Type that represents a value.

A literal represents a fixed value in the IR. We only allow values of basic types: bool, char, string, int, float.

True -- Literal (BoolLiteral True)


'a' -- Literal (CharLiteral 'a')


"foo" -- Literal (StringLiteral "foo")


13 -- Literal (IntLiteral 13)


15.4 -- Literal (FloatLiteral 15.4)

A reference to a constructor of a custom type.

Nothing -- Constructor ( ..., [ [ "maybe" ] ], [ "nothing" ] )


Foo.Bar -- Constructor ( ..., [ [ "foo" ] ], [ "bar" ] )

Represents a function invocation. We use currying to represent function invocations with multiple arguments.

Note: Operators are mapped to well-known function names.

not True -- Apply (Reference ( ..., [ [ "basics" ] ], [ "not" ])) (Literal (BoolLiteral True))


True || False -- Apply (Apply (Reference ( ..., [ [ "basics" ] ], [ "and" ]))) (Literal (BoolLiteral True)) (Literal (BoolLiteral True))

Extracts the value of a record's field.

a.foo -- Field (Variable [ "a" ]) [ "foo" ]

Represents a function that extract a field from a record value passed to it.

.foo -- FieldFunction [ "foo" ]

Represents a lambda abstraction.

Note:

• We use currying to represent lambda abstractions with multiple arguments.
• Arguments are not just names, they are patterns.

\a -> a -- Lambda (AsPattern WildcardPattern [ "a" ]) (Variable [ "a" ])

\a b -> a -- Lambda (AsPattern WildcardPattern [ "a" ]) (Lambda (AsPattern WildcardPattern [ "b" ]) (Variable [ "a" ]))

Represents a let expression that assigns a value (and optionally type) to a name.

Note: We use currying to represent let expressions with multiple name bindings.

let
    a =
        b
in
a
-- LetDef [ "a" ]
--     (UntypedDefinition [] (Variable [ "b" ]))
--     (Variable [ "a" ])


let
    a : Bool
    a =
        b


    c x =
        a
in
c
-- LetDef [ "a" ]
--     (TypedDefinition (Basic BoolType) [] (Variable [ "b" ]))
--     (LetDef [ "c" ]
--         (UntypedDefinition [ [ "x" ] ] (Variable [ "a" ]))
--         (Variable [ "c" ])
--     )

Represents a let expression that extracts values using a pattern.

let
    ( a, b ) =
        c
in
a
-- LetDestruct
--     (TuplePattern [ AsPattern WildcardPattern ["a"], AsPattern WildcardPattern ["b"] ])
--     (Variable ["a"])

Represents a let expression with one or many recursive definitions.

let
    a =
        b


    b =
        a
in
a
-- LetRec
--     [ ( [ "a" ], UntypedDefinition [] (Variable [ "b" ]) )
--     , ( [ "b" ], UntypedDefinition [] (Variable [ "a" ]) )
--     ]
--     (Variable [ "a" ])

A list represents an ordered list of values where every value has to be of the same type.

[ 1, 3, 5 ] -- List [ Literal (IntLiteral 1), Literal (IntLiteral 3), Literal (IntLiteral 5) ]


[] -- List []

A record represents a list of fields where each field has a name and a value.

{ foo = "bar" } -- Record [ ( [ "foo" ], Literal (StringLiteral "bar") ) ]


{ foo = "bar", baz = 1 } -- Record [ ( [ "foo" ], Literal (StringLiteral "bar") ), ( [ "baz" ], Literal (IntLiteral 1) ) ]


{} -- Record []

A reference that refers to a function or a value with its fully-qualified name.

List.map -- Reference ( [ ..., [ [ "list" ] ], [ "map" ] )

A tuple represents an ordered list of values where each value can be of a different type.

Note: Tuples with zero values are considered to be the special value Unit

( 1, True ) -- Tuple [ Literal (IntLiteral 1), Literal (BoolLiteral True) ]


( "foo", True, 3 ) -- Tuple [ Literal (StringLiteral "foo"), Literal (BoolLiteral True), Literal (IntLiteral 3) ]


() -- Unit

A variable represents a reference to a named value in the scope.

a -- Variable [ "a" ]


fooBar15 -- Variable [ "foo", "bar", "15" ]

Represents and if/then/else expression.

if a then
    b
else
    c
-- IfThenElse (Variable ["a"])
--     (Variable ["b"])
--     (Variable ["c"])

Represents a pattern-match.

case a of
    1 ->
        "yea"


    _ ->
        "nay"
-- PatternMatch (Variable ["a"])
--     [ ( LiteralPattern (IntLiteral 1), Literal (StringLiteral "yea") )
--     , ( WildcardPattern, Literal (StringLiteral "nay") )
--     ]

Update one or many fields of a record value.

{ a | foo = 1 } -- Update (Variable ["a"]) [ ( ["foo"], Literal (IntLiteral 1) ) ]

Represents the unit value.

() -- Unit

Type that represents a pattern.

Matches any value and ignores it (assigns no variable name).

_ -- WildcardPattern

Assigns a variable name to a pattern.

_ as foo -- AsPattern WildcardPattern ["foo"]


foo -- AsPattern WildcardPattern ["foo"]


[] as foo -- AsPattern EmptyListPattern ["foo"]

Destructures a tuple using a pattern for every element.

( _, foo ) -- TuplePattern [ WildcardPattern, AsPattern WildcardPattern ["foo"] ]

Matches on a custom type's constructor.

Note: When the custom type has a single constructor this can be used for destructuring. When there are multiple constructors it also does filtering so it cannot be used in a LetDestruct but it can be used in a pattern-match.

Just _ -- ConstructorPattern ( ..., [["maybe"]], ["just"]) [ WildcardPattern ]

Matches an empty list. Can be used standalon but frequently used as a terminal pattern in a HeadTailPattern.

[] -- EmptyListPattern


[ _ ]
-- HeadTailPattern
--     WildcardPattern
--     EmptyListPattern

Matches the head and the tail of a list. It can be used to match lists of at least N items by nesting this pattern N times and terminating with EmptyListPattern.

[ a ]
-- HeadTailPattern
--     (AsPattern WildcardPattern ["a"])
--     EmptyListPattern


a :: b
-- HeadTailPattern
--     (AsPattern WildcardPattern ["a"])
--     (AsPattern WildcardPattern ["b"])


[ a, b ]
-- HeadTailPattern
--     (AsPattern WildcardPattern ["a"])
--     (HeadTailPattern
--         (AsPattern WildcardPattern ["b"])
--         EmptyListPattern
--     )

Matches a specific literal value. This pattern can only be used in a pattern-match since it always filters.

True -- LiteralPattern (BoolLiteral True)


'a' -- LiteralPattern (CharLiteral 'a')


"foo" -- LiteralPattern (StringLiteral "foo")


13 -- LiteralPattern (IntLiteral 13)


15.4 -- LiteralPattern (FloatLiteral 15.4)

Type that represents a value or function specification. The specification of what the value or function is without the actual data or logic behind it.

Type that represents a value or function definition. A definition is the actual data or logic as opposed to a specification which is just the specification of those. Value definitions can be typed or untyped. Exposed values have to be typed.

Turns a definition into a specification by removing implementation details.

Extract the argument list from a curried apply tree. It takes the two arguments of an apply and returns a tuple of the function and a list of arguments.

uncurryApply (Apply () f a) b == ( f, [ a, b ] )

Collect all variables in a value recursively.

Map attributes of a pattern while supplying an index to the map function. The index is incremented depth first.

Map attributes of a value while supplying an index to the map function. The index is incremented depth first.