[RFC] should we add callbacks to the useMap and useMapsLibrary hooks?

[usefulthink]

An Idea for how to simplify the typical use-cases of the useMap and useMapsLibrary hooks just crossed my mind and I would love to hear what others think about this.

The most common use-case for the useMap hook follows this pattern:

function Component() {
    const map = useMap();

    useEffect(() => {
        if (!map) return;

        // do stuff with the map instance

        return () => {
            // cleanup might be needed
        };
    }, [map]);

    return ...;
}

This can be simplified if we move the useEffect into the useMap hook, allowing users to shorten the code to

 function Component() {
    useMap((map) => {
        // do something with the map instance
        
        return () => {
            // cleanup
        }
    });
 }

The biggest issue with this would be that we can't specify the dependencies for the effect in a clean way, so I guess an alternative would be to put this into a new hook useMapEffect() which would follow the structure of useEffect() and make the semantics of the dependencies array and the returned cleanup-function a bit clearer:

function Component() {
    useMapEffect((map) => {
      // do stuff with map

      return () => { 
        // cleanup
      };
    }, [some, additional, dependencies]);
}

Something similar can be done for the typical use-case of useMapsLibrary:

function Component() {
    const [service, setService] = useState(null);
    const placesLib = useMapsLibrary('places');
    
    useEffect(() => {
        if (!placesLib) return;

        setService(new placesLib.PlacesService());
    }, placesLib);
}

Since the cleanup-function will typically not be needed with useMapsLibrary, we could go even one step further and pass through the value returned by the callback, so the example above would become:

function Component() {
    const placesService = useMapsLibrary('places', 
      placesLib => new placesLib.PlacesService()
    );
}

what do you think about these? Is that too far from what react usually does or could those be useful?

[usefulthink]

/cc @leighhalliday would love to hear your thoughts on this if you can spare a few minutes. Note that I'd want to implement this in a fully backward compatible way.