refl 0.4.0 · OCaml Package

module T : BinaryTypeS

type ('a, 'b, 'positive, 'negative) item =

| None : ('a, 'b, [ `Absent ], [ `Absent ]) item
| P : ('a, 'b) T.t -> ('a, 'b, _, [ `Absent ]) item
| N : ('b, 'a) T.t -> ('a, 'b, [ `Absent ], _) item
| PN : (('a, 'b) T.t * ('b, 'a) T.t) -> ('a, 'b, _, _) item

type ('a, 'b, 'positive, 'negative) t =

| [] : (unit, unit, unit, unit) t
| :: : ('a, 'b, 'positive, 'negative) item * ('aa, 'bb, 'positive_tail, 'negative_tail) t -> ('a * 'aa, 'b * 'bb, 'positive * 'positive_tail, 'negative * 'negative_tail) t

val reverse_item : 
  'positive 'negative. ('a, 'b, 'positive, 'negative) item ->
  ('b, 'a, 'negative, 'positive) item

val pos : 'negative. ('a, 'b, [ `Present ], 'negative) item -> ('a, 'b) T.t

val get : 
  'index 'a 'b 'a_value 'b_value 'positive 'negative 'direct. ('index,
                                                                'a,
                                                                'a_value,
                                                                'positive,
                                                                'direct)
                                                                Refl__.Desc.variable ->
  ('index, 'b, 'b_value, 'positive, 'direct) Refl__.Desc.variable ->
  ('a, 'b, 'positive, 'negative) t ->
  ('a_value, 'b_value) T.t

val reverse : 
  'a 'b 'positive 'negative. ('a, 'b, 'positive, 'negative) t ->
  ('b, 'a, 'negative, 'positive) t

type ('a, 'b, 'positive, 'negative) symmetric_item =

| SNone : ('a, 'b, [ `Absent ], [ `Absent ]) symmetric_item
| SPN : (('a, 'b) T.t * ('b, 'a) T.t) -> ('a, 'b, _, _) symmetric_item

type ('a, 'b, 'positive, 'negative) symmetric =

| [] : (unit, unit, unit, unit) symmetric
| :: : ('a, 'b, 'positive, 'negative) symmetric_item * ('aa, 'bb, 'positive_tail, 'negative_tail) symmetric -> ('a * 'aa, 'b * 'bb, 'positive * 'positive_tail, 'negative * 'negative_tail) symmetric

type ('a, 'b, 'sp, 'sn, 'ap, 'an) make_transfer =

| TNone : ('a, 'b, [ `Absent ], [ `Absent ], 'ap, 'an) make_transfer
| TP : ('a, 'b, 'ap, 'an) t -> ('a, 'b, _, [ `Absent ], 'ap, 'an) make_transfer
| TN : ('a, 'b, 'an, 'ap) t -> ('a, 'b, [ `Absent ], _, 'ap, 'an) make_transfer
| TPN : ('a, 'b, 'an, 'ap) symmetric -> ('a, 'b, _, _, 'an, 'ap) make_transfer

val reverse_of_symmetric : 
  'a 'b 'positive 'negative. ('a, 'b, 'positive, 'negative) symmetric ->
  ('a, 'b, 'negative, 'positive) symmetric

val p_of_symmetric : 
  'a 'b 'ap 'an. ('a, 'b, 'ap, 'an) symmetric ->
  ('a, 'b, 'ap, 'an) t

val n_of_symmetric : 
  'a 'b 'ap 'an. ('a, 'b, 'ap, 'an) symmetric ->
  ('a, 'b, 'an, 'ap) t

val make_transfer : 
  'p 'n 'sp 'sn 'ap 'an 'a 'b. ('p, 'n, 'sp, 'sn, 'ap, 'an)
                                 Refl__.Desc.transfer_matrix ->
  ('a, 'b, 'p, 'n) t ->
  ('a, 'b, 'sp, 'sn, 'ap, 'an) make_transfer

type ('rec_group, 'a_kinds, 'b_kinds) make = {

f : 'a 'b 'structure 'a_arity 'b_arity 'ap 'an 'ad 'gadt. ('a, 'structure, 'a_arity, 'rec_group, 'a_kinds, 'ap, 'an, 'ad, 'gadt) Refl__.Desc.desc -> ('b, 'structure, 'b_arity, 'rec_group, 'b_kinds, 'ap, 'an, 'ad, 'gadt) Refl__.Desc.desc -> ('a_arity, 'b_arity, 'ap, 'an) t -> ('a, 'b) T.t;

}

val make_transfer_vector : 
  'a_types 'b_types 'structures 'arguments 'subpositive 'subnegative 'subdirect 'a_arity 'b_arity 'rec_group 'gadt. 
  ('rec_group, 'a_kinds, 'a_kinds0) make ->
  ('a_types, 'structures, 'a_arity, 'rec_group, 'a_kinds, 'arguments, 'gadt)
    Refl__.Desc.vector ->
  ('b_types, 'structures, 'b_arity, 'rec_group, 'a_kinds0, 'arguments, 'gadt)
    Refl__.Desc.vector ->
  ('positive,
    'negative,
    'direct,
    'subpositive,
    'subnegative,
    'subdirect,
    'arguments)
    Refl__.Desc.transfer ->
  ('a_arity, 'b_arity, 'positive, 'negative) t ->
  ('a_types, 'b_types, 'subpositive, 'subnegative) t

val skip : 
  'a 'b 'positive 'negative 'skip_positive 'skip_negative. ('positive,
                                                             'skip_positive)
                                                             Refl__.Desc.skip_vector ->
  ('negative, 'skip_negative) Refl__.Desc.skip_vector ->
  ('a, 'b, 'positive, 'negative) t ->
  ('a, 'b, 'skip_positive, 'skip_negative) t

val make : 
  ('a, 'b, 'b) make ->
  ('c, 'd, 'e, 'a, 'b, 'f, 'g) Refl__.Desc.vector ->
  ('h, 'd, 'i, 'a, 'b, 'f, 'g) Refl__.Desc.vector ->
  ('j, 'k, 'l, 'm, 'n, 'o, 'p) Refl__.Desc.transfer_skip ->
  ('e, 'i, 'q, 'r) t ->
  ('s, 't, 'u, 'v) t

Parameters

Signature