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 associate d modules).

S  
self [Delimited_overloading]  self tr returns the complete transformation object (closed
complete when using apply ) allowing to apply it to
subformulas.

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.
