Check if a name is a constructor name

Representation of types abstracting over the Phase

The representation of a program in the form of an AST node.

Phases that have already been passed. This has been thought as going through different phases of a compiler. We assume that there is a total order between phases.

A representation of a class in the form of an AST node. As an example:

class Foo:
  val x: Int
  var y: Bool
  def main(): Int
    42

the code above, after parsing, would generate the following AST:

ClassDef {cname = "Foo"
         ,fields = [FieldDef {fname = "x"
                             ,ftype = IntType
                             ,fmod = Val}]
         ,methods = [MethodDef {mname = "main"
                               ,mparams = []
                               ,mtype = IntType
                               ,mbody = [IntLit {etype = Proxy, ival = 42}]
                               }]}

Field qualifiers in a class. It is thought for a made up syntax such as:

class Foo:
  val x: Int
  var y: Bool

This indicates that the variable x is immutable, and y can be mutated.

Representation of a field declaration in the form of an AST node. As an example, the following code:

class Foo:
  val x: Int

could be parsed to the following field representation:

FieldDef {fname = "x"
         ,ftype = IntType
         ,fmod = Val}

Helper function to check whether a FieldDef is immutable.

Helper function to check whether a FieldDef is mutable.

Representation of parameters in the form of an AST.

Representation of a method declaration in the form of an AST. For example:

class Foo:
  def main(): Int
    42

the code above, after parsing, would generate the following AST:

ClassDef {cname = "Foo"
         ,fields = []
         ,methods = [MethodDef {mname = "main"
                               ,mparams = []
                               ,mtype = IntType
                               ,mbody = [IntLit {etype = Proxy, ival = 42}]
                               }]}

Takes a list of things that can be shown, and creates a comma separated string.

Representation of integer operations

Representation of expressions in the form of an AST node. The language is expression-based, so there are no statements. As an example, the following identity function:

let id = \x: Int -> x
in id 42

would be parsed as this Expr:

Let {etype = Proxy
    ,name = "id"
    ,val = Lambda {etype = Proxy
                  ,params = [Param "x" IntType]
                  ,body =   FunctionCall {etype = Proxy
                                         ,target = VarAccess Proxy "id"
                                         ,args = [IntLit Proxy 42]}
                  }
    ,body  :: Expr p
    }

Constant for the name this, commonly used in object-oriented languages.

Checks whether a Type is a function (arrow) type

Checks whether an expression is a FieldAccess.

Checks whether an expression is a VarAccess.

Checks whether an expression is a VarAccess of this.

Checks whether an expression is an lval.

Helper function to check whether a Type is a class

Helper function to extract the type from an expression.

Sets the type of an expression e to t.

Helper function that checks whether an expression uses a variable. This helper function can be used to throw a warning if the variable is unused.

Representation of a backtrace

Helper function for starting with an empty backtrace

Representation of different kinds of Backtrace nodes. The backtrace nodes contain all the available information that can be shown to the developer after a crash.

The type class defines how to create a Backtrace node, combinator backtrace, and how to push a new node to an existing backtrace.