Haskell函数组成可能

Question

I was studying Haskell idioms from Blow Your Mind

-- split at whitespace
-- "hello world" -> ["hello","world"]

unfoldr (\b -> fmap (const . (second $ drop 1) . break (==' ') $ b) . listToMaybe $ b)

From what I know, unfoldr is supposed to be:

unfoldr :: (b -> Maybe (a,b)) -> b -> [a]
unfoldr f b = 
case f b of
  Just (a, new_b) -> a : unfoldr f new_b
  Nothing         -> []

So fb must output Nothing at the end, right?

So I tried to understand the f part, fmap (const . (second $ drop 1) . break (==' ') $ b) . listToMaybe $ b) fmap (const . (second $ drop 1) . break (==' ') $ b) . listToMaybe $ b) .

I get the idea of second, drop, break, listToMaybe. But I can't figure out why composing functions like this can output Nothing.

Const always ignore the second parameter. So why fmap (const . (second $ drop1) . break (==' ') $ b) . listToMaybe $ b fmap (const . (second $ drop1) . break (==' ') $ b) . listToMaybe $ b can output Nothing in the end?

Answer 1

The type of (const . (second $ drop 1) . break (==' ')) is [Char] -> b -> ([Char], [Char])

This sophisticated function just takes a string (for example "one two three" ) and any argument and returns ("one", "two three") .

Therefore, (const . (second $ drop 1) . break (==' ')) $ "one two three" takes any argument and returns ("one", "two three") .

fmap (const . (second $ drop 1) . break (==' ') $ b) . listToMaybe $ b

is the same as

fmap (const . (second $ drop 1) . break (==' ') $ b) $ listToMaybe b

eg the function is fmapped to a Maybe value, but the definition of fmap for Maybe instance is:

instance  Functor Maybe  where
    fmap _ Nothing       = Nothing
    fmap f (Just a)      = Just (f a)

which means that fmap returns Nothing if a in fmap fa is Nothing .

listToMaybe returns Just first element of a list, or Nothing if the list is empty. That's why

fmap (const . (second $ drop 1) . break (==' ') $ b) $ listToMaybe b

will return Nothing , when b is an empty list.

Answer 2

The code is written in a confusing manner. fmap (const xyz) basically abuses Maybe a as a bool switch: if it's Just _ᴡʜᴀᴛᴇᴠᴇʀ , the result will be Just xyz , while a Nothing is simply passed on. Such a nothing can come straight from listToMaybe in case of an empty list, that's how this composition can yield Nothing .

The preferred style of writing all this would be

unfoldr (\b -> listToMaybe b *> Just (second (drop 1) (break (==' ') b)))

or indeed with good old old do notation

unfoldr $ \b -> do
    listToMaybe b
    return . second (drop 1) $ break (==' ') b

But really, an explicit pattern match would be much clearer:

{-# LANGUAGE LambdaCase #-}
unfoldr $ \case
   [] -> Nothing
   b -> Just . second (drop 1) $ break (==' ') b