refl 0.2.1 · OCaml Package

type ('a, 'b) eq =

| Eq : ('a, 'a) eq

type ('a, 'b, 'c) builtin_desc =

| Bool : (bool, [ `Bool ], [> `Bool ]) builtin_desc
| Bytes : (bytes, [ `Bytes ], [> `Bytes ]) builtin_desc
| Char : (char, [ `Char ], [> `Char ]) builtin_desc
| Float : (float, [ `Float ], [> `Float ]) builtin_desc
| Int : (int, [ `Int ], [> `Int ]) builtin_desc
| Int32 : (int32, [ `Int32 ], [> `Int32 ]) builtin_desc
| Int64 : (int64, [ `Int64 ], [> `Int64 ]) builtin_desc
| Nativeint : (nativeint, [ `Nativeint ], [> `Nativeint ]) builtin_desc
| String : (string, [ `String ], [> `String ]) builtin_desc

type ('index, 'items, 'value, 'tail) selection =

| Start : ([ `Zero ], 'sequence, _, 'sequence) selection
| Next : ('index, 'sequence, _, 'head * 'tail) selection -> ([ `Succ of 'index ], 'sequence, 'head, 'tail) selection

type ('index, 'items, 'value, 'tail) binary_selection =

| BinaryStart : ([ `Start ], 'sequence, _, 'sequence) binary_selection
| Zero : ('index, 'sequence, _, 'zero * 'one) binary_selection -> ([ `Zero of 'index ], 'sequence, _, 'zero) binary_selection
| One : ('index, 'sequence, _, 'zero * 'one) binary_selection -> ([ `One of 'index ], 'sequence, _, 'one) binary_selection
| Select : ('index, 'sequence, _, 'contents ref) binary_selection -> ([ `Select of 'index ], 'sequence, 'contents, unit) binary_selection

type 'cases choice =

| CFirst : 'types -> ('types * _) choice
| CNext : 'cases choice -> (_ * 'cases) choice

type 'cases binary_choice =

| CEnd : 'types -> 'types ref binary_choice
| CZero : 'cases binary_choice -> ('cases * _) binary_choice
| COne : 'cases binary_choice -> (_ * 'cases) binary_choice

module type UnaryTypeS = sig ... end

module Sequence (T : sig ... end) : sig ... end

module Delay : sig ... end

module Delays : sig ... end

type ('index, 'arity, 'a, 'positive, 'direct) variable =

| VFirst : ([ `Zero ], 'value * _, 'value, [ `Present ] * _, [ `Present ] * _) variable
| VNext : ('index, 'sequence, 'value, 'positive, 'direct) variable -> ([ `Succ of 'index ], _ * 'sequence, 'value, _ * 'positive, _ * 'direct) variable

type ('count, 'types) length =

| Zero : ([ `Zero ], unit) length
| Succ : ('length, 'types) length -> ([ `Succ of 'length ], _ * 'types) length

type ('a, 'b, 'c) append =

| Nil : (unit, 'a, 'a) append
| Add : ('a, 'b, 'c) append -> ('head * 'a, 'b, 'head * 'c) append

type ('global, 'local) presence =

| Present : ([> `Present ], [ `Present ]) presence
| Absent : (_, [ `Absent ]) presence

type ('presence, 'directs) presences =

| Presences : (_, unit) presences
| AddPresent : ('presence, 'directs) presences -> ([> `Present ] as 'presence, [ `Present ] * 'directs) presences
| AddAbsent : ('presence, 'directs) presences -> ('presence, [ `Absent ] * 'directs) presences

type ('constraints, 'exists) gadt_constraints = ..

type gadt_constraints +=

| NoConstraints

type ('gadt, 'sub_gadt) sub_gadt_ext = ..

type ('gadt, 'sub_gadt) sub_gadt = {

sub_gadt_ext : ('gadt, 'sub_gadt) sub_gadt_ext;
sub_gadt_functional : 'gadt 'sub_gadt0 'sub_gadt1. ('gadt, 'sub_gadt0) sub_gadt_ext -> ('gadt, 'sub_gadt1) sub_gadt_ext -> ('sub_gadt0, 'sub_gadt1) eq;

}

type ('count, 'local, 'positive, 'negative, 'direct, 'positives, 'negatives, 'directs, 'subpositive, 'subnegative, 'subdirect)
  subvariables =
  {

presences : ('local, 'directs) presences;
positive_count : ('count, 'positives) length;
positive : ('positives, 'positive, 'subpositive) append;
negative_count : ('count, 'negatives) length;
negative : ('negatives, 'negative, 'subnegative) append;
direct_count : ('count, 'directs) length;
direct : ('directs, 'direct, 'subdirect) append;

}

module Kinds : sig ... end

type ('a, 'arity, 'attribute) typed_attribute_kind = ..

type _ refl = ..

type ('a, 'structure, 'arity, 'rec_group, 'kinds, 'positive, 'negative, 'direct, 'gadt)
  desc =

| Variable : ('index, 'arity, 'a, 'positive, 'direct) variable -> ('a, [ `Variable of 'index ], 'arity, 'rec_group, [> `Variable ], 'positive, _, 'direct, _) desc
| Builtin : ('a, 'structure, 'kinds) builtin_desc -> ('a, [ `Builtin of 'structure ], 'arity, 'rec_group, 'kinds, _, _, _, _) desc
| Array : ('a, 'structure, 'arity, 'rec_group, 'kinds, 'negative, 'positive, 'negative, 'gadt) desc -> ('a array, [ `Array of 'structure ], 'arity, 'rec_group, [> `Array ] as 'kinds, 'negative, 'positive, 'negative, 'gadt) desc
| Arrow : {
1. parameter : ('a, 'a_structure, 'arity, 'rec_group, 'kinds, 'negative, 'positive, 'negative, 'gadt) desc;
2. result : ('b, 'b_structure, 'arity, 'rec_group, 'kinds, 'positive, 'negative, 'positive, 'gadt) desc;
} -> ('a -> 'b, [ `Arrow of 'a_structure -> 'b_structure ], 'arity, 'rec_group, [> `Arrow ] as 'kinds, 'positive, 'negative, _, 'gadt) desc
| LabelledArrow : {
1. label : string;
2. optional : bool;
3. parameter : ('a, 'a_structure, 'arity, 'rec_group, 'kinds, 'negative, 'positive, 'negative, 'gadt) desc;
4. result : ('b, 'b_structure, 'arity, 'rec_group, 'kinds, 'positive, 'negative, 'positive, 'gadt) desc;
5. wrap : ('a -> 'b) -> 'arrow;
6. unwrap : 'arrow -> 'a -> 'b;
} -> ('arrow, [ `LabelledArrow of 'a_structure -> 'b_structure ], 'arity, 'rec_group, [> `Arrow ] as 'kinds, 'positive, 'negative, _, 'gadt) desc
| Constr : {
1. constructors : ('cases, 'structures, 'arity, 'rec_group, 'kinds, 'positive, 'negative, 'direct, 'gadt) constructors;
2. construct : 'cases binary_choice -> 'a;
3. destruct : 'a -> 'cases binary_choice;
} -> ('a, [ `Constr of 'structures ], 'arity, 'rec_group, [> `Constr ] as 'kinds, 'positive, 'negative, 'direct, 'gadt) desc
| Variant : {
1. constructors : ((_ * _) as 'cases, 'structures, 'arity, 'rec_group, 'kinds, 'positive, 'negative, 'direct, 'gadt) variant_constructors;
2. construct : 'cases choice -> 'a;
3. destruct : 'a -> 'cases choice;
} -> ('a, [ `Variant of 'structures ], 'arity, 'rec_group, [> `Variant ] as 'kinds, 'positive, 'negative, 'direct, 'gadt) desc
| Tuple : {
1. structure : ((_ * (_ * _)) as 'types, 'structures, 'arity, 'rec_group, 'kinds, 'positive, 'negative, 'direct, 'gadt) tuple_structure;
2. construct : 'types -> 'a;
3. destruct : 'a -> 'types;
} -> ('a, [ `Tuple of 'structures ], 'arity, 'rec_group, [> `Tuple ] as 'kinds, 'positive, 'negative, 'direct, 'gadt) desc
| Record : {
1. structure : ((_ * _) as 'types, 'structures, 'arity, 'rec_group, 'kinds, 'positive, 'negative, 'direct, 'gadt) record_structure;
2. construct : 'types -> 'a;
3. destruct : 'a -> 'types;
} -> ('a, [ `Record of 'structures ], 'arity, 'rec_group, [> `Record ] as 'kinds, 'positive, 'negative, 'direct, 'gadt) desc
| Object : {
1. methods : ('methods, 'structures, 'arity, 'rec_group, 'kinds, 'positive, 'negative, 'direct, 'gadt) object_methods;
2. construct : 'methods Delays.t -> 'a;
3. destruct : 'a -> 'methods Delays.t;
} -> (< .. > as 'a, [ `Object of 'structures ], 'arity, 'rec_group, [> `Object ] as 'kinds, 'positive, 'negative, 'direct, 'gadt) desc
| Lazy : ('a, 'structure, 'arity, 'rec_group, 'kinds, 'positive, 'negative, 'direct, 'gadt) desc -> ('a Lazy.t, [ `Lazy of 'structure ], 'arity, 'rec_group, [> `Lazy ] as 'kinds, 'positive, 'negative, 'direct, 'gadt) desc
| Apply : {
1. arguments : ('types, 'structures, 'arity, 'rec_group, 'kinds, 'variables, 'gadt) vector;
2. desc : ('a, 'structure, 'types, 'rec_group, 'kinds, 'subpositive, 'subnegative, 'subdirect, 'gadt) desc;
3. transfer : ('positive, 'negative, 'direct, 'subpositive, 'subnegative, 'subdirect, 'variables) transfer;
} -> ('a, [ `Apply of 'structure * 'structures * 'subpositive * 'subnegative * 'subdirect * 'variables ], 'arity, 'rec_group, 'kinds, 'positive, 'negative, 'direct, 'gadt) desc
| MapOpaque : {
1. desc : ('a, 'structure, 'arity, 'rec_group, Kinds.all, 'positive, 'negative, 'direct, 'gadt) desc;
} -> ('a, [ `MapOpaque of 'structure * 'direct ], 'arity, 'rec_group, [> `MapOpaque ], 'positive, 'negative, _, 'gadt) desc
| Opaque : ([ `Succ of 'index ], 'gadt, 'a, _) selection -> ('a, [ `Opaque of 'index ], 'arity, 'rec_group, [> `Opaque ], 'positive, 'negative, _, 'gadt) desc
| Rec : {
1. index : ([ `Select of 'index ], 'rec_group, 'length * 'structure, _) binary_selection;
2. desc : ('a, 'structure, 'arity, 'rec_group, 'kinds, 'positive, 'negative, 'direct, 'gadt) desc;
} -> ('a, [ `Rec of 'index ], 'arity, 'rec_group, 'kinds, 'positive, 'negative, 'direct, 'gadt) desc
| RecGroup : {
1. desc : ('a, 'structure, 'arity, 'new_rec_group, 'kinds, 'positive, 'negative, 'direct, 'gadt) desc;
} -> ('a, [ `RecGroup of 'structure * 'new_rec_group ], 'arity, 'rec_group, 'kinds, 'positive, 'negative, 'direct, 'gadt) desc
| SelectGADT : {
1. index : ([ `Succ of 'index ], 'gadt, 'sub_gadt, _) selection;
2. desc : ('a, 'structure, 'arity, 'rec_group, 'kinds, 'positive, 'negative, 'direct, 'sub_gadt) desc;
} -> ('a, [ `SelectGADT of 'structure * 'index ], 'arity, 'rec_group, 'kinds, 'positive, 'negative, 'direct, 'gadt) desc
| SubGADT : {
1. sub_gadt : ('gadt, 'sub_gadt) sub_gadt;
2. desc : ('a, 'structure, 'arity, 'rec_group, 'kinds, 'positive, 'negative, 'direct, 'sub_gadt) desc;
} -> ('a, [ `SubGADT of 'structure ], 'arity, 'rec_group, 'kinds, 'positive, 'negative, 'direct, 'gadt) desc
| Attributes : {
1. attributes : ('a, 'arity, 'rec_group, 'kinds, 'positive, 'negative, 'direct, 'gadt) attributes;
2. desc : ('a, 'structure, 'arity, 'rec_group, 'kinds, 'positive, 'negative, 'direct, 'gadt) desc;
} -> ('a, [ `Attributes of 'structure ], 'arity, 'rec_group, [> `Attributes ] as 'kinds, 'positive, 'negative, 'direct, 'gadt) desc
| Name : {
1. name : string;
2. refl : 'a refl;
3. desc : ('a, 'structure, 'arity, 'rec_group, 'kinds, 'positive, 'negative, 'direct, 'sub_gadt) desc;
} -> ('a, [ `Name of 'structure ], 'arity, 'rec_group, 'kinds, 'positive, 'negative, 'direct, 'sub_gadt) desc

and ('cases, 'structures, 'arity, 'rec_group, 'kinds, 'positive, 'negative, 'direct, 'gadt)
  constructors =

| CLeaf : ('types_and_eqs, 'structure, 'arity, 'rec_group, 'kinds, 'positive, 'negative, 'direct, 'gadt) constructor -> ('types_and_eqs ref, 'structure ref, 'arity, 'rec_group, 'kinds, 'positive, 'negative, 'direct, 'gadt) constructors
| CNode : {
1. zero : ('cases0, 'structures0, 'arity, 'rec_group, 'kinds, 'positive, 'negative, 'direct, 'gadt) constructors;
2. one : ('cases1, 'structures1, 'arity, 'rec_group, 'kinds, 'positive, 'negative, 'direct, 'gadt) constructors;
} -> ('cases0 * 'cases1, 'structures0 * 'structures1, 'arity, 'rec_group, 'kinds, 'positive, 'negative, 'direct, 'gadt) constructors

and ('types_and_eqs, 'structure, 'arity, 'rec_group, 'kinds, 'positive, 'negative, 'direct, 'gadt)
  constructor =

| Constructor : {
1. name : string;
2. kind : ('types, 'structure_types, 'arity, 'rec_group, 'kinds, 'positive, 'negative, 'direct, 'gadt) constructor_kind;
3. eqs : ('eqs, 'structure_eqs, 'kinds, 'gadt) constructor_eqs;
4. attributes : ('types, 'arity, 'rec_group, 'kinds, 'positive, 'negative, 'direct, 'gadt) attributes;
} -> ('types * 'eqs, [ `Constructor of 'structure_types * 'structure_eqs ], 'arity, 'rec_group, 'kinds, 'positive, 'negative, 'direct, 'gadt) constructor
| Exists : {
1. name : string;
2. selection : ([ `Succ of 'index ], 'gadt, 'constraints, _) selection;
3. presence : ('kinds, 'local) presence;
4. variables : ('count, 'local, 'positive, 'negative, 'direct, 'positives, 'negatives, 'directs, 'subpositive, 'subnegative, 'subdirect) subvariables;
5. construct : 'exists 'subarity. ('count, 'exists) length -> ('constraints, 'exists) gadt_constraints -> ('exists, 'arity, 'subarity) append -> ('value, 'structure, 'subarity, 'rec_group, 'kinds, 'subpositive, 'subnegative, 'subdirect, 'gadt) exists_construct;
6. destruct : 'value -> ('count, 'constraints, 'value, 'structure, 'arity, 'rec_group, 'kinds, 'subpositive, 'subnegative, 'subdirect, 'gadt) exists_destruct;
} -> ('value, [ `Exists of 'index * 'count * 'structure * 'local * 'positives * 'negatives * 'directs ], 'arity, 'rec_group, [> `Exists ] as 'kinds, 'positive, 'negative, 'direct, 'gadt) constructor

and ('value, 'structure, 'arity, 'rec_group, 'kinds, 'positive, 'negative, 'direct, 'gadt)
  exists_construct =

| ExistsConstruct : {
1. kind : ('types, 'structure, 'arity, 'rec_group, 'kinds, 'positive, 'negative, 'direct, 'gadt) constructor_kind;
2. construct : 'types -> 'value;
} -> ('value, 'structure, 'arity, 'rec_group, 'kinds, 'positive, 'negative, 'direct, 'gadt) exists_construct

and ('count, 'constraints, 'value, 'structure, 'arity, 'rec_group, 'kinds, 'positive, 'negative, 'direct, 'gadt)
  exists_destruct =

| ExistsDestruct : {
1. exists_count : ('count, 'exists) length;
2. exists : ('exists, 'arity, 'subarity) append;
3. constraints : ('constraints, 'exists) gadt_constraints;
4. kind : ('types, 'structure, 'subarity, 'rec_group, 'kinds, 'positive, 'negative, 'direct, 'gadt) constructor_kind;
5. values : 'types;
} -> ('count, 'constraints, 'value, 'structure, 'arity, 'rec_group, 'kinds, 'positive, 'negative, 'direct, 'gadt) exists_destruct

and ('types, 'structure, 'arity, 'rec_group, 'kinds, 'positive, 'negative, 'direct, 'gadt)
  constructor_kind =

| CTuple : ('types, 'structure, 'arity, 'rec_group, 'kinds, 'positive, 'negative, 'direct, 'gadt) tuple_structure -> ('types, [ `Tuple of 'structure ], 'arity, 'rec_group, 'kinds, 'positive, 'negative, 'direct, 'gadt) constructor_kind
| CRecord : ('types, 'structure, 'arity, 'rec_group, 'kinds, 'positive, 'negative, 'direct, 'gadt) record_structure -> ('types, [ `Record of 'structure ], 'arity, 'rec_group, 'kinds, 'positive, 'negative, 'direct, 'gadt) constructor_kind

and ('types, 'structures, 'arity, 'rec_group, 'kinds, 'positive, 'negative, 'direct, 'gadt)
  tuple_structure =

| TNil : (unit, unit, 'arity, 'rec_group, 'kinds, 'positive, 'negative, 'direct, 'gadt) tuple_structure
| TCons : {
1. head : ('a, 'structure, 'arity, 'rec_group, 'kinds, 'positive, 'negative, 'direct, 'gadt) desc;
2. tail : ('types, 'structures, 'arity, 'rec_group, 'kinds, 'positive, 'negative, 'direct, 'gadt) tuple_structure;
} -> ('a * 'types, 'structure * 'structures, 'arity, 'rec_group, 'kinds, 'positive, 'negative, 'direct, 'gadt) tuple_structure

and ('types, 'structures, 'arity, 'rec_group, 'kinds, 'positive, 'negative, 'direct, 'gadt)
  record_structure =

| RNil : (unit, unit, 'arity, 'rec_group, 'kinds, 'positive, 'negative, 'direct, 'gadt) record_structure
| RCons : {
1. head : ('a, 'structure, 'arity, 'rec_group, 'kinds, 'positive, 'negative, 'direct, 'gadt) record_field;
2. tail : ('types, 'structures, 'arity, 'rec_group, 'kinds, 'positive, 'negative, 'direct, 'gadt) record_structure;
} -> ('a * 'types, 'structure * 'structures, 'arity, 'rec_group, 'kinds, 'positive, 'negative, 'direct, 'gadt) record_structure

and ('a, 'structure, 'arity, 'rec_group, 'kinds, 'positive, 'negative, 'direct, 'gadt)
  record_field =

| Mono : {
1. label : string;
2. desc : ('a, 'structure, 'arity, 'rec_group, 'kinds, 'positive, 'negative, 'direct, 'gadt) desc;
3. attributes : ('a, 'arity, 'rec_group, 'kinds, 'positive, 'negative, 'direct, 'gadt) attributes;
} -> ('a, [ `Mono of 'structure ], 'arity, 'rec_group, 'kinds, 'positive, 'negative, 'direct, 'gadt) record_field
| Poly : {
1. label : string;
2. variables : ('count, [ `Absent ], 'positive, 'negative, 'direct, 'positives, 'negatives, 'directs, 'subpositive, 'subnegative, 'subdirect) subvariables;
3. destruct : ('a, 'structure, 'arity, 'rec_group, 'kinds, 'subpositive, 'subnegative, 'subdirect, 'gadt, 'count) forall_destruct;
4. construct : ('a, 'structure, 'arity, 'rec_group, 'kinds, 'subpositive, 'subnegative, 'subdirect, 'gadt, 'count) forall_construct -> 'a;
} -> ('a, [ `Poly of 'structure * 'count * 'positives * 'negatives * 'directs ], 'arity, 'rec_group, [> `Poly ] as 'kinds, 'positive, 'negative, 'direct, 'gadt) record_field

and ('a, 'structure, 'arity, 'rec_group, 'kinds, 'positive, 'negative, 'direct, 'gadt, 'count)
  forall_construct =
  {

forall_construct : 'forall 'b 'subarity. ('count, 'forall) length -> ('forall, 'arity, 'subarity) append -> ('b, 'structure, 'subarity, 'rec_group, 'kinds, 'positive, 'negative, 'direct, 'gadt) desc -> 'b;

}

and ('a, 'structure, 'arity, 'rec_group, 'kinds, 'subpositive, 'subnegative, 'subdirect, 'gadt, 'count)
  forall_destruct =
  {

forall_destruct : 'forall 'subarity. ('count, 'forall) length -> ('forall, 'arity, 'subarity) append -> ('a, 'structure, 'subarity, 'rec_group, 'kinds, 'subpositive, 'subnegative, 'subdirect, 'gadt) forall_destruct_result;

}

and ('a, 'structure, 'arity, 'rec_group, 'kinds, 'positive, 'negative, 'direct, 'gadt)
  forall_destruct_result =

| ForallDestruct : {
1. desc : ('b, 'structure, 'arity, 'rec_group, 'kinds, 'positive, 'negative, 'direct, 'gadt) desc;
2. destruct : 'a -> 'b;
} -> ('a, 'structure, 'arity, 'rec_group, 'kinds, 'positive, 'negative, 'direct, 'gadt) forall_destruct_result

and ('cases, 'structures, 'arity, 'rec_group, 'kinds, 'positive, 'negative, 'direct, 'gadt)
  variant_constructors =

| VCNil : (unit, unit, 'arity, 'rec_group, 'kinds, 'positive, 'negative, 'direct, 'gadt) variant_constructors
| VCCons : {
1. head : ('types, 'structure, 'arity, 'rec_group, 'kinds, 'positive, 'negative, 'direct, 'gadt) variant_constructor;
2. tail : ('cases, 'structures, 'arity, 'rec_group, 'kinds, 'positive, 'negative, 'direct, 'gadt) variant_constructors;
} -> ('types * 'cases, 'structure * 'structures, 'arity, 'rec_group, 'kinds, 'positive, 'negative, 'direct, 'gadt) variant_constructors

and ('types, 'structure, 'arity, 'rec_group, 'kinds, 'positive, 'negative, 'direct, 'gadt)
  variant_constructor =

| VConstructor : {
1. name : string;
2. argument : ('types, 'structures, 'arity, 'rec_group, 'kinds, 'positive, 'negative, 'direct, 'gadt) variant_argument;
} -> ('types, [ `Constr of 'structures ], 'arity, 'rec_group, 'kinds, 'positive, 'negative, 'direct, 'gadt) variant_constructor
| VInherit : ('a, 'structure, 'arity, 'rec_group, 'kinds, 'positive, 'negative, 'direct, 'gadt) desc -> ('a, [ `Inherit of 'structure ], 'arity, 'rec_group, 'kinds, 'positive, 'negative, 'direct, 'gadt) variant_constructor

and ('types, 'structures, 'arity, 'rec_group, 'kinds, 'positive, 'negative, 'direct, 'gadt)
  variant_argument =

| VNone : (unit, unit, 'arity, 'rec_group, 'kinds, 'positive, 'negative, 'direct, 'gadt) variant_argument
| VSome : ('a, 'structure, 'arity, 'rec_group, 'kinds, 'positive, 'negative, 'direct, 'gadt) desc -> ('a * unit, 'structure * unit, 'arity, 'rec_group, 'kinds, 'positive, 'negative, 'direct, 'gadt) variant_argument

and ('methods, 'structures, 'arity, 'rec_group, 'kinds, 'positive, 'negative, 'direct, 'gadt)
  object_methods =

| ONil : (unit, unit, 'arity, 'rec_group, 'kinds, 'positive, 'negative, 'direct, 'gadt) object_methods
| OCons : {
1. head : ('a, 'structure, 'arity, 'rec_group, 'kinds, 'positive, 'negative, 'direct, 'gadt) object_method;
2. tail : ('methods, 'structures, 'arity, 'rec_group, 'kinds, 'positive, 'negative, 'direct, 'gadt) object_methods;
} -> ('a * 'methods, 'structure * 'structures, 'arity, 'rec_group, 'kinds, 'positive, 'negative, 'direct, 'gadt) object_methods

and ('types, 'structure, 'arity, 'rec_group, 'kinds, 'positive, 'negative, 'direct, 'gadt)
  object_method =

| OMethod : {
1. name : string;
2. desc : ('a, 'structures, 'arity, 'rec_group, 'kinds, 'positive, 'negative, 'direct, 'gadt) desc;
} -> ('a, [ `Method of 'structures ], 'arity, 'rec_group, 'kinds, 'positive, 'negative, 'direct, 'gadt) object_method

and ('types, 'structures, 'arity, 'rec_group, 'kinds, 'variables, 'gadt) vector =

| VNil : (unit, unit, 'arity, 'rec_group, 'kinds, unit, 'gadt) vector
| VCons : {
1. head : ('a, 'structure, 'arity, 'rec_group, 'kinds, 'positive, 'negative, 'direct, 'gadt) desc;
2. tail : ('types, 'structures, 'arity, 'rec_group, 'kinds, 'variables, 'gadt) vector;
} -> ('a * 'types, 'structure * 'structures, 'arity, 'rec_group, 'kinds, ('positive * 'negative * 'direct) * 'variables, 'gadt) vector

and ('positive, 'negative, 'direct, 'subpositive, 'subnegative, 'subdirect, 'variables)
  transfer =

| VTNil : (_, _, _, unit, unit, unit, unit) transfer
| VTCons : {
1. head : ('p, 'n, 'sp, 'sn, 'ap, 'an) transfer_matrix * ('d, 'sd, 'ad) transfer_arguments;
2. tail : ('p, 'n, 'd, 'sps, 'sns, 'sds, 'variables) transfer;
} -> ('p, 'n, 'd, 'sp * 'sps, 'sn * 'sns, 'sd * 'sds, ('ap * 'an * 'ad) * 'variables) transfer

and ('p, 'n, 'sp, 'sn, 'ap, 'an) transfer_matrix = {

pp : ('p, 'sp, 'ap) transfer_arguments;
pn : ('p, 'sn, 'an) transfer_arguments;
np : ('n, 'sp, 'an) transfer_arguments;
nn : ('n, 'sn, 'ap) transfer_arguments;

}

and ('source, 'sub, 'arg) transfer_arguments =

| VTANil : (unit, _, unit) transfer_arguments
| VTACons : {
1. head : ('source, 'sub, 'arg) transfer_argument;
2. tail : ('sources, 'sub, 'args) transfer_arguments;
} -> ('source * 'sources, 'sub, 'arg * 'args) transfer_arguments

and ('source, 'sub, 'arg) transfer_argument =

| Transfer : ('a, 'a, [ `Present ]) transfer_argument
| Skip : (_, _, [ `Absent ]) transfer_argument

and ('eqs, 'structure_eqs, 'kinds, 'gadt) constructor_eqs =

| ENil : (unit, unit, 'kinds, 'gadt) constructor_eqs
| ECons : {
1. head : ([ `Succ of 'index ], 'gadt, 'eq, _) selection;
2. tail : ('eqs, 'structure_eqs, 'kinds, 'gadt) constructor_eqs;
} -> ('eq * 'eqs, 'index * 'structure_eqs, [> `GADT ] as 'kinds, 'gadt) constructor_eqs

and ('a, 'arity, 'rec_group, 'kinds, 'positive, 'negative, 'direct, 'gadt)
  attributes =
  {

typed : 'attribute. ('a, 'arity, 'attribute) typed_attribute_kind -> 'attribute option;

}

module Builtins : sig ... end

module Tools : sig ... end

exception Incompatible

val selection : 
  'index_a 'index_b 'sequence 'head_a 'head_b 'tail_a 'tail_b. ([ `Succ of
                                                                    'index_a ],
                                                                 'sequence,
                                                                 'head_a,
                                                                 'tail_a)
                                                                 Refl__.Desc.selection ->
  ([ `Succ of 'index_b ], 'sequence, 'head_b, 'tail_b) Refl__.Desc.selection ->
  ('head_a, 'head_b) Refl__.Desc.eq

val convert_eqs : 
  'a_eqs 'structure_eqs_a 'structure_eqs_b 'b_eqs 'kinds_a 'kinds_b. 
  ('a_eqs, 'structure_eqs_a, 'kinds_a, 'gadt) Refl__.Desc.constructor_eqs ->
  ('b_eqs, 'structure_eqs_b, 'kinds_b, 'gadt) Refl__.Desc.constructor_eqs ->
  'a_eqs ->
  'b_eqs

val convert_presence : 
  'global_a 'local_a 'global_b 'local_b. ('global_a, 'local_a)
                                           Refl__.Desc.presence ->
  ('global_b, 'local_b) Refl__.Desc.presence ->
  ('local_a, 'local_b) Refl__.Desc.eq

val convert_presences : 
  'global 'local_a 'local_b. ('global, 'local_a) Refl__.Desc.presences ->
  ('global, 'local_b) Refl__.Desc.presences ->
  ('local_a, 'local_b) Refl__.Desc.eq

module Converter : sig ... end

module Converters : sig ... end

type ('arity_a, 'arity_b) converters =

| Converters of ('arity_a, 'arity_b) Converters.t

type ('forall, 'arity_a, 'arity_b) make_variables

val reverse : 
  'arity_a 'arity_b. ('arity_a, 'arity_b) converters ->
  ('arity_b, 'arity_a) converters

val make_variables : 
  'count 'forall 'arity_a 'arity_b. ('count, 'forall) Refl__.Desc.length ->
  ('arity_a, 'arity_b) converters ->
  ('forall, 'arity_a, 'arity_b) make_variables

val convert : 
  'structure_a 'structure_b 'a_struct 'b_struct 'arity_a 'arity_b 'rec_group_a 'rec_group_b 'kinds_a 'kinds_b 'positive_a 'negative_a 'direct_a 'positive_b 'negative_b 'direct_b 'gadt_a 'gadt_b. 
  ('a_struct,
    'structure_a,
    'arity_a,
    'rec_group_a,
    'kinds_a,
    'positive_a,
    'negative_a,
    'direct_a,
    'gadt_a)
    Refl__.Desc.desc ->
  ('b_struct,
    'structure_b,
    'arity_b,
    'rec_group_b,
    'kinds_b,
    'positive_b,
    'negative_b,
    'direct_b,
    'gadt_b)
    Refl__.Desc.desc ->
  ('arity_a, 'arity_b) converters ->
  ('gadt_a, 'gadt_b) Refl__.Desc.eq option ->
  ('a_struct, 'b_struct) Converter.t

val transfer : 
  'a 'structures_a 'arity_a 'rec_group_a 'kinds_a 'variables_a 'gadt_a 'b 'structures_b 'arity_b 'rec_group_b 'kinds_b 'variables_b 'gadt_b. 
  ('a, 'structures_a, 'arity_a, 'rec_group_a, 'kinds_a, 'variables_a, 'gadt_a)
    Refl__.Desc.vector ->
  ('b, 'structures_b, 'arity_b, 'rec_group_b, 'kinds_b, 'variables_b, 'gadt_b)
    Refl__.Desc.vector ->
  ('arity_a, 'arity_b) converters ->
  ('gadt_a, 'gadt_b) Refl__.Desc.eq option ->
  ('a, 'b) Converters.t

val cast : 
  ('a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, 'i) Refl__.Desc.desc ->
  ('j, 'k, 'c, 'l, 'm, 'n, 'o, 'p, 'i) Refl__.Desc.desc ->
  'a ->
  'j

module Mapper : sig ... end

module Mappers : sig ... end

val map : 
  'structure 'a_struct 'b_struct 'a_arity 'b_arity 'rec_group 'kinds 'positive 'negative 'direct 'gadt. 
  ('a_struct,
    'structure,
    'a_arity,
    'rec_group,
    'kinds,
    'positive,
    'negative,
    'direct,
    'gadt)
    Refl__.Desc.desc ->
  ('b_struct,
    'structure,
    'b_arity,
    'rec_group,
    'kinds,
    'positive,
    'negative,
    'direct,
    'gadt)
    Refl__.Desc.desc ->
  ('a_arity, 'b_arity, 'positive, 'negative) Mappers.t ->
  ('a_struct, 'b_struct) Mapper.t

module Printer : sig ... end

module Printers : sig ... end

module PrinterSequence : sig ... end

type Refl__.Desc.typed_attribute_kind +=

| Attribute_printer : ('a0, 'arity0, 'a0 Printer.t) Refl__.Desc.typed_attribute_kind
| Attribute_polyprinter : ('a1, 'arity1, 'arity1 PrinterSequence.t -> 'a1 Printer.t) Refl__.Desc.typed_attribute_kind

type 'kinds value

val pp : 
  'a 'structure 'arity 'rec_group 'positive 'negative 'direct 'gadt. 
  ('a,
    'structure,
    'arity,
    'rec_group,
    [> `Array
    | `Arrow
    | `Attributes
    | `Bool
    | `Bytes
    | `Char
    | `Constr
    | `Exists
    | `Float
    | `Int
    | `Int32
    | `Int64
    | `Lazy
    | `MapOpaque
    | `Nativeint
    | `Object
    | `Opaque
    | `Poly
    | `Record
    | `String
    | `Tuple
    | `Variable
    | `Variant ],
    'positive,
    'negative,
    'direct,
    'gadt)
    Refl__.Desc.desc ->
  ('arity, 'direct) Printers.t ->
  'a Printer.t

val show : 
  ('a,
    'b,
    'c,
    'd,
    [> `Array
    | `Arrow
    | `Attributes
    | `Bool
    | `Bytes
    | `Char
    | `Constr
    | `Exists
    | `Float
    | `Int
    | `Int32
    | `Int64
    | `Lazy
    | `MapOpaque
    | `Nativeint
    | `Object
    | `Opaque
    | `Poly
    | `Record
    | `String
    | `Tuple
    | `Variable
    | `Variant ],
    'e,
    'f,
    'g,
    'h)
    Refl__.Desc.desc ->
  ('c, 'g) Printers.t ->
  'a ->
  string

module Compare : sig ... end

module Comparer = Compare.Comparer

module Comparers = Compare.Comparers

val compare_gen : 
  ?hook:Compare.hook ->
  ('a,
    'b,
    'c,
    'd,
    [< Refl__.Desc.Kinds.comparable Array Attributes Bool Bytes Char Constr Exists Float Int Int32 Int64 Lazy MapOpaque Nativeint Object Opaque Record String Tuple Variable Variant ] as 'e,
    'f,
    'g,
    'h,
    'i)
    Refl__.Desc.desc ->
  ('j, 'b, 'k, 'd, 'e, 'f, 'g, 'h, 'l) Refl__.Desc.desc ->
  ('c, 'i, 'k, 'l) Compare.poly ->
  ('c, 'k, 'h) Compare.Comparers.t ->
  ('a, 'j) Compare.Comparer.t

val compare_poly : 
  ?hook:Compare.hook ->
  ('a,
    'b,
    'c,
    'd,
    [< Refl__.Desc.Kinds.comparable Array Attributes Bool Bytes Char Constr Exists Float Int Int32 Int64 Lazy MapOpaque Nativeint Object Opaque Record String Tuple Variable Variant ] as 'e,
    'f,
    'g,
    'h,
    'i)
    Refl__.Desc.desc ->
  ('j, 'b, 'k, 'd, 'e, 'f, 'g, 'h, 'l) Refl__.Desc.desc ->
  ('c, 'k, 'h) Compare.Comparers.t ->
  ('a, 'j) Compare.Comparer.t

val compare : 
  ?hook:Compare.hook ->
  ('a,
    'b,
    'c,
    'd,
    [< Refl__.Desc.Kinds.comparable Array Attributes Bool Bytes Char Constr Exists Float Int Int32 Int64 Lazy MapOpaque Nativeint Object Opaque Record String Tuple Variable Variant ],
    'e,
    'f,
    'g,
    'h)
    Refl__.Desc.desc ->
  ('c, 'c, 'g) Compare.Comparers.t ->
  ('a, 'a) Compare.Comparer.t

module Eq : sig ... end

module Equaler = Eq.Equaler

module Equalers = Eq.Equalers

val equal_poly : 
  ?hook:Eq.hook ->
  ('a,
    'b,
    'c,
    'd,
    [< Refl__.Desc.Kinds.comparable Array Attributes Bool Bytes Char Constr Exists Float Int Int32 Int64 Lazy MapOpaque Nativeint Object Opaque Record String Tuple Variable Variant ] as 'e,
    'f,
    'g,
    'h,
    'i)
    Refl__.Desc.desc ->
  ('j, 'b, 'k, 'd, 'e, 'f, 'g, 'h, 'l) Refl__.Desc.desc ->
  ('c, 'k, 'h) Eq.Equalers.t ->
  ('a, 'j) Eq.Equaler.t

val equal : 
  ?hook:Eq.hook ->
  ('a,
    'b,
    'c,
    'd,
    [< Refl__.Desc.Kinds.comparable Array Attributes Bool Bytes Char Constr Exists Float Int Int32 Int64 Lazy MapOpaque Nativeint Object Opaque Record String Tuple Variable Variant ],
    'e,
    'f,
    'g,
    'h)
    Refl__.Desc.desc ->
  ('c, 'c, 'g) Eq.Equalers.t ->
  ('a, 'a) Eq.Equaler.t

module Hash : sig ... end

val hash : 
  ('a,
    'b,
    'c,
    'd,
    [< Refl__.Desc.Kinds.comparable Array Attributes Constr Exists Lazy MapOpaque Object Opaque Record Tuple Variable Variant ],
    'e,
    'f,
    'g,
    'h)
    Refl__.Desc.desc ->
  ('c, 'g) Hash.Hashers.t ->
  'a Hash.Hasher.t

type Refl__.Desc.typed_attribute_kind +=

| Attribute_value : ('a0, 'arity0, int) Refl__.Desc.typed_attribute_kind

val lift_zero : 
  ('cases Refl__.Desc.binary_choice * int option) list ->
  (('cases * 'a) Refl__.Desc.binary_choice * int option) list

val lift_one : 
  ('cases Refl__.Desc.binary_choice * int option) list ->
  (('a * 'cases) Refl__.Desc.binary_choice * int option) list

val merge : 'a list -> 'a list -> 'a list

val constructor_assoc : 
  'cases 'structures. ('cases,
                        'structures,
                        'arity,
                        'rec_group,
                        'kinds,
                        'positive,
                        'negative,
                        'direct,
                        'gadt)
                        Refl__.Desc.constructors ->
  ('cases Refl__.Desc.binary_choice * int option) list

val constructor_assoc_with_default_values : 
  ('a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, 'i) Refl__.Desc.constructors ->
  ('a Refl__.Desc.binary_choice * int) list

type ('a, 'b) enum_structure = [

| `RecGroup of [ `Name of [ `Constr of 'a ] ] * 'b

]

val min : 
  'a. ('a,
        ('structures, 'b) enum_structure,
        'arity,
        'rec_group,
        [> `Constr ],
        'positive,
        'negative,
        'direct,
        'gadt)
        Refl__.Desc.desc ->
  int

val max : 
  'a. ('a,
        ('structures, 'b) enum_structure,
        'arity,
        'rec_group,
        [> `Constr ],
        'positive,
        'negative,
        'direct,
        'gadt)
        Refl__.Desc.desc ->
  int

val check_choice : 
  'cases Refl__.Desc.binary_choice ->
  ('cases Refl__.Desc.binary_choice * int) ->
  bool

val check_value : int -> ('cases Refl__.Desc.binary_choice * int) -> bool

val to_int_opt : 
  'a. ('a,
        ('structures, 'b) enum_structure,
        'arity,
        'rec_group,
        [> `Constr ],
        'positive,
        'negative,
        'direct,
        'gadt)
        Refl__.Desc.desc ->
  'a ->
  int option

val of_int_opt : 
  'a. ('a,
        ('structures, 'b) enum_structure,
        'arity,
        'rec_group,
        [> `Constr ],
        'positive,
        'negative,
        'direct,
        'gadt)
        Refl__.Desc.desc ->
  int ->
  'a option

val to_string : 
  'a. ('a,
        ('structures, 'b) enum_structure,
        'arity,
        'rec_group,
        [> `Constr ],
        'positive,
        'negative,
        'direct,
        'gadt)
        Refl__.Desc.desc ->
  'a ->
  string

val of_string_aux : 
  'cases 'structures. ('cases,
                        'structures,
                        'arity,
                        'rec_group,
                        'kinds,
                        'positive,
                        'negative,
                        'direct,
                        'gadt)
                        Refl__.Desc.constructors ->
  string ->
  'cases Refl__.Desc.binary_choice option

val of_string_opt : 
  'a. ('a,
        ('structures, 'b) enum_structure,
        'arity,
        'rec_group,
        [> `Constr ],
        'positive,
        'negative,
        'direct,
        'gadt)
        Refl__.Desc.desc ->
  string ->
  'a option

module StringMap : sig ... end

type Refl__.Desc.typed_attribute_kind +=

| Attribute_default : ('a0, 'arity0, 'a0) Refl__.Desc.typed_attribute_kind

type ('arity, 'rec_group, 'kinds, 'positive, 'negative, 'direct, 'gadt) field

val make_fields : 
  'types 'structures. ('types,
                        'structures,
                        'arity,
                        'rec_group,
                        [> `Poly ] as 'a,
                        'positive,
                        'negative,
                        'direct,
                        'gadt)
                        Refl__.Desc.record_structure ->
  ('arity, 'rec_group, 'a, 'positive, 'negative, 'direct, 'gadt) field
    StringMap.t ->
  'types

type ('a, 'b) record_type_structure = [

| `RecGroup of [ `Name of [ `Record of 'a ] ] * 'b

]

val make : 
  'a 'structures 'new_rec_group. ('a,
                                   ('structures, 'new_rec_group)
                                     record_type_structure,
                                   'arity,
                                   'rec_group,
                                   [> `Poly | `Record ] as 'b,
                                   'positive,
                                   'negative,
                                   'direct,
                                   'gadt)
                                   Refl__.Desc.desc ->
  ('arity, 'new_rec_group, 'b, 'positive, 'negative, 'direct, 'gadt) field
    StringMap.t ->
  'a

module Lift : sig ... end

module Visit : sig ... end

module Ocaml_attributes : sig ... end

package refl