include module type of struct include Types end

Representation of types and declarations

Types defines the representation of types and declarations (that is, the content of module signatures).

CMI files are made of marshalled types.

Asttypes exposes basic definitions shared both by Parsetree and Types.

type type_expr = Types.type_expr = {

mutable desc : type_desc;
mutable level : int;
id : int;

}

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.

and type_desc = Types.type_desc =

| Tvar of string option
(*
Tvar (Some "a") ==> 'a or '_a Tvar None ==> _
*)
| Tarrow of Asttypes.arg_label * type_expr * type_expr * commutable
(*
Tarrow (Nolabel, e1, e2, c) ==> e1 -> e2 Tarrow (Labelled "l", e1, e2, c) ==> l:e1 -> e2 Tarrow (Optional "l", e1, e2, c) ==> ?l:e1 -> e2
See commutable for the last argument.
*)
| Ttuple of type_expr list
(*
Ttuple [t1;...;tn] ==> (t1 * ... * tn)
*)
| Tconstr of Path.t * type_expr list * abbrev_memo Pervasives.ref
(*
Tconstr (`A.B.t', [t1;...;tn], _) ==> (t1,...,tn) A.B.t The last parameter keep tracks of known expansions, see abbrev_memo.
*)
| Tobject of type_expr * (Path.t * type_expr list) option Pervasives.ref
(*
Tobject (`f1:t1;...;fn: tn', `None') ==> < f1: t1; ...; fn: tn > f1, fn are represented as a linked list of types using Tfield and Tnil constructors.
Tobject (_, `Some (`A.ct', [t1;...;tn]') ==> (t1, ..., tn) A.ct. where A.ct is the type of some class.
There are also special cases for so-called "class-types", cf. Typeclass and Ctype.set_object_name:
Tobject (Tfield(_,_,...(Tfield(_,_,rv)...), Some(`A.#ct`, [rv;t1;...;tn]) ==> (t1, ..., tn) #A.ct Tobject (_, Some(`A.#ct`, [Tnil;t1;...;tn]) ==> (t1, ..., tn) A.ct
where rv is the hidden row variable.
*)
| Tfield of string * field_kind * type_expr * type_expr
(*
Tfield ("foo", Fpresent, t, ts) ==> <...; foo : t; ts>
*)
| Tnil
(*
Tnil ==> <...; >
*)
| Tlink of type_expr
(*
Indirection used by unification engine.
*)
| Tsubst of type_expr
(*
Tsubst is used temporarily to store information in low-level functions manipulating representation of types, such as instantiation or copy. This constructor should not appear outside of these cases.
*)
| Tvariant of row_desc
(*
Representation of polymorphic variants, see row_desc.
*)
| Tunivar of string option
(*
Occurrence of a type variable introduced by a forall quantifier / Tpoly.
*)
| Tpoly of type_expr * type_expr list
(*
Tpoly (ty,tyl) ==> 'a1... 'an. ty, where 'a1 ... 'an are names given to types in tyl and occurrences of those types in ty.
*)
| Tpackage of Path.t * Longident.t list * type_expr list
(*
Type of a first-class module (a.k.a package).
*)

and row_desc = Types.row_desc = {

row_fields : (Asttypes.label * row_field) list;
row_more : type_expr;
row_bound : unit;
row_closed : bool;
row_fixed : bool;
row_name : (Path.t * type_expr list) option;

}

`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 = _; _; _

}

; _

}

and row_field = Types.row_field =

| Rpresent of type_expr option
| Reither of bool * type_expr list * bool * row_field option Pervasives.ref
| Rabsent

and abbrev_memo = Types.abbrev_memo =

| Mnil
(*
No known abbreviation
*)
| Mcons of Asttypes.private_flag * Path.t * type_expr * type_expr * abbrev_memo
(*
Found one abbreviation. A valid abbreviation should be at least as visible and reachable by the same path. The first expression is the abbreviation and the second the expansion.
*)
| Mlink of abbrev_memo Pervasives.ref
(*
Abbreviations can be found after this indirection
*)

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.

and field_kind = Types.field_kind =

| Fvar of field_kind option Pervasives.ref
| Fpresent
| Fabsent

and commutable = Types.commutable =

| Cok
| Cunknown
| Clink of commutable Pervasives.ref

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.

module TypeOps = Types.TypeOps

module Meths = Types.Meths

module Vars = Types.Vars

type value_description = Types.value_description = {

val_type : type_expr;
val_kind : value_kind;
val_loc : Location.t;
val_attributes : Parsetree.attributes;

}

and value_kind = Types.value_kind =

| Val_reg
| Val_prim of Primitive.description
| Val_ivar of Asttypes.mutable_flag * string
| Val_self of (Ident.t * type_expr) Meths.t Pervasives.ref * (Ident.t * Asttypes.mutable_flag * Asttypes.virtual_flag * type_expr) Vars.t Pervasives.ref * string * type_expr
| Val_anc of (string * Ident.t) list * string
| Val_unbound

module Variance = Types.Variance

type type_declaration = Types.type_declaration = {

type_params : type_expr list;
type_arity : int;
type_kind : type_kind;
type_private : Asttypes.private_flag;
type_manifest : type_expr option;
type_variance : Variance.t list;
type_newtype_level : (int * int) option;
type_loc : Location.t;
type_attributes : Parsetree.attributes;
type_immediate : bool;
type_unboxed : unboxed_status;

}

and type_kind = Types.type_kind =

| Type_abstract
| Type_record of label_declaration list * record_representation
| Type_variant of constructor_declaration list
| Type_open

and record_representation = Types.record_representation =

| Record_regular
| Record_float
| Record_unboxed of bool
| Record_inlined of int
| Record_extension

and label_declaration = Types.label_declaration = {

ld_id : Ident.t;
ld_mutable : Asttypes.mutable_flag;
ld_type : type_expr;
ld_loc : Location.t;
ld_attributes : Parsetree.attributes;

}

and constructor_declaration = Types.constructor_declaration = {

cd_id : Ident.t;
cd_args : constructor_arguments;
cd_res : type_expr option;
cd_loc : Location.t;
cd_attributes : Parsetree.attributes;

}

and constructor_arguments = Types.constructor_arguments =

| Cstr_tuple of type_expr list
| Cstr_record of label_declaration list

and unboxed_status = private Types.unboxed_status = {

unboxed : bool;
default : bool;

}

val unboxed_false_default_false : unboxed_status

val unboxed_false_default_true : unboxed_status

val unboxed_true_default_false : unboxed_status

val unboxed_true_default_true : unboxed_status

type extension_constructor = Types.extension_constructor = {

ext_type_path : Path.t;
ext_type_params : type_expr list;
ext_args : constructor_arguments;
ext_ret_type : type_expr option;
ext_private : Asttypes.private_flag;
ext_loc : Location.t;
ext_attributes : Parsetree.attributes;

}

and type_transparence = Types.type_transparence =

| Type_public
| Type_new
| Type_private

module Concr = Types.Concr

type class_type = Types.class_type =

| Cty_constr of Path.t * type_expr list * class_type
| Cty_signature of class_signature
| Cty_arrow of Asttypes.arg_label * type_expr * class_type

and class_signature = Types.class_signature = {

csig_self : type_expr;
csig_vars : (Asttypes.mutable_flag * Asttypes.virtual_flag * type_expr) Vars.t;
csig_concr : Concr.t;
csig_inher : (Path.t * type_expr list) list;

}

type class_declaration = Types.class_declaration = {

cty_params : type_expr list;
mutable cty_type : class_type;
cty_path : Path.t;
cty_new : type_expr option;
cty_variance : Variance.t list;
cty_loc : Location.t;
cty_attributes : Parsetree.attributes;

}

type class_type_declaration = Types.class_type_declaration = {

clty_params : type_expr list;
clty_type : class_type;
clty_path : Path.t;
clty_variance : Variance.t list;
clty_loc : Location.t;
clty_attributes : Parsetree.attributes;

}

type module_type = Types.module_type =

| Mty_ident of Path.t
| Mty_signature of signature
| Mty_functor of Ident.t * module_type option * module_type
| Mty_alias of alias_presence * Path.t

and alias_presence = Types.alias_presence =

| Mta_present
| Mta_absent

and signature = signature_item list

and signature_item = Types.signature_item =

| Sig_value of Ident.t * value_description
| Sig_type of Ident.t * type_declaration * rec_status
| Sig_typext of Ident.t * extension_constructor * ext_status
| Sig_module of Ident.t * module_declaration * rec_status
| Sig_modtype of Ident.t * modtype_declaration
| Sig_class of Ident.t * class_declaration * rec_status
| Sig_class_type of Ident.t * class_type_declaration * rec_status

and module_declaration = Types.module_declaration = {

md_type : module_type;
md_attributes : Parsetree.attributes;
md_loc : Location.t;

}

and modtype_declaration = Types.modtype_declaration = {

mtd_type : module_type option;
mtd_attributes : Parsetree.attributes;
mtd_loc : Location.t;

}

and rec_status = Types.rec_status =

| Trec_not
| Trec_first
| Trec_next

and ext_status = Types.ext_status =

| Text_first
| Text_next
| Text_exception

type constructor_description = Types.constructor_description = {

cstr_name : string;
cstr_res : type_expr;
cstr_existentials : type_expr list;
cstr_args : type_expr list;
cstr_arity : int;
cstr_tag : constructor_tag;
cstr_consts : int;
cstr_nonconsts : int;
cstr_normal : int;
cstr_generalized : bool;
cstr_private : Asttypes.private_flag;
cstr_loc : Location.t;
cstr_attributes : Parsetree.attributes;
cstr_inlined : type_declaration option;

}

and constructor_tag = Types.constructor_tag =

| Cstr_constant of int
| Cstr_block of int
| Cstr_unboxed
| Cstr_extension of Path.t * bool

val equal_tag : constructor_tag -> constructor_tag -> bool

val may_equal_constr : 
  constructor_description ->
  constructor_description ->
  bool

type label_description = Types.label_description = {

lbl_name : string;
lbl_res : type_expr;
lbl_arg : type_expr;
lbl_mut : Asttypes.mutable_flag;
lbl_pos : int;
lbl_all : label_description array;
lbl_repres : record_representation;
lbl_private : Asttypes.private_flag;
lbl_loc : Location.t;
lbl_attributes : Parsetree.attributes;

}

val repr_desc : type_expr -> type_desc

repr + desc

val expand_repr_desc : Env.t -> type_expr -> type_desc

expand_head + repr + desc

val with_snapshot : (unit -> 'a) -> 'a

Run the given function. Unifications caused by the function are undo-ed.

val is_constr : Env.t -> type_expr -> (Path.t * type_expr list) option

Check the type is a Tconstr

val is_option_type : Env.t -> type_expr -> type_expr option

Check the type is option

val gen_vars : type_expr -> type_expr list

Generalized tvars

val create_uniq_type : unit -> type_expr

Create a unique data type. Note that the result data type lacks definition.

val close_gen_vars : type_expr -> unit

Unify genvars with unique data types. Use with_snapshot to recover the original types

package typpx

Representation of types and declarations