Index of values


A
abs [Std.Float]
Similar to add but for abs_float
add [Std.Float]
An alternate identifier for +. that performs float addition even if the identifier +. has been redefined.
add [Delimited_overloading.Suspend]
add m suspend overloadings of the module m.
add_to_beginning_of_file [Delimited_overloading]
add_to_beginning_of_file decl add decl (a structure item) to the beginning of the parsed file.
addition [Pa_infix.Level]
Level of "+", "-",...
after [Delimited_overloading]
after t f perform the transformation f e after the overloading have been preformed -- i.e.
apply [Delimited_overloading.Default]
apply m e apply the default overloadings qualified with the module m to the expression e.
apply [Delimited_overloading]
apply t m e apply the overloadings in t to the expression e.
arity [Pa_infix.Level]
arity l returns the arity of that level.
array [Delimited_overloading]
array t f return the "set of overloadings" t augmented with the new function f that specifies how array constants are overloaded for t.
array_get [Delimited_overloading]
array_get t f return the "set of overloadings" t augmented with the new function f that specifies how the construction a.(i) is overloaded for t.
array_set [Delimited_overloading]
array_set t f return the "set of overloadings" t augmented with the new function f that specifies how the construction a.(i) <- x is overloaded for t.
assign [Delimited_overloading]
assign t f return the "set of overloadings" t augmented with the new function f that specifies how the assignment is overloaded for t.
assign_ref [Delimited_overloading]
assign t f return the "set of overloadings" t augmented with the new function f that specifies how the reference assignment is overloaded for t.
assignment [Pa_infix.Level]
Level of ":="
assoc [Pa_infix.Level]
assoc l returns the associativity of that level.
assoc [Pa_infix]
assoc op returns the associativity of the operator op.
associate [Delimited_overloading]
associate_t t m links the "set of overloadings" t to the module longident m.

B
before [Delimited_overloading]
before t f add f to the list of functions to execute before performing an overloading.
bigarray_get [Delimited_overloading]
Same as array_get but for a.{i1,...,iK}.
bigarray_set [Delimited_overloading]
Same as array_set but for a.{i1,...,iK} <- x.
binary [Pa_infix.Level]
binary prec creates a new level for infix operators at the level specified by prec.

C
compare [Pa_infix.Level]
Total ordering on Level.t
compare [Std.Float]
Relocatable expression for a specialized comparison function.
compare [Std.Int]
An expression for a specialized comparison function.
compare [Macro.Module_longident]
Total comparison function on longidents.
comparison [Pa_infix.Level]
Level of "<", "<=", "=",...
comparison [Delimited_overloading]
comparison ?cmp t return the set of overloadings t augmented with the transformations for comparison operators =, <>, <, >, <=, and >= using the function name cmp to overload them.
concat [Delimited_overloading]
concat t1 t2 "concatenates" the overloadings in t1 and t2.
concatenation [Pa_infix.Level]
Level of "^"
conjunction [Pa_infix.Level]
Level of "&&"

D
default_unary [Pa_infix.Level]
Level of "!"
define [Macro.Hook]
Register hook f to be run after the body of a macro has been read; f params boby returns the new body of the macro.
define [Macro]
define name defines the new macro name which has no body.
define_params [Macro.Hook]
Register a hook to be run after the parameters of a macro have been read.
disjunction [Pa_infix.Level]
Level of "||"
div [Std.Float]
Similar to add but for /.

E
empty [Delimited_overloading]
Empty set of overloadings.
eq [Std.Float]
An expression for the equality function ( = ) : float -> float -> bool, optimized for floats.
eq [Std.Nativeint]
An expression for the equality function ( = ) : nativeint -> nativeint -> bool, optimized.
eq [Std.Int64]
An expression for the equality function ( = ) : int64 -> int64 -> bool, optimized.
eq [Std.Int32]
An expression for the equality function ( = ) : int32 -> int32 -> bool, optimized.
eq [Std.Int]
An expression for the equality function ( = ) : int -> int -> bool, optimized for integers.
exponentiation [Pa_infix.Level]
Level of "**", "lsl",...
expr [Delimited_overloading]
expr t f returns a new set of overloadings which executes the transformation f first.
expr_fold [Delimited_overloading]
expr_fold f a0 is the same as Delimited_overloading.expr except that it allows to carry down information while parsing the AST.

F
float [Delimited_overloading]
float t f return the same "set of overloadings" that t with the new function f that specifies how float constants are overloaded for t.

G
ge [Std.Float]
same as eq but for >=
ge [Std.Nativeint]
same as eq but for >=
ge [Std.Int64]
same as eq but for >=
ge [Std.Int32]
same as eq but for >=
ge [Std.Int]
same as eq but for >=
gt [Std.Float]
same as eq but for >
gt [Std.Nativeint]
same as eq but for >
gt [Std.Int64]
same as eq but for >
gt [Std.Int32]
same as eq but for >
gt [Std.Int]
same as eq but for >

H
handle_error [Pa_infix]
handle_error f a applies f to x and returns the result.
hypot [Std.Float]
Expression for hypot x y which computes sqrt(x *. x +. y *. y) without undue underflow or overflow.

I
infix [Pa_infix]
infix op l defines the operator op as a binary infix operator at level l.
int [Delimited_overloading]
int t f return the same "set of overloadings" that t with the new function f that specifies how integer constants are overloaded for t.
int32 [Delimited_overloading]
int32 t f return the "set of overloadings" t augmented with the new function f that specifies how int32 constants are overloaded for t.
int64 [Delimited_overloading]
int64 t f return the "set of overloadings" t augmented with the new function f that specifies how int64 constants are overloaded for t.
is [Macro.Module_longident]
is s returns true iff s represents a module longident.
is_capitalized_identifier [Macro]
Returns true if the string is a capitalized (i.e.
is_defined [Macro]
is_defined name returns true iff the macro name is defined.
is_immediate [Delimited_overloading]
is_immediate e says whether the expression e is "immediate", such as a literal number or string, a variable name, a variable name with type annotation, the dereference of a name,...
is_lowercase_identifier [Macro]
is_lowercase_identifier lid returns true if the string lid is a lowercase identifier.
is_operator [Pa_infix]
is_operator op tells whether the string op can be used as an operator.
is_set [Pa_infix]
is_set op tells whether the operator op has been set using one of the functions of this API.
is_uppercase_identifier [Macro]
Returns true if the string is an uppercase (i.e.

K
kind [Pa_infix]
kind op returns the (default or assigned) kind of the operator op.

L
le [Std.Float]
same as eq but for <=
le [Std.Nativeint]
same as eq but for <=
le [Std.Int64]
same as eq but for <=
le [Std.Int32]
same as eq but for <=
le [Std.Int]
same as eq but for <=
level [Pa_infix]
pos op returns the (default or assigned) level of the operator op.
lid [Delimited_overloading]
lid t op e return the set of overloadings t augmented with the transformation of the identifier op in the relocatable expression e.
lid_remove [Delimited_overloading]
lid_remove t l return the set of overloadings t with all overloadings for a lowercase identifier or an operator in the list l removed.
lid_subst [Delimited_overloading]
lid_subst t ov return the set of overloadings t augmented with the transformations of the identifier op in the identifier op' for all (op, op') in the list ov.
list [Delimited_overloading]
list t f return the "set of overloadings" t augmented with the new function f that specifies how list constants are overloaded for t.
lt [Std.Float]
same as eq but for <
lt [Std.Nativeint]
same as eq but for <
lt [Std.Int64]
same as eq but for <
lt [Std.Int32]
same as eq but for <
lt [Std.Int]
same as eq but for <

M
macro_expansion [Macro.Hook]
At a macro call site, we substitute the macros parameters in the body e of the macro and then apply all functions registered with macro_expansion in the order they were given to obtain the final expression.
max [Std.Float]
Optimized implementation for max
min [Std.Float]
Optimized implementation for min
module_curly_brackets [Delimited_overloading]
Function to be performed on M.{ e }.
module_square_brackets [Delimited_overloading]
Function to be performed on M.[ e ].
mul [Std.Float]
Similar to add but for *.
multiplication [Pa_infix.Level]
Level of "*", "/", "land",...

N
name [Pa_infix.Level]
name l returns the possible name given to the level l.
nativeint [Delimited_overloading]
nativeint t f return the "set of overloadings" t augmented with the new function f that specifies how nativeint constants are overloaded for t.
ne [Std.Float]
same as eq but for <>
ne [Std.Nativeint]
same as eq but for <>
ne [Std.Int64]
same as eq but for <>
ne [Std.Int32]
same as eq but for <>
ne [Std.Int]
same as eq but for <>
neg [Std.Float]
An alternate identifier for ~-. that performs float unary negation even if the identifier ~-. has been redefined.
new_lid [Delimited_overloading]
new_lid() returns the name of a new lowercase identifier.

O
of_id [Macro.Module_longident]
of_id returns the module longident corresponding to an identifier like <:ident< A.B.C >>.
of_list [Macro.Module_longident]
Return the longident from the list of components.
of_string [Macro.Module_longident]
Return the module longident associated with the given string.
openin [Delimited_overloading]
Set (default) or disable (with ~remove:true) the opening of the module M for the expression e when using M.(e).
overloaded [Delimited_overloading]
The function name that serves to protect already overloaded expressions.
overloading [Std.Complex]
In addition to the features listed at the top of this module, overloading_complex allows the notation I or i to designate the pure imaginary complex number and x I, where x is a literal integer or float, to mean x times I.
overloading [Std.Float]
In addition to the above overloadings, the usual float functions like sqrt, exp, cos, sin, acos, floor,...
overloading [Std.Nativeint]
overloading [Std.Int64]
overloading [Std.Int32]
overloading [Std.Int]
The main purpose of this overloading set is to escape subexpressions from a surrounding overloading.
overloading_big_int [Pa_do_num]
overloading_hashtbl [Std]
Allows to use h.(k) for Hashtbl.find h k and h.(k) <- v for Hashtbl.replace h k v.
overloading_num [Pa_do_num]
overloading_ratio [Pa_do_num]
overloading_string [Std]
Trivial overloading to restore the usual meaning of string operations.

P
pi [Std.Float]
Expression for the constant pi
poly_var [Delimited_overloading]
poly_var t f return the "set of overloadings" t augmented with the new function f that specifies how the lowercase polymorphic variants are overloaded for t.
postfix [Pa_infix]
postfix op l define the operator op as a postfix operator at level l.
pow [Std.Float]
Similar to add but for **
prefix [Pa_infix]
prefix op l define the operator op as a prefix operator at level l.

Q
qualify [Macro.Module_longident]
qualify i returns the identifier i, e.g.
qualify_lid [Delimited_overloading]
qualify_lid lid m _loc returns the expression of the operator or function name lid qualified with the module longident m.
qualify_lid [Macro.Module_longident]
qualify_lid lid m _loc returns the expression of the operator or function name lid qualified with the module longident m.
qualify_uid [Macro.Module_longident]
qualify_uid uid m _loc returns the expression of the constructor uid qualified with the module longident m.

R
remove [Delimited_overloading.Suspend]
remove m remove the suspension of overloadings for the module m.
resolve [Delimited_overloading.Suspend]
resolve e removed all the suspended overloading marks from the expression e, applying the module overloadings (according to the currently associated modules).

S
self [Delimited_overloading]
self tr returns the complete transformation object (closed complete when using apply) allowing to apply it to sub-formulas.
std_arithmetic [Delimited_overloading]
std_arithmetic t is just a shortcut for lid_subst t [("+","add"); ("-","sub"); ("~-", "neg"); ("*","mul"); ("/","div")].
string [Delimited_overloading]
string t f return the "set of overloadings" t augmented with the new function f that specifies how string constants are overloaded for t.
string_get [Delimited_overloading]
Same as array_get but for a.[i].
string_set [Delimited_overloading]
Same as array_set but for a.[i] <- x.
sub [Std.Float]
Similar to add but for -.
super [Delimited_overloading]
When adding a new transformation, super tr is the previous transformation that the new one may override.
suspended [Delimited_overloading]
For internal purposes only

T
to_id [Macro.Module_longident]
to_id m loc converts m to an identifier like <:ident< A.B.C >>.
to_string [Macro.Module_longident]
Return a string representing the module longident.
transf_module [Delimited_overloading]
transf_qualify [Delimited_overloading]
transf_qualify tr lid _loc qualify lid by the module longident used to apply the overloadings.

U
unary [Pa_infix.Level]
unnary prec creates a new level for prefix or postfix operators at the level specified by prec.
undef [Macro]
undef name undefines the macro name.
unset [Delimited_overloading.Default]
Remove all default overloadings.
update [Delimited_overloading.Default]
update f updates the set of default overloadings to f t where t is its current value.