package refl

You can search for identifiers within the package.

in-package search v0.2.0

package refl

refl
- CHANGES
- README
- Library ppx_refl
  - Ppx_refl
- Library refl
  - Refl
    
    UnaryTypeS
    
    Sequence
    
    Delay
    
    Delays
    
    Kinds
    
    Builtins
    
    Refl
    
    UnaryTypeS
    
    Sequence
    
    Delay
    
    Delays
    
    Kinds
    
    Tools
    
    TypeS
    
    BinaryTypeS
    
    VectorS
    
    T
    
    Vector
    
    T
    
    BinaryVector
    
    ParameterizedVector
    
    Unary
    
    Item
    
    Unary
    
    T
    
    T
    
    SignedVector
    
    Desc_type
    
    Desc_vector
    
    Section
    
    Mapper
    
    MapperTools
    
    Tuple
    
    Tuple
    
    Item
    
    Items
    
    Tuples
    
    Record
    
    Record
    
    Field
    
    Map
    
    Tools
    
    Fields
    
    Records
    
    Constructor
    
    Map
    
    Tools
    
    RecordMap
    
    Tools
    
    Variant
    
    Object
    
    Object
    
    Method
    
    Methods
    
    Objects
    
    Converter
    
    Converters
    
    Mapper
    
    Mappers
    
    Printer
    
    Printers
    
    T
    
    PrinterSequence
    
    Compare
    
    Comparer
    
    Comparers
    
    Comparer
    
    Comparers
    
    Eq
    
    Equaler
    
    Equalers
    
    Equaler
    
    Equalers
    
    Hash
    
    Hasher
    
    Hashers
    
    T
    
    Iter
    
    Iters
    
    Fold
    
    Folds
    
    StringMap
    
    Lift
    
    Make
    
    Lifter
    
    Lifters
    
    T
    
    Exp
    
    Lifter
    
    Lifters
    
    T
    
    Pat
    
    Lifter
    
    Lifters
    
    T
    
    Visit
    
    VisitorS
    
    Applicative
    
    VisitS
    
    Visitor
    
    Visitors
    
    T
    
    Make
    
    Visitor
    
    Visitors
    
    T
    
    Ocaml_attributes
- Sources
  - ppx_refl
    
    ListExt.ml
    
    common.ml
    
    constraints.ml
    
    indexer.ml
    
    ppx_refl.ml
    
    ppx_refl__.ml
  - refl
    
    builtins.ml
    
    compare.ml
    
    convert.ml
    
    desc.ml
    
    enum.ml
    
    eq.ml
    
    fold.ml
    
    hash.ml
    
    iter.ml
    
    lift.ml
    
    make.ml
    
    map.ml
    
    refl.ml
    
    refl__.ml
    
    show.ml
    
    tools.ml
    
    visit.ml

Legend:
Page
Library
Module
Module type
Parameter
Class
Class type
Source

Module `Refl.Tools`Source

Sourcemodule type TypeS = Traverse.TypeS

Sourcemodule type BinaryTypeS = sig ... end

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

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

Source

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

Sourcetype 'types selection_of_choice =

| SelectionOfChoice : {
1. index : ([ `Succ of 'index ], 'types, 'a, _) Refl__.Desc.selection;
2. item : 'a;
} -> 'types selection_of_choice

Source

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

Source

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

Source

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

Sourcetype ('index, 'index') compare =

| LessThan
| Equal of ('index, 'index') Refl__.Desc.eq
| GreaterThan

Source

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

Source

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

Source

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

Source

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

Source

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

Source

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

Source

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

Source

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

Source

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

Source

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

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

Sourcemodule type VectorS = sig ... end

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

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

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

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

Sourcemodule type Desc_type = sig ... end

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

Sourcemodule Section : sig ... end

Source

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;

}

Sourcemodule type Mapper = sig ... end

Sourcetype 'count map_length =

| MapLength : {
1. length : ('count, _) Refl__.Desc.length;
} -> 'count map_length

Sourcetype ('types, 'tail) make_append =

| MakeAppend : ('types, 'tail, 'append) Refl__.Desc.append -> ('types, 'tail) make_append

Source

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

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

Source

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

Sourcemodule Tuple : sig ... end

Sourcemodule Record : sig ... end

Sourcemodule Constructor : sig ... end

Sourcemodule Variant : sig ... end

Sourcemodule Object : sig ... end

package refl

Module Refl.ToolsSource

Module `Refl.Tools`Source