[Haskell-cafe] do

[Luke Palmer]

Disclaimer:  I'm explaining all of this in terms of "actions", which
are only one way of looking at monads, and the view only works for
certain ones (IO, State, ...).  Without futher ado...

An action does two things:  it has a side-effect and then it has a
return value.  The type "IO Int" is an I/O action which does something
then returns an Int.

(>>) :: m a -> m b -> m b

x >> y  first does x, *discards* its return value, then does y.  You
can see that the return value of x is discarded by the absence of the
type variable a in the return value of (>>).  So if you said:

    getLine >> putStrLn "Hello"

This is an action which gets a line from the user and then throws it
away, never to be retrieved again, only to print Hello.

(>>=) :: m a -> (a -> m b) -> m b

But what if you want to do something with the return value?  That's
what (>>=) is for.  (>>=) takes an action on its left side and a
function which returns an action on its right, and then "pipes" one
into the other.

    getLine >>= (\x -> putStrLn x)

This gets a line from the user and then executes the function on the
right given the return value from getLine as an argument; i.e. x is
bound to the return value of getLine.  The above can also be written
as:

    getLine >>= putStrLn

Because of currying.  This action echoes one line.

Using this you can do more complex actions, like, for instance, adding
two numbers:

    readLine >>= (\x -> readLine >>= (\y -> print (x + y)))

Take a moment to grok that...

Which you might like to write:

    do x <- readLine
       y <- readLine
       print (x + y)

The parser sequencing thing is probably from the List monad (unless
you're using Parsec or something).  List was the first monad I really
understood (before IO even), thanks to this great tutorial:

http://www.haskell.org/haskellwiki/Monads_as_containers

Luke