在Haskell中实现List＃flatten

Question

Scala offers a List#flatten method for going from List[Option[A]] to List[A] .

scala> val list = List(Some(10), None)
list: List[Option[Int]] = List(Some(10), None)

scala> list.flatten
res11: List[Int] = List(10)

I attempted to implement it in Haskell:

flatten :: [Maybe a] -> [a]
flatten xs = map g $ xs >>= f

f :: Maybe a -> [Maybe a]
f x = case x of Just _  -> [x]
                Nothing -> []

-- partial function!
g :: Maybe a -> a
g (Just x) = x

However I don't like the fact that g is a partial, ie non-total, function.

Is there a total way to write such flatten function?

Answer 1

Your flatten is the same as catMaybes (link) which is defined like this:

catMaybes :: [Maybe a] -> [a]
catMaybes ls = [x | Just x <- ls]

The special syntax Just x <- ls in a list comprehension means to draw an element from ls and discard it if it is not a Just . Otherwise assign x by pattern matching the value against Just x .

Answer 2

A slight modification of the code you have will do the trick:

flatten :: [Maybe a] -> [a]
flatten xs = xs >>= f

f :: Maybe a -> [a]
f x = case x of Just j  -> [j]
                Nothing -> []

If we extract the value inside of the Just constructor in f , we avoid g altogether.

Incidentally, f already exists as maybeToList and flatten is called catMaybes , both in Data.Maybe .

Answer 3

One could quite easily write a simple recursive function which goes through a list and rejects all the Nothing s from the Maybe monad. Here's how I'd do it as a recursive sequence:

flatten :: [Maybe a] -> [a]
flatten [] = []
flatten (Nothing : xs) =     flatten xs
flatten (Just x  : xs) = x : flatten xs

However, it may be clearer to write it as a fold:

flatten :: [Maybe a] -> [a]
flatten = foldr go []
    where go  Nothing xs =     xs
          go (Just x) xs = x : xs

Or, we could use a blindingly elegant solution thanks to @user2407038, which I'd recommend playing around with in GHCi to work out the individual functions' jobs:

flatten :: [Maybe a] -> [a]
flatten = (=<<) (maybe [] (:[])

And it's faster, folded brother:

flatten :: [Maybe a] -> [a]
flatten = foldr (maybe id (:))

Your solution is halfway there. My suggestion if to rewrite your function f to use pattern matching (like my temporary go function), and enclose it in a where statement to keep relevant functions in one place. You've got to remember the differences in function syntax within scala and Haskell.

The big problem you're having is you don't know the differences I've mentioned. Your g function can use pattern matching with multiple patterns:

g :: Maybe a -> [a]
g (Just x) = [x]
g  Nothing = []

There you go: your g function is now what you call 'complete', though more accurately, it would be said to have exhaustive patterns .

You can find more about function syntax here .