`type abstract`

Some documentation.

`type alias = int`
`type private_ = private int`
`type 'a constructor = '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 = int constructor`
`type long = labeled_higher_order -> [ `Bar | `Baz of triple ] -> pair -> labeled -> higher_order -> (string -> int) -> (int * float * char * string * char * unit) option -> nested_pair -> arrow -> string -> nested_pair array`
`type variant_e = {`

1. `a : int;`

`}`
`type variant =`

1. `| A`
2. `| B of int`
3. `| C`
   (*

   foo

   *)
4. `| D`
   (*

   bar

   *)
5. `| E of variant_e`

`type variant_c = {`

1. `a : int;`

`}`
`type _ gadt =`

1. `| A : int gadt`
2. `| B : int -> string gadt`
3. `| C : variant_c -> unit gadt`

`type degenerate_gadt =`

1. `| A : degenerate_gadt`

`type private_variant = private`

1. `| A`

`type record = {`

1. `a : int;`
2. `mutable b : int;`
3. `c : int;`
   (*

   foo

   *)
4. `d : int;`
   (*

   bar

   *)
5. `e : 'a. 'a;`

`}`
`type polymorphic_variant = [`

1. `|` ``A`
2. `|` ``B of int`
3. `|` ``C of int * unit`
4. `|` ``D`

`]`
`type polymorphic_variant_extension = [`

1. `|` `polymorphic_variant`
2. `|` ``E`

`]`
`type nested_polymorphic_variant = [`

1. `|` ``A of [ `B | `C ]`

`]`
`type private_extenion = private [>`

1. `|` `polymorphic_variant`

`]`
`type object_ = < a : int ; b : int ; c : int >`
`module type X = sig ... end`
`type module_ = (module X)`
`type module_substitution = (module X with type t = int and type u = unit)`
`type +'a covariant`
`type -'a contravariant`
`type _ bivariant = int`
`type ('a, 'b) binary`
`type using_binary = (int, int) binary`
`type 'custom name`
`type 'a constrained = 'a constraint 'a = int`
`type 'a exact_variant = 'a constraint 'a = [ `A | `B of int ]`
`type 'a lower_variant = 'a constraint 'a = [> `A | `B of int ]`
`type 'a any_variant = 'a constraint 'a = [> ]`
`type 'a upper_variant = 'a constraint 'a = [< `A | `B of int ]`
`type 'a named_variant = 'a constraint 'a = [< polymorphic_variant ]`
`type 'a exact_object = 'a constraint 'a = < a : int ; b : int >`
`type 'a lower_object = 'a constraint 'a = < a : int ; b : int.. >`
`type 'a poly_object = 'a constraint 'a = < a : 'a. 'a >`
`type ('a, 'b) double_constrained = 'a * 'b constraint 'a = int constraint 'b = unit`
`type as_ = int as 'a * 'a`
`type extensible = ..`
`type extensible +=`

1. `| Extension`
   (*

   Documentation for `Extension`.

   *)
2. `| Another_extension`
   (*

   Documentation for `Another_extension` .

   *)

`type mutually =`

1. `| A of recursive`

`and recursive =`

1. `| B of mutually`

`exception Foo of int * int`