Type (test_package+re.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)`;