Notes on working monadically
20 Jun 2014You can do little bits and pieces in your Haskell code to take it from an imperative looking style to being more concise and monadic in your approach. In today’s post, I’m going to run through a small sample of functions that should help this process greatly.
One final thought is that it’s not so much the use of these functions that’s important; it’s more the change in thought process to put you in a position where these functions become effective is where the true power lies.
»=
The >>= function (pronounced “bind”) sequences operations together by passing the result of what’s on the left hand side, to the right hand side. >>= looks like this:
(>>=) :: Monad m => m a -> (a -> m a) -> m b>>= is asking for:
awhich is a value wrapped in a monad(a -> m a)which is a function accepting a value and returning a wrapped value
An example of this in action looks like this:
-- | Returns a string in context of a monad
ns :: Monad m => m [Char]
ns = return $ "Hello"
-- | Prints a string to the console
putStrLn :: String -> IO ()
-- Using bind
ns >>= putStrLnWhat’s going on in the above snippet is that >>= has unwrapped the string returned by ns from its IO monad so that it’s just a string. >>= has then applied this raw value to putStrLn.
=«
The =<< function performs the same role as >>= only it has its parameters flipped.
putStrLn =<< nsliftM
liftM allows you to promote a function to a monad. Here’s what it looks like
liftM :: Monad m => (a1 -> r) -> m a1 -> m r(a1 -> r) is what will get lifted into the monad, so we can keep our code that does work free of any monad awareness.
Where I have found that this is useful is when you have a set of functions that don’t operate on wrapped values, and you’d like to sequence them monadically.
My initial attempts to do this look like this:
-- | Collects all of the successfully read contents of
-- of the read files into an array of targets
allContents :: [String] -> IO [Target]
allContents paths = do
rs <- safeReadFiles
let cs = map parseSentinelFile (catMaybes rs)
return $ concat $ rights cs
where safeReadFiles = mapM safeReadFile pathsThis reads like a big blob of imperative glug! So, I thought that all of these pieces could be sequenced together and chained with >>=. Here’s what I got:
allContents paths = mapM safeReadFile paths
>>= return . catMaybes
>>= return . mapParseSentinelFile
>>= return . rights
>>= return . concatWell, at least the code is sequenced - but all of those returns sure are annoying. Here’s where liftM comes in. With liftM, we can compose all of those functions without needing to know anything about the monad that it’s executing in. Here’s what I’ve ended up with:
allContent paths = liftM p (mapP safeReadFile paths)
where p = concat . rights . map parseSentinelFile . catMaybesliftM has allowed us to express our function chain using . as function composition. liftM then handles all of the monadness for us!
»
The >> function performs he same sequencing as what >>= does, only the first action specified is discarded. >> looks like this:
(>>) :: Monad m => m a -> m b -> m bThis particular function comes in handy where you’re interested in not passing along a result from certain links in your sequencing chain, like this:
putStrLn "Hello. What is your name? " >> getLine
>>= putStr
>> putStrLn "! That's a great name"From this particular sequence, you can see that
- The action emitted from the first
putStrLnis dropped - The action emitted from
getLineis passed ontoputStr - The action emitted from
putStris dropped - The last action terminates the sequence
sequence
sequence will evaluate all of the actions passed to it from left to right and return out the results of these actions. It’s defined like this
sequence :: Monad m => [m a] -> m [a]What this allows you to do is something like this
sequence [putStr "What's your name? " >> getLine
,putStr "What's your age? " >> getLine
,putStr "What's your favourite colour? " >> getLine
]This will then give you back an array of the IO actions emitted from each array index.
sequence_ will perform the same task as what sequence does, only it’ll throw away the result.
mapM
mapM will allow you to perform a monadic action over a list of normal (or unwrapped) values. It looks like this
mapM :: Monad m => (a -> m b) -> [a] -> m [b]mapM wants:
- A function that takes an unwrapped value
aas its first parameter and returns a wrapped valuem b - A list of unwrapped values
[a]
It will then give you back a list of wrapped outputs m [b]. So, this allows you to do something like this
-- our list of unwrapped values
let questions = ["What's your name? ", "What's your age? "]
-- print out each question and ask for a response
mapM (\q -> putStr q >> getLine) questionsAlso notice that in the lambda above (\q -> putStr q >> getLine), we’ve used the >> function from above as we don’t care for the action emitted from printing a string to the console.
mapM_ will perform the same task as what mapM does, only it’ll throw the result away.
filterM
filterM will filter a list based on a Bool wrapped in an action. Here’s how filterM is defined
filterM :: Monad m => (a -> m Bool) -> [a] -> m [a]filterM will execute an action (a -> m Bool) that wants an a as its input and returns you a wrapped m Bool which will determine which a’s in the passed list [a] end up in the resulting wrapped list m [a]. Mouthful, I know. Here’s an example
filterM (\_ -> randomIO >>= return . even) [1..50]The lambda here (\_ -> randomIO >>= return . even) actually ignores the input parameter by using \_. It’s using randomIO to grab a number out of the hat which is then bound to (return . even), which will return a wrapped Bool of if the number supplied by randomIO is even or not.
There’s heaps more that you can do. Just check out the Control.Monad namespace of the base library for some more. That’s it for today though!