Index of values

(f &&. g) x = f x && g x

(g -< f) x = g (f x)

(f >- g) x = g (f x)

(f >>. g) x = f x ; g x

add_con ext c adds c to the constructors of extensible type described by ext

Boolean monoid under conjunction.

Anti-unification for type patterns.

any == Any

Boolean monoid under disjunction.

The arity of a constructor is the number of its arguments.

array == Array Any

Builds a constant constructor.

The list of children of type a of a value of type a

children is a generic function that computes a list of dynamic values which are the immediate children of the given value.

Coerces a value between two intensionally equal types.

con ext x

con x is the constructor of x.

Discriminates each constructor of a variant datatype by returning a distinct pair of (bool,int) for each of them.

returns the current list of constructors

Deconstructs a value of a polymorphic variant into the pair of its constructor and its arguments.

Deconstructs a value into a pair of a constructor and its arguments.

O(1).

Constructor application: the pair of a constructor and its list of arguments.

concat_map f x = concat -< map f

concat_map is the flipped bind operator of the list monad

conpat computes a constructor pattern:

conpat (Pair (Int, List String)) == Pair (Any,Any)

conpat' is the ty' version of conpat, working on index-less type codes.

Builds a 'v cons from a list of constructor descriptions.

cons is useful when we want partial application of the list constructor.

Constant function, ignore the second argument.

create name, creates a new closure initially empty: calling f will raise Type_pattern_match_failure.

create name, creates a new closure initially empty: calling f will raise Type_pattern_match_failure.

Initialises the collection of constructors for an extensible type

cst cs returns the list of the constant constructors in cs.

O(1).

O(1).

Returns the identifier of a custom block, or the empty string if the block isn't a custom one.

the default open-recursive transformation applies its openrec argument to all the children of a value.

Duplicate a block.

Embed an effectful computation in the IO monad

Empty elimination: anything can be proved from a falsehood.

eq x y == E x = E y

erase x is used when only the side effects of a computation are needed, not its value.

extends equal with a new case.

ext t f extends function repr with a new case for type t defined by f.

ext pattern new_case extends desc with a new_case corresponding to the types that match pattern.

Generic view for Generic_core_ty.ty: low level description of the type ty itself.

Adds a constructor to an extensible variant.

Extracts the constructor of an extensible variant (the from a value which may be a constructor application.

Returns the unique object identifier associated with an extensible constructor.

Returns the constructor name of an extensible variant.

Computes the constructor application view for a value of an extensible variant.

ext_fold t is similar to List.fold_right executed on the list of constructors of the extensible variant witnessed by t.

ext_iter t f executes f on each constructor registered with the extensible variant witnessed by t.

Extensible variants are declared with this function.

A family is a list of descendents.

family is a generic function that computes a list of dynamic values which are the descendent of a given value, that is: the value itself and the descendents of its immediate children

fields_all p x y holds iff x and y are both be block of the same size, and the binary predicate p holds for all their fields:

find_index p xs is the index of the first element of xs for which the predicate p is true: p (List.nth xs (find_index p xs)) == true and (n < find_index p xs ==> p (List.nth xs n) == false

findOpt p xs returns Some x if x is the first element of the list xs verifying the predicate p.

Option monoid returning the leftmost non-Nothing value.

Serialising/Deserializing an extensible value (including exceptions) doesn't preserve structural equality:

flip the arguments of a function

Multiplicative monoid.

Additive monoid.

Corresponds to List.fold_right

fold ext computes List.foldr on the constructor list.

Use the plate on each child to get an element of the monoid, and use the monoid to reduce them to a single value.

foldr c n l = List.fold_right c l n

for_all_in a b f is the imperative equivalent of fun a b f -> List.for_all f (from_to a b)

from_to a b = [a; a+1; ... ; b]

get a n returns the element at index n of array a.

Get the argument of the Const constructor

Get the argument of the Exponential constructor

Partial function

get_some (Some x) = x

Either the size of a block (the number of its fields) or 0 for an immediate value.

guard x does nothing if x is true, but raises Generic_util_exn.Failed if x is false.

Identity function

in_range x (a, b)  =  x >= a && x <= b

index x xs is the index of the first element of xs equal to x.

init n f returns a fresh array of length n, with element number i initialized to the result of f i.

Multiplicative monoid.

Additive monoid.

The IO monad operations

True if the value could be a value of a non-polymorphic variant type: the value must be either an immediate value or a block whose tag is within the range of constructor tags.

Returns whether the object is a constructor of an extensible variant.

The identity isomorphism

Executes an effectful function on each of the (known) constructors of an extensible datatype.

Option monoid returning the rightmost non-Nothing value.

Monadic plus, the left argument has priority on the right in case both options have a value.

Corresponds to List.length

Partial lexical order on type patterns used to implement extensible functions allowing nested patterns of any depths.

list == List Any

List monoid

Dynamic products are isomorphic to lists of dynamic values

Forgetting the type index 'a, we obtain a list of unindexed type codes Generic_core_ty.ty'

Given a obj of type (x0,...xn), computes a nested product (x0, (x1, (..., xn) ...))

Builds a con using the corresponding field values

Mapping a function on each component of a product.

Specialisation of fmap_children with the identity functor.

Replace the children of a value using the given function.

Specialisation of fmap_family with the identity monad.

Bottom up (Depth-first, post-order) traversal of a value of a recursive type.

match_list tries to apply a function to the first element of a list.

The maximum length that can be allocated for an array of type t, using the function init.

monadic variant of Generic_fun_uniplate.reduce_family

ncst cs returns the list of the non-constant constructors in cs.

O(1).

O(1).

neq x y == not (eq x y)

true iff the pattern doesn't contain Any, and thus determines a specific type

no_free_var' (E t) == no_free_var' t

one_of xs tries each action of the list xs in turn until one succeeds (meaning that it does not raise any exception).

only_if f x returns x only if f x is true.

opon (^) f x y = f x ^ f y

opres (^) f g x = f x ^ g x

opt_try x forces the lazy value x.

option == Option Any

option f is the functorial action of the functor 'a option:

Some x -> Some (f x)

None -> None

pair == Pair (Any,Any)

Paramorphism.

Returns the hash value associated with a constructor of a polymorphic variant

Generic_fun_uniplate.post_family lists the descendents in post-order: the leaves are first and the root is last

folds a family in post-order

Folds a family in pre-order.

Print the representation to standard output.

Specialisation of pure_plate to the constant functor.

Specialisation of pure_plate to the identity functor.

A plate that lift all values into the applicative functor.

Builds back a value from it's spine view.

given a function that may optionally transform a value, reduce_family returns a function that exhaustively transforms the family of the input.

Replacing the children of a value with new children.

replicate n x = [x; x; ...; x] with x repeated n times.

Recursively replace every occurence of type synonyms with their base type

Run the computation with side effects to obtain a result

safe_find, catches the Not_found exception with a default value:

safe_find table key some none =
  try some (Hashtbl.find table key)
  with Not_found -> none

scrap is a generic function that deconstruct a value in a tuple children with a function to rebuild the value given the children.

Scrap a returns the list of children of type a of a value of type a and a function to replace the children.

set a n x modifies array a in place, replacing element number n with x.

set i x xs computes a new list where the i-th element of xs is x, the rest of the list is unchanged.

An extensible function whose default behaviour is given by Generic_fun_show.show_default

Generic function

Add a ad-hoc case for Generic_fun_show.show.

sl_insert leq x xs inserts the new element x in the sorted list xs using the pre-order <=.

some_if f x = Some x if f x is true, None otherwise

Arguments of the constructor.

Converts the result of Obj.tag to a more descriptive type.

Low level functions

Traversing a product type with effects

Replace each child using the plate.

applicative variant of Generic_fun_uniplate.map_children

Bottom up (Depth-first, post-order) traversal of a value of a recursive type.

monadic variant of Generic_fun_uniplate.map_family

triple == Triple (Any,Any,Any)

Builds a 'v cons from a single constructor.

unopt s n eliminates an option value by replacing the constructor Some by s and None by n.

unopt_try s n x = unopt s n (opt_try x)

Update a hashtable entry.

view = sumprod

view = spine

synonym of Generic_core_repr.repr

Computes the generic view.

A view on the memory representation of values.

with_indices [x0; x1; ...; xn] = [(0,x0); (1,x1); ... ; (n, xn)]

with_type is used to help the type-checker fix the type of a value to the index of ='a ty=.