Index of types

A
app [Generic_util_app.T]	Extensible GADT interpreting type application.
applicative [Generic_util_applicative.T]
arguments [Generic_core_desc.Con]	The arguments of a constructors are either a tuple or an inline record.
array' [Generic_util_app]
C
closure [Generic_core_consumer]	A closure allows us to call a type-indexed consumer and to extend it to new type cases.
closure [Generic_core_extensible]	A closure allows us to call a type-indexed function and to extend it to new type cases.
comp [Generic_util_app]
con [Generic_core_desc.Ext]	A constructor of an extensible type `('a0,...'an) t` is described by a value of type `con` which is a partial polymorphic function that computes the constructor representation for any closed type expression `(s0,...,sn) t` (without any type variable).
con [Generic_core_desc.Con]	Constructor.
con_id [Generic_util_obj]	Type of constructor identifiers, the result type of function `Generic_util_obj.con_id`
conap [Generic_core_desc.Con]	Constructor Application.
cons [Generic_core_desc.Ext]
cons [Generic_core_desc.Variant]	Set of constructors.
const [Generic_util_app]	The type `'t const` doesn't build useful values, we use it as a "code" to be interpreted by `app` so that `('a, 't const) app` is isomorphic to `'t`.
const_plate [Generic_fun_multiplate]	Specialisation of `plate` to a constant functor.
custom [Generic_core_desc.Custom.T]
D
desc [Generic_core_desc.T]
desc [Generic_core_desc.Method]
desc [Generic_core_desc.Con]	Constructor description.
desc [Generic_core_desc]
desc_fun [Generic_core_desc_fun]	Type of the generic view: a `desc_fun` takes a type witness `'a ty` and computes the description `'a desc`
dyn [Generic_core_ty.Dynamic]
dyn [Generic_core_ty]
dynamic [Generic_core_ty.Dynamic]
dynamic [Generic_core_ty]
dynprod [Generic_core_product]	Union of all product types
E
elt [Generic_core_desc.Array.intf]	`elt` is the element type
empty [Generic_util_sum]	Type with zero element.
equal [Generic_core_equal]	`x : ('a,'b) equal` is a witness that 'a and 'b are intensionally equal.
equal_fun [Generic_core_equal]
exponential [Generic_util_app]	The type `'b exponential` doesn't build useful values, consider it abstract.
extensible [Generic_core_desc.Ext]
F
field [Generic_core_desc.Field.T]	Field.
fields [Generic_core_desc.Fields.T]	List of fields.
functorial [Generic_util_functor.T]
I
id [Generic_util_app]
id_plate [Generic_fun_multiplate]	Specialisation of `plate` to the identity functor.
io [Generic_util_monad.IO]	`Generic_util_monad.IO.io` is used as a type index for `T.app`
iso [Generic_util_fun]	An isomorphism is given by a bijection and its inverse, it must be true that: `fwd (bck x) = bck (fwd x) = x`
L
list' [Generic_util_app]
M
monad [Generic_util_monad.T]
monad [Generic_util_monad]
monoid [Generic_util_monoid.T]
O
obj [Generic_util_obj]	Variant type reflecting the implementation of ocaml values, they are either an immediate (integer) value or a block with a tag and a number of fields.
openrec [Generic_fun_multiplate]
option' [Generic_util_app]
P
pat [Generic_core_ty]
plate [Generic_fun_multiplate]	A plate is a type-indexed function that may transform values of any type while carrying some effect in an applicative functor or a monad.
product [Generic_core_product.T]
R
reader [Generic_util_monad.Reader]
record [Generic_core_desc.Record.T]	Record.
repr [Generic_core_repr]	The concrete representation type is existentially quantified.
repr_by [Generic_core_repr]	`(a,b) repr_by` explains how `a` is represented by `b`.
repr_fun [Generic_core_repr]	Type-indexed function that associates a representation to an abstract type.
S
scrapped [Generic_fun_multiplate]
sp [Generic_view_sumprod]
spine [Generic_view_spine.T]
state [Generic_util_monad.State]
sum [Generic_util_sum]	Sum type.
T
t [Generic_view_conlist]
t [Generic_view_spine]
t [Generic_core_product]	Synonym, so that `Product.T.product` might be refered to as `Product.t`
t [Generic_core_equal]
t [Generic_core_repr]	A synonym, so that `repr` might be referred to as `Repr.t`
t [Generic_core_desc.Custom]
t [Generic_core_desc.Array.intf]	`t` is the array type
t [Generic_core_desc.Class]
t [Generic_core_desc.Object]
t [Generic_core_desc.Method]
t [Generic_core_desc.Poly]	Abstract type representing the set of constructors in a polymorphic variant type
t [Generic_core_desc.Ext]	Synonym for convenience.
t [Generic_core_desc.Variant]	Synonym for convenience.
t [Generic_core_desc.Con]	Synonym for convenience.
t [Generic_core_desc.Record]	Record.
t [Generic_core_desc.Fields]	List of fields.
t [Generic_core_desc.Field]
t [Generic_core_desc]
t [Generic_core_ty]
t [Generic_util_monad]
t [Generic_util_applicative]
t [Generic_util_functor]
t [Generic_util_monoid]
t [Generic_util_app]	Synonym for convenience, when namespace `Generic_util` is opened, and one doesn't want to open `App.T`, one can refer to `App.T.app` as `App.t`.
tag [Generic_util_obj]	Each ocaml values is associated to a tag, an integer.
tuple [Generic_core_product]	A value tagged by the witness of its product type
ty [Generic_core_ty.T]
ty [Generic_core_ty]
ty' [Generic_core_ty]
ty_fun [Generic_core_consumer]	Type-indexed consumer function
ty_fun [Generic_core_extensible]	Type-indexed function, `'b` is the code for a parametric type `'a f` such that `'b ty_fun` is equivalent to `for all 'a . 'a f`
typed [Generic_core_ty.Typed]
typed [Generic_core_ty]
V
variant [Generic_core_desc.Variant]	Variant.
view [Generic_view_conlist]