20-CS-4003-001 |
Organization of Programming Languages |
Fall 2017 |
---|---|---|

Monads |

Prev
Next
All lectures
Code

**Basics**

import Control.Monad f = (\ x -> if (x == 0) then fail "zero" else Just (x+1)) v1 = Just 5 >>= f v2 = Just 0 >>= f v3 = Nothing >>= f v4 = f 0 v5 = f 5 va = (return 3) :: Maybe Int vb = (return 3) :: [Int] vb = getLine >>= (\x -> return (x ++ x)) >>= print v6 = ap [(+1),(+2),(+3)] [1,2,3] v7 = fail "test" :: Maybe Int v8 = fail "test" :: Maybe [Int] v9 = fail "test" :: IO () v10 = filterM (\x -> Just (x > 0)) [2, 1, 0, -1] (./.) :: Fractional a => a -> a -> Maybe a x ./. 0 = Nothing x ./. y = Just (x / y) divide :: Fractional a => a -> [a] -> Maybe a divide x ys = foldM (./.) x ys v11 = divide 128 [2,4,8] v12 = divide 8 [2,3,4,0,6,7] v13 = guard True >> Just 3 v14 = guard False >> Just 3 v15 = liftM head (Just [23,24,25]) v16 = liftM tail (Just [23,24,25]) v17 = mzero :: [Int] v18 = mzero :: Maybe Int v19 = mplus "a" "b" v20 = mplus (Just "a") (Just "b") v21 = mplus (Just 10) (Just 20) v22 = mplus mzero (Just 10) v23 = mplus (Just 10) mzero v27 = sequence [print 1, print 2, print 3] >>= print v28 = sequence [Just 1, Just 2, Just 3] v29 = unless (0 == 1) (print "OK") v30 = unless (1 == 1) (print "OK") |
- |
If you have a value with a context, m a, how do you apply to it a
function that takes a normal a and returns a value with a context?
That is, how do you apply a function of type a -> m
bm a? So essentially, we will want this function:
(>>=) :: (Monad m) => m a -> (a -> m b) -> m bMonads are just applicative functors that support >>=
(called bind). The >>= operator either returns
"Nothing" if it is passed "Nothing" on it's left-hand side; or if it's
left-hand side is a "Just ..." it strips off the Just, and passes the
contents into the function supplied on it's right-hand side. In the top
examples to the left v1 and v5 have value Just
6;
v2, v3, and v4 have value Nothing.
The inferred type of f is f :: Integer -> Maybe
Integerfail.
The operator
The
The
The operator
The operator
The operator
The operator
The operator
The operator
The operator
The operator
The operator
The operator v28 displays
Just [1,2,3]. The type of sequence is
sequence :: Monad m => [m a] -> m [a]
The operator
The operator Monads are useful in any situation where the programmer wants to carry out a purely functional computation while a related computation is carried out on the side. In imperative programming the side effects are embedded in the semantics of the programming language; with monads, they are made explicit in the monad definition, thus avoiding errors by action at a distance. |