Module Type

type abstract;

Some documentation.

type alias = int;
type private_ = pri int;
type constructor('a) = 'a;
type arrow = int => int;
type higher_order = (int => int) => int;
type labeled = l:int => int;
type optional = ?⁠l:int => int;
type labeled_higher_order = (l:int => int) => (?⁠l:int => int) => int;
type pair = (int, int);
type parens_dropped = (int, int);
type triple = (int, int, int);
type nested_pair = ((int, int), int);
type instance = constructor(int);
type variant_e = {
a: int,
};
type variant =
| A
| B(int)
| C

foo

| D

bar

| E(variant_e)
;
type variant_c = {
a: int,
};
type gadt(_) =
| A : gadt(int)
| B(int) : gadt(string)
| C(variant_c) : gadt(unit)
;
type degenerate_gadt =
| A : degenerate_gadt
;
type private_variant = pri
| A
;
type record = {
a: int,
mutable b: int,
c: int,

foo

d: int,

bar

e: a. 'a,
};
type polymorphic_variant = [
| `A
| `B(int)
| `C((int, unit))
| `D
];
type polymorphic_variant_extension = [
| polymorphic_variant
| `E
];
type nested_polymorphic_variant = [
| `A([ `B | `C ])
];
type private_extenion#row;
and private_extenion = pri [>
| polymorphic_variant
];
type object_ = {. a: int, b: int, c: int, };
module type X = { ... };
type module_ = (module X);
type module_substitution = (module X with type t = int and type u = unit);
type covariant(+'a);
type contravariant(-'a);
type bivariant(_) = int;
type binary('a, 'b);
type using_binary = binary(int, int);
type name('custom);
type constrained('a) = 'a constraint 'a = int;
type exact_variant('a) = 'a constraint 'a = [ `A | `B(int) ];
type lower_variant('a) = 'a constraint 'a = [> `A | `B(int) ];
type any_variant('a) = 'a constraint 'a = [> ];
type upper_variant('a) = 'a constraint 'a = [< `A | `B(int) ];
type named_variant('a) = 'a constraint 'a = [< polymorphic_variant ];
type exact_object('a) = 'a constraint 'a = {. a: int, b: int, };
type lower_object('a) = 'a constraint 'a = {.. a: int, b: int, };
type poly_object('a) = 'a constraint 'a = {. a: a. 'a, };
type double_constrained('a, 'b) = ('a, 'b) constraint 'a = int constraint 'b = unit;
type as_ = (int as 'a, 'a);
type extensible = ..;
type extensible += Extension | Another_extension;
type mutually =
| A(recursive)
;
and recursive =
| B(mutually)
;
exception Foo(int, int);