The full, source code is available here.

                         TOP LEVEL DEFINITIONS

        let x = e                                  (let)
        let (op) = e                               (definition of an infix operator op)
        let x a ... a = e                          (let function)
        atom id                                    (constant and atomic type definition)
        type Id = t and Id = t ...                 (recursive types definition)


                               ARGUMENTS

a  ::=  x                                          (argument)
        (x:t)                                      (explicitly typed argument)

                              EXPRESSIONS

e  ::=  fun a ... a . e                            (function)
        fun (t) x ... x -> e                       (explicitly typed function)

        let x = e in e                             (let)
        let x a ... a = e in e                     (let function)

        <t>                                        ("magic" constant of type t)

        if e is t then e else e                    (typecase)
        e e                                        (application)
        e op e                                     (infix operator)
        (e, e)                                     (pair)
	fst e                                      (left projection)
        snd e                                      (right projection)
        [e;...; e]                                 (list)
        ()                                         (unit)
        "..."                                      (string constant)
        true                                       ([true] Boolean constant)
        false                                      ([false] Boolean constant)
        n                                          (numeric constant)
        id                                         (user-defined constant)
        x                                          (variable)

	

                              TYPES

t ::=  Bool                                       (booleans)
        Int                                        (integers)
        String                                     (strings)
        True                                       (singleton [true])
        False                                      (singleton [false])
        n                                          (singleton [integers])
        "..."                                      (singleton [strings])
        Unit                                       (unit)
        [t*]                                       (lists of t)
        n--n                                       (interval of integers)
        Id                                         (user-defined type)

        t->t                                       (functions)
        (t,t)                                      (products)

        t|t                                        (union)
        t&t                                        (intersection)
        t\t                                        (difference)
        ~t                                         (negation)

        Empty                                      (empty type)
        Any                                        (top type)