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

A literal expression ( 42 )

An infix operator application ( a + b )

Prefix operator application ( -x )

Function application ( f 4 )

Lambda expression ( \a b -> a + b )

Local binding ( let x = 2; y = 3 in e x y )

If expression ( if a then b else c )

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

Pattern matching expression ( case expr of pat1 -> expr1; pat2 -> expr2 )

Do-notation expressions ( do x <- act1; act2 )

MDo-notation expressions ( mdo x <- act1; act2 )

Tuple expression ( (e1, e2, e3) )

Unboxed tuple expression ( (# e1, e2, e3 #) )

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

Unboxed tuple section enabled with TupleSections ( () ). One of the elements must be missing.

List expression: [1,2,3]

Parallel array expression: [: 1,2,3 :]

Parenthesized expression: ( a + b )

Left operator section: (1+)

Right operator section: (+1)

Record value construction: Point { x = 3, y = -2 }

Record value update: p1 { x = 3, y = -2 }

Enumeration expression ( [1,3..10] )

Parallel array enumeration ( [: 1,3 .. 10 :] )

List comprehension ( [ (x, y) | x <- xs | y <- ys ] )

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

Explicit type signature ( x :: Int )

Explicit type application ( show @Integer (read "5") )

'x for template haskell reifying of expressions

''T for template haskell reifying of types

Template haskell bracket expression

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

Template haskell quasi-quotation: [$quoter|str]

Template haskell quasi-quotation: [$quoter|str]

Arrow definition: proc a -> f -< a+1

Arrow definition: proc a -> f -< a+1

Lambda case ( case 0 -> 1; 1 -> 2 )

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

Update of a field ( x = 1 )

Update the field to the value of the same name ( x )

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

An existing element in a tuple section

A missing element in a tuple section

Clause of case expression ( Just x -> x + 1 )

Unguarded right-hand side a pattern match ( -> 3 )

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

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

A CORE pragma for adding notes to expressions.

An SCC pragma for defining cost centers for profiling

A pragma that describes if an expression was generated from a code fragment by an external tool ( {--} )

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

An infix command application

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 local binding command ( let z = x+y )

Left arrow application: -<

Right arrow application: >-

Left arrow high application: -<<

Right arrow high application: >>-

A hole expression _