Represents a type expression that can appear in various places within the IR. It can be the right-hand-side of a type alias declaration, input and output types of a function or as an annotation on values after type inference is done.

Type are modeled as expression trees: a recursive data structure with various node types. The type argument a allows us to assign some additional attributes to each node in the tree. Here are some details on each node type in the tree:

• Variable
  • Represents a type variable.
  • It has a single argument which captures the name of the variable.
  • Wikipedia: Type variable
  • creation, matching
• Reference
  • A fully-qualified reference to some other type or type alias within the package or one of its dependencies.
  • References to built-in types (like Int, String, ...) don't have an associated definition.
  • creation, matching
• Tuple
  • A tuple is a composition of other types (potentially other tuples).
  • The order of types is relevant so the easiest way to think about it is as a list of types.
  • A tuple can have any number of elements and there is no restriction on the element types.
  • A tuple with zero elements is equivalent with Unit.
  • A tuple with a single element is equivalent to the element type itself.
  • Wikipedia: Tuple
  • creation, matching
• Record
  • A record is a composition of other types like tuples but types are identified by a field name instead of an index.
  • The best way to think of a record is as a dictionary of types.
  • Our representation captures the order of fields for convenience but the order should not be considered for type equivalence.
  • [Wikipedia: Record](https://en.wikipedia.org/wiki/Record_(computer_science))
  • Elm-lang: Records
  • Utilities: creation, matching
• ExtensibleRecord
  • Similar to records but while record types declare that the underlying object has "exactly these fields" an extensible record declares that the object has "at least these fields".
  • Besides the list of fields you need to specify a variable name that will be used to abstract over the type that's being extended.
  • Elm: Extensible records
  • creation, matching
• Function
  • Represents the type of a function. The two arguments are the argument and the return type of the function.
  • Multi-argument functions are represented by composing functions:
    • a -> b -> c is represented as a -> (b -> c)
  • Wikipedia: Function type
  • creation, matching
• Unit
  • Unit type is used as a placeholder in situations where a type is required but the corresponding value is unused.
  • Semantically the unit type represents a set that has exactly one value which is often called unit.
  • Unit corresponds to void in some other programming languages.
  • Wikipedia: Unit type
  • creation, matching

Creates a type variable.

toIR a == variable [ "a" ] ()


toIR fooBar == variable [ "foo", "bar" ] ()

Creates a fully-qualified reference to a type.

toIR (List Int)
    == reference SDK.List.listType [ intType ]


toIR Foo.Bar
    == reference
        ( [ [ "my" ], [ "lib" ] ], [ [ "foo" ] ], [ "bar" ] )
        []

Creates a tuple type.

toIR ( Int, Bool )
    == tuple [ basic intType, basic boolType ]

Creates a record type.

toIR {} == record []


toIR { foo = Int }
    == record
        [ field [ "foo" ] SDK.Basics.intType
        ]


toIR { foo = Int, bar = Bool }
    == record
        [ field [ "foo" ] SDK.Basics.intType
        , field [ "bar" ] SDK.Basics.boolType
        ]

Creates an extensible record type.

toIR { e | foo = Int }
    == extensibleRecord (variable [ "e" ])
        [ field [ "foo" ] intType
        ]


toIR { f | foo = Int, bar = Bool }
    == extensibleRecord (variable [ "f" ])
        [ field [ "foo" ] intType
        , field [ "bar" ] boolType
        ]

Creates a function type. Use currying to create functions with more than one argument.

toIR (Int -> Bool) ==
    function
        SDK.Basics.intType
        SDK.Basics.boolType


toIR (Int -> Bool -> Char) ==
    function
        intType
        (function
            SDK.Basics.boolType
            SDK.Basics.charType
        )

Creates a unit type.

toIR () == unit

An opaque representation of a field. It's made up of a name and a type.

Map the name of the field to get a new field.

Map the type of the field to get a new field.

This syntax represents a type definition. For example:

• type alias Foo a = {bar : Maybe a, qux : Int}
• type MyList a = End | Cons a (MyList a)

In the definition, the List Name refers to type parameters on the LHS and Type extra refers to the RHS

Collect all variables in a type recursively.