Question

findM :: Monad m => (a -> m Bool) -> m [a] -> Maybe (m a)

I cannot implement it by myself. I could use some pointers

find looks like:

find f as = listToMaybe $ filter f as

so I tried:

findM f as = filterM f as >>= listToMaybe

but it doesnt work.

Answer 1

No. It is not possible. However, you can write a function with the signature:

findM :: Monad m => (a -> m Bool) -> m [a] -> m (Maybe a)

The reason it is not possible is because in order to figure out if the Maybe has constructor Just x or Nothing, you have to get the value out of the monad. Which means that the Maybe must be inside the monad at the end, since it is not possible in general to extract a value from inside a monad. (That is the whole point of monads, after all.)

For example, given your signature to findM, you could write some obviously incorrect functions:

findM :: Monad m => (a -> m Bool) -> m [a] -> Maybe (m a)
findM = magic
anyM :: Monad m => (a -> m Bool) -> m [a] -> Bool
anyM f = isJust . findM f
extractBool :: Monad m => m Bool -> Bool
extractBool = anyM id . liftM (:[])

The function extractBool is obviously impossible, so findM cannot have that signature.

Here is an implementation of findM:

findM :: Monad m => (a -> m Bool) -> [a] -> m (Maybe a)
findM _ [] = return Nothing
findM f (x:xs) = do y <- f x
                    if y then return (Just x) else findM f xs

I am not sure of a simpler way to implement it — this seems fairly clean, and it works on infinite lists.

Changing the signature from using an m [a] to using [a] makes it more useful and easier to use. You’ll quickly figure out why, if you implement both interfaces.