Create a expression for a variable or a data constructor ( a )

Create a literal expression ( 42 )

Create a infix operator application expression ( a + b )

Create a prefix operator application expression ( -x )

Create a function application expression ( f 4 )

Create a lambda expression ( \a b -> a + b )

Create a local binding ( let x = 2; y = 3 in e x y )

Create a if expression ( if a then b else c )

Create a multi way if expressions with MultiWayIf extension ( if | guard1 -> expr1; guard2 -> expr2 )

Create a pattern matching expression ( case expr of pat1 -> expr1; pat2 -> expr2 )

Create a do-notation expressions ( do x <- act1; act2 )

Create a mdo-notation expressions ( mdo x <- act1; act2 )

Create a tuple expression ( (e1, e2, e3) )

Create a unboxed tuple expression ( (# e1, e2, e3 #) )

Create a tuple section, enabled with TupleSections ( (a,,b) ). One of the elements must be missing.

Create a unboxed tuple section, enabled with TupleSections ( (#a,,b#) ). One of the elements must be missing.

Create a list expression: [1,2,3]

Create a parallel array expression: [: 1,2,3 :]

Create a parenthesized expression: ( a + b )

Create a left operator section: (1+)

Create a right operator section: (+1)

Create a record value construction: Point { x = 3, y = -2 }

Create a record value update: p1 { x = 3, y = -2 }

Create a enumeration expression ( [1,3..10] )

Create a parallel array enumeration ( [: 1,3 .. 10 :] )

Create a list comprehension ( [ (x, y) | x <- xs | y <- ys ] )

Create a parallel array comprehensions [: (x, y) | x <- xs , y <- ys :] enabled by ParallelArrays

Create a explicit type signature ( x :: Int )

Create a explicit type application ( show @Integer (read "5") )

'x for template haskell reifying of expressions

''T for template haskell reifying of types

Create a template haskell bracket expression

Create a template haskell splice expression, for example: $(gen a) or $x

Create a template haskell quasi quote expression, for example: [quoter| a + b ]

Creates a pragma that marks an expression.

Create a arrow definition: proc a -> f -< a+1

Create a arrow definition: proc a -> f -< a+1

Create a lambda case ( case 0 -> 1; 1 -> 2 )

Create a static pointer expression ( static e ). The inner expression must be closed (cannot have variables bound outside)

Create a update of a field ( x = 1 )

Create a update the field to the value of the same name ( x )

Create a update the fields of the bounded names to their values ( .. ). Must be the last initializer. Cannot be used in a record update expression.

Create a clause of case expression ( Just x -> x + 1 )

Create a unguarded right-hand side a pattern match ( -> 3 )

Create a guarded right-hand sides of a pattern match ( | x == 1 -> 3; | otherwise -> 4 )

Creates a guarded right-hand side of pattern matches binding ( | x > 3 -> 2 )

Creates a CORE pragma for adding notes to expressions.

Creates an SCC pragma for defining cost centers for profiling

Creates a pragma that describes if an expression was generated from a code fragment by an external tool ( {-# GENERATED "Happy.y" 1:15-1:25 #-} )

Create a in-AST source ranges (for generated pragmas)

An arrow application command ( f -< x + 1 )

A form command ( (|untilA (increment -< x+y) (within 0.5 -< x)|) )

A function application command

An infix command application

A lambda command

A parenthesized command

A pattern match command

An if command ( if f x y then g -< x+1 else h -< y+2 )

A local binding command ( let z = x+y )

A do-notation in a command

Left arrow application: -<

Right arrow application: >-

Left arrow high application: -<<

Right arrow high application: >>-

A hole expression _