Declares a type synonym.

type A a b = B b a
=====
type' "A" ["a", "b"] $ var "B" @@ var "b" @@ var "a"

A newtype declaration.

newtype Const a b = Const a
=====
newtype' "Const" ["a", "b"] $ conDecl "Const" [var "a"]

A data declaration.

data Either a b = Left a | Right b
=====
data' "Either" ["a", "b"]
  [ conDecl "Left" [var "a"]
  , conDecl "Right" [var "b"]
  ]

A pattern binding.

x = y
=====
patBind (var "x") $ rhs $ var "y"

(x, y) = e
=====
patBind (tuple [var "x", var "y"]) $ rhs e

(x, y)
  | test = (1, 2)
  | otherwise = (2, 3)
=====
patBind (tuple [var "x", var "y"])
  $ guardedRhs
      [ var "test" `guard` tuple [int 1, int 2]
      , var "otherwise" `guard` [int 2, int 3]
      ]

Declares a Haskell-98-style prefix constructor for a data or type declaration.

Foo a Int
=====
conDecl "Foo" [field (var "a"), field (var "Int")]

Declares a Haskell-98-style infix constructor for a data or type declaration.

A b :+: C d
=====
infixCon (field (var "A" @@ var "b")) ":+:" (field (Var "C" @@ var "d"))

Declares Haskell-98-style record constructor for a data or type declaration.

A { x :: B, y :: C }
=====
recordCon "A" [("x", var "B"), ("y", var "C")]

An individual argument of a data constructor. Contains a type for the field, and whether the field is strict or lazy.

A field with no explicit strictness annotations.

A b
=====
field $ var "A" @@ var "b"

Give a field an explicit strictness annotation. Overrides any such previous annotations (for example, from lazy).

!(A b)
=====
strict $ field $ var "A" @@ var "b"

Give a field an explicit laziness annotation. This feature is useful in combination with the StrictData extension. Overrides any such previous annotations (for example, from strict).

!(A b)
=====
strict $ field $ var "A" @@ var "b"

A class declaration.

class (Real a, Enum a) => Integral a where
  divMod :: a -> a -> (a, a)
  div :: a -> a -> a
  div x y = fst (divMod x y)
=====
let a = var "a"
in class'
     [var "Real" @@ a, var "Enum" @@ a]
     "Integral"
     ["a"]
     [ typeSig "divMod" $ a --> a --> tuple [a, a]
     , typeSig "div" $ a --> a --> a
     , funBind "div"
         $ matchRhs [var "x", var "y"]
            $ var "fst" @@ (var "divMod" @@ var "x" @@ var "y")
     ]

A definition that can appear in the body of a class declaration.

A functional dependency for a class.

| a, b -> c
=====
funDep ["a", "b"] ["c"]

class Ident a b | a -> b, b -> a where
  ident :: a -> b
=====
class' [] "Ident" ["a", "b"]
   [ funDep ["a"] ["b"]
   , funDep ["b"] ["a"]
   , typeSig "ident" $ var "a" --> var "b"
   ]

An instance declaration.

instance Show Bool where
  show :: Bool -> String -- Requires the InstanceSigs extension
  show True = "True"
  show False = "False"
=====
instance' (var "Show" @@ var "Bool")
  [ typeSig "show" $ var "Bool" --> var "String"
  , funBinds "show"
      [ matchRhs [var "True"] $ string "True"
      , matchRhs [var "False"] $ string "False"
      ]
  ]

A definition that can appear in the body of an instance declaration.