refl 0.2.0 · OCaml Package

module Refl : sig ... end

type unit__structure = [

| `Name of [ `Constr of [ `Constructor of [ `Tuple of unit ] * unit ] ref ]

]

type unit__arity = [

| `Zero

]

type unit__rec_group = (unit__arity * unit__structure) * unit

type Refl.refl +=

| Name_unit : unit Refl.refl

type unit__kinds = [

| `Constr
| `Name

]

type unit__gadt = unit

val unit_refl : 
  (unit,
    unit__structure,
    'arity,
    unit__rec_group,
    [> unit__kinds ],
    unit,
    unit,
    unit,
    unit)
    Refl.desc

type 'a list = 'a Stdcompat.List.t =

| []
| :: of 'a * 'a list

val list__variable_positive0 : 'a -> 'b -> 'a

val list__variable_negative0 : 'a -> 'b -> 'b

val list__variable_direct0 : 'a -> 'b -> 'a

type ('present, 'unknown) list__variable_positive0 = 'present

and ('present, 'unknown) list__variable_negative0 = 'unknown

and ('present, 'unknown) list__variable_direct0 = 'present

and list__arity = [

| `Succ of [ `Zero ]

]

and list__structure = [

| `Name of [ `Constr of [ `Constructor of [ `Tuple of unit ] * unit ] ref * [ `Constructor of [ `Tuple of [ `Variable of [ `Zero ] ] * ([ `SubGADT of [ `Rec of [ `Start ] ] ] * unit) ] * unit ] ref ]

]

and list__rec_group = (list__arity * list__structure) ref

and list__kinds = [

| `Variable
| `Constr

]

and 'a0 list__gadt = unit

type Refl.refl +=

| Refl_list : 'a0 list Refl.refl

type Refl.sub_gadt_ext +=

| List__sub_0 : ('a0 list__gadt, 'a list__gadt) Refl.sub_gadt_ext

val list_refl : 
  'a0. ('a0 list,
         list__structure,
         'a0 * unit,
         list__rec_group,
         [> list__kinds ],
         [ `Present ] * unit,
         [ `Absent ] * unit,
         [ `Present ] * unit,
         'a0 list__gadt)
         Refl.desc

type ('a, 'b) result = ('a, 'b) Stdcompat.Stdlib.result =

| Ok of 'a
| Error of 'b

val result__variable_positive0 : 'a -> 'b -> 'a

val result__variable_positive1 : 'a -> 'b -> 'a

val result__variable_negative0 : 'a -> 'b -> 'b

val result__variable_negative1 : 'a -> 'b -> 'b

val result__variable_direct0 : 'a -> 'b -> 'a

val result__variable_direct1 : 'a -> 'b -> 'a

type ('present, 'unknown) result__variable_positive0 = 'present

and ('present, 'unknown) result__variable_positive1 = 'present

and ('present, 'unknown) result__variable_negative0 = 'unknown

and ('present, 'unknown) result__variable_negative1 = 'unknown

and ('present, 'unknown) result__variable_direct0 = 'present

and ('present, 'unknown) result__variable_direct1 = 'present

and result__arity = [

| `Succ of [ `Succ of [ `Zero ] ]

]

and result__structure = [

| `Name of [ `Constr of [ `Constructor of [ `Tuple of [ `Variable of [ `Zero ] ] * unit ] * unit ] ref * [ `Constructor of [ `Tuple of [ `Variable of [ `Succ of [ `Zero ] ] ] * unit ] * unit ] ref ]

]

and result__rec_group = (result__arity * result__structure) ref

and result__kinds = [

| `Variable
| `Constr

]

and ('a0, 'a1) result__gadt = unit

type Refl.refl +=

| Refl_result : ('a0, 'a1) result Refl.refl

val result_refl : 
  'a0 'a1. (('a0, 'a1) result,
             result__structure,
             'a0 * ('a1 * unit),
             result__rec_group,
             [> result__kinds ],
             [ `Present ] * ([ `Present ] * unit),
             [ `Absent ] * ([ `Absent ] * unit),
             [ `Present ] * ([ `Present ] * unit),
             ('a0, 'a1) result__gadt)
             Refl.desc

type 'a option = 'a Stdcompat.Option.t =

| None
| Some of 'a

val option__variable_positive0 : 'a -> 'b -> 'a

val option__variable_negative0 : 'a -> 'b -> 'b

val option__variable_direct0 : 'a -> 'b -> 'a

type ('present, 'unknown) option__variable_positive0 = 'present

and ('present, 'unknown) option__variable_negative0 = 'unknown

and ('present, 'unknown) option__variable_direct0 = 'present

and option__arity = [

| `Succ of [ `Zero ]

]

and option__structure = [

| `Name of [ `Constr of [ `Constructor of [ `Tuple of unit ] * unit ] ref * [ `Constructor of [ `Tuple of [ `Variable of [ `Zero ] ] * unit ] * unit ] ref ]

]

and option__rec_group = (option__arity * option__structure) ref

and option__kinds = [

| `Variable
| `Constr

]

and 'a0 option__gadt = unit

type Refl.refl +=

| Refl_option : 'a0 option Refl.refl

val option_refl : 
  'a0. ('a0 option,
         option__structure,
         'a0 * unit,
         option__rec_group,
         [> option__kinds ],
         [ `Present ] * unit,
         [ `Absent ] * unit,
         [ `Present ] * unit,
         'a0 option__gadt)
         Refl.desc

type 'a ref = 'a Stdcompat.Stdlib.ref = {

mutable contents : 'a;

}

val ref__variable_positive0 : 'a -> 'b -> 'a

val ref__variable_negative0 : 'a -> 'b -> 'b

val ref__variable_direct0 : 'a -> 'b -> 'a

type ('present, 'unknown) ref__variable_positive0 = 'present

and ('present, 'unknown) ref__variable_negative0 = 'unknown

and ('present, 'unknown) ref__variable_direct0 = 'present

and ref__arity = [

| `Succ of [ `Zero ]

]

and ref__structure = [

| `Name of [ `Record of [ `Mono of [ `Variable of [ `Zero ] ] ] * unit ]

]

and ref__rec_group = (ref__arity * ref__structure) ref

and ref__kinds = [

| `Variable
| `Record

]

and 'a0 ref__gadt = unit

type Refl.refl +=

| Refl_ref : 'a0 ref Refl.refl

val ref_refl : 
  'a0. ('a0 ref,
         ref__structure,
         'a0 * unit,
         ref__rec_group,
         [> ref__kinds ],
         [ `Present ] * unit,
         [ `Absent ] * unit,
         [ `Present ] * unit,
         'a0 ref__gadt)
         Refl.desc

package refl