Documentation

Desugar into lambdas then normalize the lambdas.

Adds the "module Main where" if no module given (but not the "main" export).

Desugar record type defs, field accessors, record patterns, record construction expressions, and record update syntax.

R {f = a}

becomes

R _ a _

and

r { f = a }

becomes

case r of R x0 _ x1 -> R x0 a x1

Turns Specials into normal identifiers.

Removes parens in types, expressions, and patterns so they don't confuddle everything.

Turns sections and infix ops into regular applications and lambdas.

TODO Apparently this should actually desugar to guards:

f (-k) = v

is actually sugar for

f z | z == negate (fromInteger k) = v

Turns tuples into applications of a tuple constructor (also in types and pats):

(x, y, z)

becomes

((,,) x y z)

Turns piece-wise function definitions into a single PatBind with a lambda and case expression on the RHS. E.g.:

f p1 p2 = rhs1
f q1 q2 = rhs2

becomes

f = \ $1 $2 -> case ($1, $2) of { (p1, p2) -> rhs1; (q1, q2) -> rhs2 }

Turns

case e of {...}

into

(\ x -> case x of {...}) e

Turn cases with multiple alts into cases with two alts: an alt with a pattern and another with a default, wildcard branch.

case x of
  p1 -> e1
  p2 -> e2
  p3 -> e3

becomes

case x of
  p1 -> e1
  _  -> case x of
          p2 -> e2
           _ -> case x of
                  p3 -> e3
                   _ -> undefined

Should run after function desugarage. From the Haskell 98 report:

case v of
  p | g1 -> e1
    | gn -> en where { decls }
  _    -> e'

becomes

case e' of
  y -> case v of
    p -> let { decls } in
      if g1 then e1 else if gn then en else y
    _ -> y

Turns where clauses into lets. Only valid after guard desugarage. E.g.:

f x = a where a = b

becomes

f x = let a = b in a

Turns do-notation into a series of >>= \ x ->. Turns LetStmts into Lets. E.g.:

do p1 <- m
   let p2 = e
   return e

becomes

m >>= (\ p1 -> (let p2 = e in return e))

Turns the type a -> b into (->) a b.

Turns Lets into Cases. Assumes functions in Lets are already desugared. E.g.:

let p = e1
    q = e2
in e3

becomes

case e1 of { p -> (case e2 of { q -> e3 } }

Turns ifs into cases.

if e1 then e2 else e3

becomes

case e1 of { True -> e2; False -> e3 }

Turns Lambdas with several bindings into several lambdas with single bindings. E.g.:

\ p1 p2 -> e

becomes

\ p1 -> \ p2 -> e

Replaces non-var patterns in lambdas with a fresh var and a case. E.g.:

\ (a, b) -> e

becomes

\ $x -> case $x of { (a, b) -> e }

Desugars as-patterns in (and only in) cases into more cases. Should run after depatLambdas. E.g.:

case e1 of
  x@(C y@p) -> e2

becomes

case e1 of { C p -> (\ x -> ((\ y -> e2) p)) (C p) }

Turns beta-redexes into cases. E.g.:

(\ x -> e2) e1

becomes

case e1 of { x -> e2 }