Why does the type match on the next line but not on the same line in `do` block?

Question

I’m reading in several lines from the input that the user has to type:

main :: IO ()
main = do
  let size = 3
  arr <- replicateM size getLine
  let pairs = map parsePair arr
  print pairs

Why am I allowed to do map parsePair arr on a separate line but not on the same line, like this:

arr <- map parsePair (replicateM size getLine)

Doing so, I get the error :

• Couldn't match type ‘[]’ with ‘IO’
  Expected type: IO [Int]
    Actual type: [[Int]]

To give you more details, here is parsePair:

parsePair string = map parseInt $ words string

parseInt :: String -> Int
parseInt s = read s :: Int

Instead of the non-working `arr <- map parsePair $ replicateM size getLine` you can use the similar `arr <- map parsePair <$> replicateM size getLine` (`<$>` is `fmap`). — chi, Aug 14 '19 at 13:35
Consider also `replicateM size getLine >>= print . map parsePair` — Khuldraeseth na'Barya, Aug 14 '19 at 14:02
see [`do` notation primer](https://stackoverflow.com/a/11326549/849891) with a [picture](https://i.stack.imgur.com/oKZgV.jpg), by user:[pigworker](https://stackoverflow.com/users/828361/pigworker) — Will Ness, Aug 14 '19 at 14:08

score 7 · Accepted Answer · answered Aug 14 '19 at 11:52

7

Because the type of replicateM size getLine is IO [String], it is not a list of Strings, it is basically a description of an IO action that will obtain a [String]. You can see the arrow <- in an IO monad as a way to retrieve it and unpack the result.

You can however do some processing on that like, since IO is a Functor as well, you can make use of fmap :: Functor f => (a -> b) -> f a -> f b:

main :: IO [Int]
main = do
  let size = 3
  fmap (map parsePair) (replicateM size getLine)

or you can shift the fmap to the getLine part:

main :: IO [Int]
main = do
  let size = 3
  replicateM size (fmap parsePair getLine)

Note that there is a readLn :: Read a => IO a function that is basically fmap read getLine (except that it does some addional error handling). We can thus use:

main :: IO [Int]
main = do
  let size = 3
  replicateM size readLn

answered Aug 14 '19 at 11:52

Willem Van Onsem

443,496
30
428
555

Thanks for the details. But I’d like to understand why it works without `fmap` if I just do that on the next line – Albizia Aug 14 '19 at 11:56
@Albizia: as said, because the arrow `<-` will obtain the result from that `IO a`. It is not the new line here, it is the fact that you used `arr <- ...`, and then processed the `arr`. – Willem Van Onsem Aug 14 '19 at 11:57
Oh, I see. I didn’t understand that part of the answer. thanks. – Albizia Aug 14 '19 at 11:58

score 7 · Answer 2 · answered Aug 14 '19 at 12:07

Note that the do syntax with the <- symbol is really not like the assignment operator (which is = in many languages, sometimes := and sometimes indeed <-, e.g. in R). Rather, it's a special construct that executes a monadic action and extracts the result of this action. There is is a fundamental distinction between an action and its result; and often-quoted analogy is that an action is like a recipe for a cake, the result is the cake itself.

applying map parsePair directly to the IO action would be like taking a knife to cut the recipe in pieces, and expecting that you can then use that recipe to bake a ready-cut cake. Clearly that's not how it works.

Likewise, you first need to execute (bind) an IO action before you can manipulate the result. That's what happens on the line arr <- replicateM size getLine: the action is executed and only its result stored in arr, so that you can then write map parsePair arr.

Alternatively, you can use the fmap operator. What this does is basically, it takes a recipe and some instruction what to do with the result, and then adds that instruction to the end of the recipe. If you then execute that recipe, the result of it will indeed be a cake cut into pieces.

Why does the type match on the next line but not on the same line in `do` block?

2 Answers2