Type expressions for the core language.

The type_desc variant defines all the possible type expressions one can find in OCaml. type_expr wraps this with some annotations.

The level field tracks the level of polymorphism associated to a type, guiding the generalization algorithm. Put shortly, when referring to a type in a given environment, both the type and the environment have a level. If the type has an higher level, then it can be considered fully polymorphic (type variables will be printed as 'a), otherwise it'll be weakly polymorphic, or non generalized (type variables printed as '_a). See http://okmij.org/ftp/ML/generalization.html for more information.

Note about type_declaration: one should not make the confusion between type_expr and type_declaration.

type_declaration refers specifically to the type construct in OCaml language, where you create and name a new type or type alias.

type_expr is used when you refer to existing types, e.g. when annotating the expected type of a value.

Also, as the type system of OCaml is generative, a type_declaration can have the side-effect of introducing a new type constructor, different from all other known types. Whereas type_expr is a pure construct which allows referring to existing types.

Note on mutability: TBD.

`X | `Y (row_closed = true) < `X | `Y (row_closed = true) > `X | `Y (row_closed = false) < `X | `Y > `X (row_closed = true)

type t = > `X as 'a (row_more = Tvar a) type t = private > `X (row_more = Tconstr (t#row, , ref Mnil)

And for:

let f = function `X -> `X -> | `Y -> `X

the type of "f" will be a Tarrow whose lhs will (basically) be:

Tvariant row_fields = [("X", _)]; row_more = Tvariant { row_fields = [("Y", _)]; row_more = Tvariant { row_fields = []; row_more = _; _ ; _

}

; _

}

abbrev_memo allows one to keep track of different expansions of a type alias. This is done for performance purposes.

For instance, when defining type 'a pair = 'a * 'a, when one refers to an 'a pair, it is just a shortcut for the 'a * 'a type. This expansion will be stored in the abbrev_memo of the corresponding Tconstr node.

In practice, abbrev_memo behaves like list of expansions with a mutable tail.

Note on marshalling: abbrev_memo must not appear in saved types. Btype, with cleanup_abbrev and memo, takes care of tracking and removing abbreviations.

commutable is a flag appended to every arrow type.

When typing an application, if the type of the functional is known, its type is instantiated with Cok arrows, otherwise as Clink (ref Cunknown).

When the type is not known, the application will be used to infer the actual type. This is fragile in presence of labels where there is no principal type.

Two incompatible applications relying on Cunknown arrows will trigger an error.

let f g = g ~a:() ~b:(); g ~b:() ~a:();

Error: This function is applied to arguments in an order different from other calls. This is only allowed when the real type is known.