refl 0.4.1 (latest) · OCaml Package

module type TypeS = Traverse.TypeS

module type BinaryTypeS = sig ... end

val cast : 'a 'b. ('a, 'b) Refl__.Desc.eq -> 'a -> 'b

val eq_symmetric : 'a 'b. ('a, 'b) Refl__.Desc.eq -> ('b, 'a) Refl__.Desc.eq

val sub_gadt_functional : 
  ('a, 'b) Refl__.Desc.sub_gadt ->
  ('c, 'd) Refl__.Desc.sub_gadt ->
  ('e, 'f) Refl__.Desc.eq

type 'types selection_of_choice

val equal_binary_choice : 
  'cases. 'cases Refl__.Desc.binary_choice ->
  'cases Refl__.Desc.binary_choice ->
  bool

val selection_of_choice : 
  'types. 'types Refl__.Desc.choice ->
  'types selection_of_choice

val variable_functional : 
  'index 'arity 'a 'b 'positive_a 'direct_a 'positive_b 'direct_b. ('index,
                                                                    'arity,
                                                                    'a,
                                                                    'positive_a,
                                                                    'direct_a)
                                                                    Refl__.Desc.variable ->
  ('index, 'arity, 'b, 'positive_b, 'direct_b) Refl__.Desc.variable ->
  ('a, 'b) Refl__.Desc.eq

type ('index, 'index') compare =

| LessThan
| GreaterThan

val compare_length : 
  'count_a 'types_a 'count_b 'types_b. ('count_a, 'types_a) Refl__.Desc.length ->
  ('count_b, 'types_b) Refl__.Desc.length ->
  ('count_a, 'count_b) compare

val compare_selection : 
  'index 'index' 'sequence 'sequence' 'head 'tail 'head' 'tail'. ('index,
                                                                   'sequence,
                                                                   'head,
                                                                   'tail)
                                                                   Refl__.Desc.selection ->
  ('index', 'sequence', 'head', 'tail') Refl__.Desc.selection ->
  ('index, 'index') compare

val int_of_selection : 
  'index 'sequence 'head 'tail. ?start:int ->
  ('index, 'sequence, 'head, 'tail) Refl__.Desc.selection ->
  int

val int_of_binary_selection : 
  'index 'sequence 'head 'tail. ?start:int ->
  ('index, 'sequence, 'head, 'tail) Refl__.Desc.binary_selection ->
  int

val selection_functional_tail : 
  'index 'sequence 'head 'tail 'head' 'tail'. ('index, 'sequence, 'head, 'tail)
                                                Refl__.Desc.selection ->
  ('index, 'sequence, 'head', 'tail') Refl__.Desc.selection ->
  ('tail, 'tail') Refl__.Desc.eq

val selection_functional_head : 
  'index 'sequence 'head 'head' 'tail 'tail'. ([ `Succ of 'index ],
                                                'sequence,
                                                'head,
                                                'tail)
                                                Refl__.Desc.selection ->
  ([ `Succ of 'index ], 'sequence, 'head', 'tail') Refl__.Desc.selection ->
  ('head, 'head') Refl__.Desc.eq

val compare_binary_selection : 
  'index 'index' 'sequence 'sequence' 'head 'tail 'head' 'tail'. ('index,
                                                                   'sequence,
                                                                   'head,
                                                                   'tail)
                                                                   Refl__.Desc.binary_selection ->
  ('index', 'sequence', 'head', 'tail') Refl__.Desc.binary_selection ->
  ('index, 'index') compare

val binary_selection_functional_tail : 
  'index 'sequence 'head 'tail 'head' 'tail'. ('index, 'sequence, 'head, 'tail)
                                                Refl__.Desc.binary_selection ->
  ('index, 'sequence, 'head', 'tail') Refl__.Desc.binary_selection ->
  ('tail, 'tail') Refl__.Desc.eq

val binary_selection_functional_head : 
  'index 'sequence 'head 'head' 'tail 'tail'. ([ `Select of 'index ],
                                                'sequence,
                                                'head,
                                                'tail)
                                                Refl__.Desc.binary_selection ->
  ([ `Select of 'index ], 'sequence, 'head', 'tail')
    Refl__.Desc.binary_selection ->
  ('head, 'head') Refl__.Desc.eq

val equal_variable : 
  'index_a 'index_b 'arity_a 'arity_b 'a 'b 'positive_a 'positive_b 'direct_a 'direct_b. 
  ('index_a, 'arity_a, 'a, 'positive_a, 'direct_a) Refl__.Desc.variable ->
  ('index_b, 'arity_b, 'b, 'positive_b, 'direct_b) Refl__.Desc.variable ->
  (('index_a, 'index_b) Refl__.Desc.eq, unit) result

val attributes_empty : ('a, 'b, 'c, 'd, 'e, 'f, 'g, 'h) Refl__.Desc.attributes

module type VectorS = sig ... end

module Vector (T : sig ... end) : VectorS with module T = T

module BinaryVector (T : BinaryTypeS) : sig ... end

module ParameterizedVector (T : BinaryTypeS) : sig ... end

module SignedVector (T : BinaryTypeS) : sig ... end

module type Desc_type = sig ... end

module Desc_vector (T : Desc_type) : sig ... end

module Section : sig ... end

type ('a_arity, 'b_arity, 'rec_group, 'kinds_a, 'kinds_b, 'positive, 'negative, 'direct, 'gadt)
  map =
  {

f : 'a 'b 'structure. ('a, 'structure, 'a_arity, 'rec_group, 'kinds_a, 'positive, 'negative, 'direct, 'gadt) Refl__.Desc.desc -> ('b, 'structure, 'b_arity, 'rec_group, 'kinds_b, 'positive, 'negative, 'direct, 'gadt) Refl__.Desc.desc -> 'a -> 'b;

}

module type Mapper = sig ... end

type 'count map_length

type ('types, 'tail) make_append

val make_append : 
  'count 'types. ('count, 'types) Refl__.Desc.length ->
  ('types, 'tail) make_append

module MapperTools (M : Mapper) : sig ... end

val append_functional : 
  'prefix 'suffix 'result1 'result2. ('prefix, 'suffix, 'result1)
                                       Refl__.Desc.append ->
  ('prefix, 'suffix, 'result2) Refl__.Desc.append ->
  ('result1, 'result2) Refl__.Desc.eq

module Tuple : sig ... end

module Record : sig ... end

module Constructor : sig ... end

module Variant : sig ... end

module Object : sig ... end

package refl