> ( * ) <$> Just 2 < * > Just 8<p>I would have written "Just 16."<p>> Nothing >>= \x -> return (x * 10)<p>I would have written "Nothing." Actually, that about sums it up.<p><i>Edit</i>: just to expand on the above with some commentary, his examples are all basically as if he saw a salad in a bag, decided he wanted a salad, and proceeded to buy all the ingredients from separate bags, stick them in one big bag, open them all from inside the other bag and mix them together. In practice, you just don't need to do things this way.<p>The first example is treating Maybe as an applicative functor. In practice, when someone does this, they don't use a bare operator like ( * ). Suppose I want to read in an integer from the user. Which is easier to understand?<p><pre><code> x <- getLine >>= return . read
</code></pre>
or<p><pre><code> x <- read <$> getLine
</code></pre>
This is the usual way <$> is used, not his way. You could even get some mileage out of using monads with the do notation, by doing something more like:<p><pre><code> x <- getLine
return $ read x
</code></pre>
Same with the next example:<p><pre><code> x <- Just 2
y <- Just 8
return $ x * y
</code></pre>
but there's no intrinsic reason to instead write that as he did.<p>Similarly, his second example reads much better when you consider the do notation:<p><pre><code> x <- Nothing
return $ x * 10
</code></pre>
In fact, even using the syntax he proposes on the other line produces a more readable example:<p><pre><code> Nothing >>= return . (*10)
</code></pre>
If you don't understand what's going on with his second example, you should brush up on monads. You don't need to understand applicative functors to get things done, but they do make life better when used in moderation.