Documentation

A type constructor with data constructors

A value

A type class

A type class instance, created during typeclass desugaring (name, class name, instance types)

A declaration reference with source position information

A data type declaration (name, arguments, data constructors)

A minimal mutually recursive set of data type declarations

A type synonym declaration (name, arguments, type)

A type declaration for a value (name, ty)

A value declaration (name, top-level binders, optional guard, value)

A minimal mutually recursive set of value declarations

A foreign import declaration (type, name, optional inline Javascript, type)

A data type foreign import (name, kind)

A type class instance foreign import

A fixity declaration (fixity data, operator name)

A module import (module name, optional set of identifiers to import, optional qualified as name)

A type class declaration (name, argument, implies, member declarations)

A type instance declaration (name, dependencies, class name, instance types, member declarations)

A declaration with source position information

A numeric literal

A string literal

A boolean literal

A prefix -, will be desugared

Binary operator application. During the rebracketing phase of desugaring, this data constructor will be removed.

Explicit parentheses. During the rebracketing phase of desugaring, this data constructor will be removed.

An array literal

An object literal

An record property accessor expression

Partial record update

Function introduction

Function application

Variable

Conditional (if-then-else expression)

A data constructor

A case expression. During the case expansion phase of desugaring, top-level binders will get desugared into case expressions, hence the need for guards and multiple binders per branch here.

A value with a type annotation

A let binding

A do-notation block

A placeholder for a type class dictionary to be inserted later. At the end of type checking, these placeholders will be replaced with actual expressions representing type classes dictionaries which can be evaluated at runtime. The constructor arguments represent (in order): whether or not to look at superclass implementations when searching for a dictionary, the type class name and instance type, and the type class dictionaries in scope.

A placeholder for a superclass dictionary to be turned into a TypeClassDictionary during typechecking

A value with source position information

A monadic value without a binder

A monadic value with a binder

A let statement, i.e. a pure value with a binder

A do notation element with source position information

Wildcard binder

A binder which matches a boolean literal

A binder which matches a string literal

A binder which matches a numeric literal

A binder which binds an identifier

A binder which matches a data constructor

A binder which matches a record and binds its properties

A binder which matches an array and binds its elements

A binder which matches an array and binds its head and tail

A binder which binds its input to an identifier

A binder with source position information