Documentation

value (doesn't need evaluation)

For example: { 1 } is represented as Exactly (Int 1)

variable

For example: { x } is represented as Var "x"

function application

For example: { f 42 } is represented as Apply (Var "f") (Exactly (Int 42))

built-in operator

For example: { 2+2 } is represented as BinOp Plus (Exactly (Int 2)) (Exactly (Int 2))

For example: { x @ [] } is represented as BinOp Cons (Var "x") (Exactly Nil)

if statement

For example: { if a then b else c } is represented as If (Var "a") (Var "b") (Var "c")

let statement, handles both regular lets and tuple-match lets

For example: { let x = 2 in x + x } is represented as Let ["x"] (Exactly (Int 2)) (BinOp Plus (Var "x") (Var "x"))

For example: { let (x,y) = mypair in x+y } is represented as Let ["x","y"] (Var "mypair") (BinOp Plus (Var "x") (Var "y"))

recursive let statement

For example: { letrec ones = 1 : ones in ones } is represented as LetRec "ones" (BinOp Cons (Exactly (Int 1)) (Var "ones")) (Var "ones")

lambda expression

For example: { x :: INT -> x + 1 } is represented as Lambda "x" IntTy (BinOp Plus (Var "x") (Exactly (Int 1)))

case expression on lists

For example: { case l of [] -> 0 | h : t -> h } is represented as ListCase (Var "l") (Exactly (Int 0)) "h" "t" (Var "h")

Notice that the form is very restrictive; you cannot have case expressions where the patterns have a different structure. It must be empty list as the first case and head and tail as the second!

expression to create a tuple

For example: { (x,1,[]) } is represented as Tuple [Var "x",Exactly (Int 1),Exactly Nil]

Parameterized type: Function from type a to type b

Parameterized type: Tuple of types t_1 to t_n

Parameterized type: List of elements of type a