Check if a name is a constructor name

Representation of types

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

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 = Nothing, 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 = Nothing, 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

generates this Expr:

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

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.

Checks whether a variable is used inside an expression

Representation of backtrace

Empty backtrace

Different kinds of backtrace nodes. Whenever the type checking function adds a backtrace, it needs to add the correspondingly correct backtrace. This logic is handle in the type class Backtraceable.

Type class defines how to create and push a backtrace node