Today we’ll play around with the following task:
Write a program that will receive a number N as an input, and that then will do additional N reads and print them out.
So first, let’s see how we can do this with a static number of times, say 3:
*Main> (readLn :: IO Int) >>= \x -> return $ x : []
1
[1]
*Main> (readLn :: IO Int) >>= \x -> (readLn :: IO Int) >>= \y -> return $ x : y : []
1
2
[1,2]
*Main> (readLn :: IO Int) >>= \x -> (readLn :: IO Int) >>= \y -> (readLn :: IO Int) >>=
\z -> return $ x : y : z : []
1
2
3
[1,2,3]
*Main>
So what we need, is a function that will take a number as an input, and spit list of IO Ints as an output.
There are 2 ways to do this, and we’ll do both and then discuss the difference between them.
pn :: Int -> [IO Int]
pn' :: Int -> IO [Int]
What pn does, is returns a list of IO actions that need to be executed (which we can execute with sequence for example).
pn’ on the other hand, returns an IO action of list of numbers.
So we can view pn’ as one IO action that returns a list of numbers, and pn as a list of IO actions that return a number. Pretty simple!
Let’s start with pn. To cover the base case, we say that pn = 0 will return an empty list of actions. Note that [] is [IO Int] here, not [Int].
pn 0 = []
For the inductive step, we store the *read a number using readLn* action in a list (but not execute it), and then append that action to the list. Note that x is IO Int here, not Int.
pn n = do
-- No need for explicit signature here because Haskell already knows this by the fn signature
let x = readLn :: IO Int
x : pn (n - 1)
Now, to execute this, we can do:
*Main> sequence $ pn 3
1
2
3
[1,2,3]
*Main>
And what is sequence?
*Main> :t sequence
sequence :: Monad m => [m a] -> m [a]
sequence [] = return []
sequence (x:xs) = do v <- x; vs <- sequence xs; return (v:vs)
*Main>
So, sequence takes a list of monads (IO actions in this case), executes each one of them and returns their result *combined*.
pn’ is the same implementation as pn, but with sequence _within_ it so that we don’t have to call sequence each time.
pn' :: Int -> IO [Int]
pn' 0 = return []
pn' n = do
x <- readLn
xs <- pn' (n - 1)
return $ x : xs
For the base case, we need a monadic empty list, that is:
*Main> :t return
return :: Monad m => a -> m a
*Main> :t (return []) :: IO [Int]
(return []) :: IO [Int] :: IO [Int]
For the inductive step, we are reading a number into x, i.e. executing the read action with <- (in contrast to =). Note that x is Int here, not IO Int.
Then, we recursively call pn’ to read for more numbers, and store those executed reads in xs. Note that xs is [Int] here.
After that, we return x:xs in order to get a IO [Int] instead of [Int].
We can now call it like:
*Main> pn' 3
1
2
3
[1,2,3]
*Main>
Let’s try to unwrap this call:
test :: IO [Int]
test = do
x' <- readLn
xs' <- do
x'' <- readLn
xs'' <- do
x''' <- readLn
xs''' <- return []
return $ x''' : xs'''
return $ x'' : xs''
return $ x' : xs'
And that’s how it works. Or, we can rewrite everything as:
Prelude> let pn'' n = sequence $ take n $ repeat (readLn :: IO Int)
Prelude> pn'' 5
1
2
3
4
5
[1,2,3,4,5]
Prelude>
But it’s worth knowing what it does behind the scenes 🙂
We can now extend this function to accept an additional parameter (function), that will do something to the read value:
pn''' :: Int -> (Int -> Int) -> IO [Int]
pn''' 0 _ = return []
pn''' n f = do
x <- readLn
xs <- pn'' (n - 1) f
return $ (f x) : xs
And call it like:
*Main> pn''' 5 succ
1
2
3
4
5
[2,3,4,5,6]
*Main>
bor0's reflective blog 