Nested do syntax

Question

In this question Will's answer states that the following code (let's call it code A):

reverse2lines :: IO () 
reverse2lines = 
 do line1 <- getLine 
    line2 <- getLine
    putStrLn (reverse line2) 
    putStrLn (reverse line1)

can be transformed into the following (let's call it code B) :

reverse2lines = 
 do { line1 <- getLine ;
      do { line2 <- getLine ;
           do { putStrLn (reverse line2) ;
                do { putStrLn (reverse line1) } } } }

I am confused. I understand, for example, that

addOneInt :: IO () 
addOneInt = do line <- getLine
               putStrLn (show (1 + read line :: Int))

can be transformed into:

addOneInt' :: IO ()
addOneInt' = getLine >>= \line ->
             putStrLn (show ( 1 + read line :: Int))

But I don't understand how the nested do transformation works. In other words, I don't understand how one arrives from code A to code B ? What are the rules governing this transformation ?

Where are these rules described / explained / specified ?

Could someone please explain what is going on here with this (codeA to codeB) transformation ?

For example, what does do { command1; do {command2 } } mean ? How should I interpret that ? What is its definition ?

In other words,

what is the difference between

do {command1;command2} and

do {command1; do {command2}} ?

Furthermore, what is the difference between

do {command1; do{command2};command3} and

do {command1;do {command2; do {command3}}} ?

Thanks for reading.

A hint, `do single_expr` is exactly the same as `single_expr`. So `do { cmd1; cmd2 }` and `do { cmd1; do {cmd2} }` are identical. To put it another way, the `hlint` tool that checks your code for stylistic problems will flag `do single_expr` as a redundant `do`, and tell you to remove it since it is unnecessary. — bheklilr, Apr 15 '14 at 17:53
The next thing to remember is that `do { cmd1; cmd2 }` is the same as `cmd1 >> cmd2`, which is the same as `cmd1 >>= \_ -> cmd2`. So that means that `do { cmd1; do { cmd2 } } === do { cmd1; cmd2 } === cmd1 >> cmd2 === cmd1 >>= \_ -> cmd2`. — bheklilr, Apr 15 '14 at 18:00

score 5 · Accepted Answer · answered Apr 15 '14 at 18:01

5

Just treat the do expressions completely separately: nesting them does not change how they get desugared. For your to example, we can start with the bottom line:

reverse2lines = 
 do { line1 <- getLine ;
      do { line2 <- getLine ;
           do { putStrLn (reverse line2) ;
                putStrLn (reverse line1) } } }

then the next one:

reverse2lines = 
 do { line1 <- getLine ;
      do { line2 <- getLine ;
           putStrLn (reverse line2) >> putStrLn (reverse line1) } }

which is, in fact, just like:

reverse2lines = 
 do { line1 <- getLine ;
      do { line2 <- getLine ;
           putStrLn (reverse line2)
           putStrLn (reverse line1) } }

then we can turn the inner remaining do into a lambda:

reverse2lines = 
 do { line1 <- getLine ;
      getLine >>= \ line2
       putStrLn (reverse line2) >>
       putStrLn (reverse line1)  }

And then, if we go backwards, we see that it's the same as just:

reverse2lines = 
 do { line1 <- getLine ;
      line2 <- getLine ;
      putStrLn (reverse line2) ;
      putStrLn (reverse line1)  }

So, as you can see by going through the whole example, the nested version is the same as the flat version. In fact, if you just look at the rules for desugaring do expressions (and we've seen the important ones), you'll see that nesting them like this does not change anything.

In fact, this is pretty natural because the way do is desugared is defined recursively: each time we desugar a single line, we recurse on all the lines following it as if they were another do expression.

answered Apr 15 '14 at 18:01

Tikhon Jelvis

67,485
18
177
214

Thanks for the answer. In the original answer (http://stackoverflow.com/questions/22909281/simple-example-on-do-syntax-transformed-to-syntax) Will said that `code A` can be directly rewritten to `code B` without using the `do` to `>>=` desugaring (he later desugared `code B` to `>>=` syntax). This is what confused me. So you say that there is no way to get from `code A` to `code B` without the use of the `do` to `>>=` desugaring rule ? – jhegedus Apr 15 '14 at 18:22
1

@jhegedus: You could just have a rule that is something like `do { x <- m; do { ... } }` ==> `do { x <- m; ... }`. That wouldn't *explicitly* use the desugaring. – David Young Apr 15 '14 at 18:25
1

@jhegedus: I'm not really sure what you mean by your question. Anyhow, since the rules for desugaring are recursive--at each step, the rest of the lines are treated like a new do-expression to desugar--you could skip the `>>=` bits. You can always nest `do` expressions like this. I just thought they were illustrative. – Tikhon Jelvis Apr 15 '14 at 18:25
In other words, in Will's answer it is implied that the code transformation from `code A` to `code B` has nothing to do with the `do` desugaring rule. – jhegedus Apr 15 '14 at 18:25
@jhegedus I'm not totally sure what you mean. `do` notation gets turned into `>>=` and `>>` internally by the compiler, so it can't really ever be considered totally independent from those methods. – David Young Apr 15 '14 at 18:26
@David Young : But that would implicitly still need the desugaring rule right ? – jhegedus Apr 15 '14 at 18:27
I see, thanks, I think I got confused by the accepted answer in the original question. That answer might be perhaps a little bit misleading. – jhegedus Apr 15 '14 at 18:28
@jhegedus Well, yes because that is how `do` is defined. To me, this is like asking something like "can I expand '(x + y)*(a + b)' without using the distributive law." Yeah, you can just use the FOIL operation, but FOIL works because of the distributive law. – David Young Apr 15 '14 at 18:31
So here http://stackoverflow.com/questions/22909281/simple-example-on-do-syntax-transformed-to-syntax Will goes from `code A` to `code B` and then uses the desugaring on `code B` to get to a form which uses no `do` at all. This is logically misleading. It implies that one can go from `codeA` to `codeB` **without** making use of the desugaring rule but now I understand that one has to use -at least implicitly - the desugaring rule to get from `codeA` to `codeB`. – jhegedus Apr 15 '14 at 18:32
@jhegedus That doesn't seem very misleading to me at all. For one thing, he never said that you *didn't* need to desugar it to show that they are equivalent. All he said is that those two expressions are equivalent. – David Young Apr 15 '14 at 18:36
I see. Ok. Perhaps I accept it again then because that is still the best answer. I have to admit that I am quite a beginner in Haskell and get confused easily but it's great that I can get clarification on SOF :) – jhegedus Apr 15 '14 at 18:37

Nested do syntax

1 Answers1

Linked