# “Lambda” notation

A lambda is an anonymous function. Normally when you define a function, you write its name first, then parameter, then the body.

square1 x = x*x

To make it anonymous, you omit the name, and instead use a backslash (which looks a bit like a Greek lowercase lambda: λ).

\x -> x*x

This is an expression not a definition – you wouldn’t write just that at the top-level in a Haskell file. However you could still bind the expression to a name:

square2 = \x -> x*x

You can consider this to be an alternative syntax for a function definition. But the lambda notation is most useful for passing to higher-order functions.

For example, when we do something like these examples:

ghci> map square2 [2..4]
[4,9,16]
ghci> map (*8) [2..4]
[16,24,32]

We are passing functions to map. In the first example, it’s a named function, square1. In the second example we use a section on an operator to produce a function. A more general way to specify a function in that position is a lambda expression:

ghci> map (\x -> 2*x*x + 3*x - 4) [5..10]
[61,86,115,148,185,226]

Here, the lambda expression represents the polynomial $$2x^2 + 3x - 4$$, and we have evaluated for each $$x$$ in the given range.

The operator section notation can now be seen as just a shortcut for a lambda expression:

• (*2) is equivalent to (\x -> x*2)
• (3-) is equivalent to (\x -> 3-x)

A type is a monad m if it provides the following two operations:

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

The operator (>>=) is pronounced as “bind”, “andThen”, or sometimes “flatMap”. The most well-understood monad types are Maybe and lists. If we specialize the types above to Maybe and [], they are:

return :: a -> Maybe a
(>>=) :: Maybe a -> (a -> Maybe b) -> Maybe b

return :: a -> [a]
(>>=) :: [a] -> (a -> [b]) -> [b]

We saw the Maybe version of this in Assignment 4, where I had you implement it as andThen. It’s used to sequence together operations that may fail.

Here’s a rather contrived example where someone wants to log in to their bank account, check their balance, and then transfer some money. Each of those operations can fail, so each function returns Maybe.

login :: String -> String -> Maybe Int  -- returns session ID
then Just (length user)      -- fake a session ID
else Nothing
checkBalance :: Int -> Maybe Float
checkBalance sessionId =
if odd sessionId        -- suppose even session IDs are offline
then Just 215.38
else Nothing
transfer :: Float -> Float -> Maybe Float
transfer amount balance
| amount <= balance = Just (balance - amount)
| otherwise = Nothing

So we sequence them together as follows, and each can fail for different reasons.

-- Works:
ghci> login "joe" "eoj" >>= checkBalance >>= transfer 50
Just 165.38

-- Fails because Joe doesn't have \$500 to transfer
ghci> login "joe" "eoj" >>= checkBalance >>= transfer 500
Nothing

-- Fails because Fran's session ID is offline
ghci> login "fran" "narf" >>= checkBalance >>= transfer 50
Nothing

-- Fails because Bob has wrong password
ghci> login "bob" "secret" >>= checkBalance >>= transfer 50
Nothing

Of course, the unfortunate thing about Maybe in this example is that it can’t directly tell us which step in the pipeline went wrong. But Either also forms a Monad, so you could try using Left to display error messages!

Here’s a simple example of using (>>=) on a list of strings.

ghci> ["hello world", "this is a test", "bye for now"] >>= words
["hello","world","this","is","a","test","bye","for","now"]

Compare it to using map, where each word list stays together

ghci> map words ["hello world", "this is a test", "bye for now"]
[["hello","world"],["this","is","a","test"],["bye","for","now"]]

and you perhaps you can see why it’s sometimes called flatMap.

Last week when we worked with threading state through a calculation or traversal, we defined a state function with a type like s -> (r, s) where s is the state and r is the result. It turns out that this function type is itself a monad.

Substitute m a in the monad operations with s -> (a, s) and you get:

return :: a -> s -> (a, s)
(>>=) :: (s -> (a, s)) -> (a -> s -> (b, s)) -> s -> (b, s)

We can actually write these functions, but we’ll name them a little differently so they don’t conflict with the real ones:

returnState :: a -> s -> (a,s)
returnState result state = (result, state)
bindState :: (s -> (a, s)) -> (a -> s -> (b, s)) -> s -> (b, s)
bindState action1 action2 state0 = (result2, state2)
where (result1, state1) = action1 state0
(result2, state2) = action2 result1 state1

Notice the usual careful state-passing in the where clause of the bindState function. That little bit of state-passing logic turns is sufficient to encode everything we need to build more elaborate stateful functions.

For example, the function threeRandoms becomes:

threeRandoms :: Seed -> ([Integer], Seed)
threeRandoms =
rand bindState \r1 ->
rand bindState \r2 ->
rand bindState \r3 ->
returnState [r1, r2, r3]

This has the same type as the threeRandoms we did list week, but all the state-passing is hidden. It’s done transparently by bindState and returnState, and we get exactly the same results.

ghci> threeRandoms (Seed 3453)
([58034571,429459059,225867046],Seed {unSeed = 225867046})
data Seed = Seed { unSeed :: Integer }
deriving (Eq, Show)
rand :: Seed -> (Integer, Seed)
rand (Seed s) = (s', Seed s')
where
s' = (s * 16807) mod 0x7FFFFFFF
main = putStrLn "OK"