getLine在Haskell中如何工作？

Question

Looking at the definition of getLine in the Haskell Prelude , I get how the recursion works, where you keep asking for a character until you hit a newline and you buildup a list which you then return wrapped in an IO.

However my question is how do the return statements work in this case, specifically how does return (c:....:return "") work when you hit the base case. How do you cons a return "" on to a list?

Answer 1

return isn't a control structure like in most languages. It's a constructor for monadic values. Let's take a look at its type:

return :: Monad m => a -> m a

In this case, given a String value, it produces a IO String value.

The fact that return is the last expression evaluated in each branch of the if doesn't mean return ends execution; other expressions could occur after return . Consider this simple example from the list monad:

foo :: Int -> Int -> [Int]
foo x y = return x ++ return y

In the list monad, return simply creates a new single-item list containing its argument. Those two lists are then concatenated into the final result list returned by the function.

$ return 3 :: [Int]
[3]
$ foo 3 4
[3,4]

Answer 2

do -notation is a syntax sugar.

do x <- e
   rest

is equivalent to

e >>= \x -> rest

where >>= is a flatMap or bind operation (it attaches a callback to IO container).

flatMap :: IO a -> (a -> IO b) -> IO b meaning is: given container of type IO a attach a callback of type a -> IO b , fired when container succeeds in its operation, and this produces a new container of type IO b

So

getLine =
    getChar >>= \c ->
        if c == '\n'
        then (return [])
        else getLine >>= \rest ->
             return (c : rest)

What is means? getLine immediately delegates execution to getChar IO -container, with a callback, which analyses the character passed to it. If its a newline, it does " return "" ", which is a construction of IO -container, returning empty String immediately. Otherwise, we call ourselves, grab the rest and return current c haracter attached to rest .

PS: return is used to turn a pure value into container, since Monad interface doesn't allow us to bind non-container-producing callbacks (there are very good reasons for this).