28

As I'm learning Haskell I'm realizing that do notation is just syntatic sugar:

a = do x <- [3..4] [1..2] return (x, 42)

Translates into 

a = [3..4] >>= (\x -> [1..2] >>= (\_ -> return (x, 42)))

I realize that I'll probably use do-notation but I'd like to understand whats going on in translation. So purely for pedagogical reasons, is there a way for ghc/ghci to give me the corresponding bind statements for a fairly complex monad written in do-notation?

Edit. It turns out lambdabot on #haskell can do this:

<Guest61347> @undo do x <- [3..4] ; [1..2] ; return (x, 42) <lambdabot> [3 .. 4] >>= \ x -> [1 .. 2] >> return (x, 42)

Here's the source code the Undo plugin.

Improve this question
3
  • 4
    actually m >>= (\_ -> k) is m >> k Commented Nov 5, 2011 at 10:59
  • 8
    Lambdabot has an "undo" plugin that desugars do notation Commented Nov 6, 2011 at 7:54
  • 1
    I'm just learning and feel like this is key to really understanding the details of a particular instance - they are all written in terms of >>= Commented Feb 25, 2015 at 12:30

1 Answer 1

Reset to default
24

You can ask for the output of GHC's desugarer, however this will also desugar a lot of other syntax.

First, we'll put your code in a module Foo.hs:

module Foo where a = do x <- [3..4] [1..2] return (x, 42)

Next, we'll ask GHC to compile it and output the result after the desugaring phase:

$ ghc -c Foo.hs -ddump-ds

The output may look rather messy, because it is a variant of Haskell called Core that is used as GHC's intermediate language. However, it's not too hard to read once you get used to it. In the middle of some other definitions we find yours:

Foo.a :: [(GHC.Integer.Type.Integer, GHC.Integer.Type.Integer)] LclIdX [] Foo.a = >>=_agg @ GHC.Integer.Type.Integer @ (GHC.Integer.Type.Integer, GHC.Integer.Type.Integer) (enumFromTo_ag7 (GHC.Integer.smallInteger 3) (GHC.Integer.smallInteger 4)) (\ (x_adf :: GHC.Integer.Type.Integer) -> >>_agn @ GHC.Integer.Type.Integer @ (GHC.Integer.Type.Integer, GHC.Integer.Type.Integer) (enumFromTo_ags (GHC.Integer.smallInteger 1) (GHC.Integer.smallInteger 2)) (return_aki @ (GHC.Integer.Type.Integer, GHC.Integer.Type.Integer) (x_adf, GHC.Integer.smallInteger 42)))

Core isn't too pretty, but being able to read it is very useful when working with GHC, as you can read the dump after later stages to see how GHC is optimizing your code.

If we remove the _xyz suffixes added by the renamer, as well as the type applications @ Xyz and the calls to GHC.Integer.smallInteger, and make the operators infix again, you're left with something like this:

Foo.a :: [(GHC.Integer.Type.Integer, GHC.Integer.Type.Integer)] Foo.a = enumFromTo 3 4 >>= \x -> enumFromTo 1 2 >> return (x, 42)
Improve this answer
Sign up to request clarification or add additional context in comments.

7 Comments

Which begs the question... is there something out there that will automatically remove _xyz suffixes, type applications, calls to GHC.Integer.smallInteger and make operators infix again?
@missingno: None that I'm aware of. However, there are libraries available for working with either Haskell or Core on Hackage, so it shouldn't be too hard to hack something together if you want it badly enough.
The trouble is, by the time you've written the code to do that, you don't need it any more.
Just for fun, a quick and dirty do-notation desugarer for Haskell 98.
@missingno there is a flag to suppress the suffices, ghc -ddump-ds -dsuppress-uniques Foo.hs will removethem from the output. From ghc-7.2 on, there's also a -ddump-to-file flag which will make ghc dump the output into in this case Foo.dump-ds. Very useful if you want more than one dump, e.g. ghc -ddump-ds -ddump-simpl -ddump-to-file Foo will produce Foo.dump-ds and Foo.dump.simpl (btw., -ddump-simpl also provides a desugaring if you compile without optimisations).
|

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.