module Standard: Extlib.ExtPervasives.Pervasives
The initially opened module.
This module provides the basic operations over the built-in types (numbers, booleans, strings, exceptions, references, lists, arrays, input-output channels, ...)
This module is automatically opened at the beginning of each compilation.
All components of this module can therefore be referred by their short
name, without prefixing them by Standard
.
Automatically opened module.
Author(s): Xavier Leroy (Base module), Nicolas Cannasse, David Teller, Zheng Li
val raise : exn -> 'a
val invalid_arg : string -> 'a
Invalid_argument
with the given string.val failwith : string -> 'a
Failure
with the given string.
Note This function is provided as a simple technique for
exiting a function or a program with an error message. It is
however considered a bad practice to define a library which makes
use of this function. So don't use it except for quick experiments
and for teaching.
val exit : int -> 'a
flush_all
.
An implicit exit 0
is performed each time a program
terminates normally. An implicit exit 2
is performed if the program
terminates early because of an uncaught exception.val at_exit : (unit -> unit) -> unit
at_exit
will be called when the program executes Standard.exit
,
or terminates, either normally or because of an uncaught exception.
The functions are called in ``last in, first out'' order:
the function most recently added with at_exit
is called first.val (=) : 'a -> 'a -> bool
e1 = e2
tests for structural equality of e1
and e2
.
Mutable structures (e.g. references and arrays) are equal
if and only if their current contents are structurally equal,
even if the two mutable objects are not the same physical object.
Equality between functional values raises Invalid_argument
.
Equality between cyclic data structures does not terminate.val (<>) : 'a -> 'a -> bool
Standard.(=)
.val (<) : 'a -> 'a -> bool
Standard.(>=)
.val (>) : 'a -> 'a -> bool
Standard.(>=)
.val (<=) : 'a -> 'a -> bool
Standard.(>=)
.val (>=) : 'a -> 'a -> bool
(=)
. As in the case
of (=)
, mutable structures are compared by contents.
Comparison between functional values raises Invalid_argument
.
Comparison between cyclic structures does not terminate.val compare : 'a -> 'a -> int
compare x y
returns 0
if x
is equal to y
,
a negative integer if x
is less than y
, and a positive integer
if x
is greater than y
. The ordering implemented by compare
is compatible with the comparison predicates =
, <
and >
defined above, with one difference on the treatment of the float value
Standard.nan
. Namely, the comparison predicates treat nan
as different from any other float value, including itself;
while compare
treats nan
as equal to itself and less than any
other float value. This treatment of nan
ensures that compare
defines a total ordering relation.
compare
applied to functional values may raise Invalid_argument
.
compare
applied to cyclic structures may not terminate.
The compare
function can be used as the comparison function
required by the Set.Make
and Map.Make
functors, as well as
the List.sort
and Array.sort
functions.
val min : 'a -> 'a -> 'a
val max : 'a -> 'a -> 'a
val (==) : 'a -> 'a -> bool
e1 == e2
tests for physical equality of e1
and e2
.
On integers and characters, physical equality is identical to structural
equality. On mutable structures, e1 == e2
is true if and only if
physical modification of e1
also affects e2
.
On non-mutable structures, the behavior of (==)
is
implementation-dependent; however, it is guaranteed that
e1 == e2
implies compare e1 e2 = 0
.val (!=) : 'a -> 'a -> bool
Standard.(==)
.val not : bool -> bool
val (&&) : bool -> bool -> bool
e1 && e2
, e1
is evaluated first, and if it returns false
,
e2
is not evaluated at all.val (&) : bool -> bool -> bool
val (||) : bool -> bool -> bool
e1 || e2
, e1
is evaluated first, and if it returns true
,
e2
is not evaluated at all.Integers are 31 bits wide (or 63 bits on 64-bit processors). All operations are taken modulo 231 (or 263).
Note These operations do not fail on overflow. In other words,
although Standard.max_int
is the largest possible integer, addition
max_int + 1
will succeed. However, the result if this addition
is min_int
. If you wish your operations to fail on overflow,
open module Data.Numeric.SafeInt
.
More operations on integers are defined in Int
, SafeInt
,
Int32
, Int64
and Native_int
.
val (~-) : int -> int
-e
instead of ~-e
.val succ : int -> int
succ x
is x+1
.val pred : int -> int
pred x
is x-1
.val (+) : int -> int -> int
val (-) : int -> int -> int
val (*) : int -> int -> int
val (/) : int -> int -> int
Division_by_zero
if the second argument is 0.
Integer division rounds the real quotient of its arguments towards zero.
More precisely, if x >= 0
and y > 0
, x / y
is the greatest integer
less than or equal to the real quotient of x
by y
. Moreover,
(-x) / y = x / (-y) = -(x / y)
.val mod : int -> int -> int
y
is not zero, the result
of x mod y
satisfies the following properties:
x = (x / y) * y + x mod y
and
abs(x mod y) <= abs(y)-1
.
If y = 0
, x mod y
raises Division_by_zero
.
Notice that x mod y
is nonpositive if and only if x < 0
.
Raise Division_by_zero
if y
is zero.val abs : int -> int
min_int
.val max_int : int
val min_int : int
val land : int -> int -> int
val lor : int -> int -> int
val lxor : int -> int -> int
val lnot : int -> int
val lsl : int -> int -> int
n lsl m
shifts n
to the left by m
bits.
The result is unspecified if m < 0
or m >= bitsize
,
where bitsize
is 32
on a 32-bit platform and
64
on a 64-bit platform.val lsr : int -> int -> int
n lsr m
shifts n
to the right by m
bits.
This is a logical shift: zeroes are inserted regardless of
the sign of n
.
The result is unspecified if m < 0
or m >= bitsize
.val asr : int -> int -> int
n asr m
shifts n
to the right by m
bits.
This is an arithmetic shift: the sign bit of n
is replicated.
The result is unspecified if m < 0
or m >= bitsize
.
Caml's floating-point numbers follow the
IEEE 754 standard, using double precision (64 bits) numbers.
Floating-point operations never raise an exception on overflow,
underflow, division by zero, etc. Instead, special IEEE numbers
are returned as appropriate, such as infinity
for 1.0 /. 0.0
,
neg_infinity
for -1.0 /. 0.0
, and nan
(``not a number'')
for 0.0 /. 0.0
. These special numbers then propagate through
floating-point computations as expected: for instance,
1.0 /. infinity
is 0.0
, and any operation with nan
as
argument returns nan
as result.
More floating-point operations are defined in Float
.
val (~-.) : float -> float
-.e
instead of ~-.e
.val (+.) : float -> float -> float
val (-.) : float -> float -> float
val (*.) : float -> float -> float
val (/.) : float -> float -> float
val (**) : float -> float -> float
val sqrt : float -> float
val exp : float -> float
val log : float -> float
val log10 : float -> float
val cos : float -> float
Standard.atan2
.val sin : float -> float
Standard.atan2
.val tan : float -> float
Standard.atan2
.val acos : float -> float
Standard.atan2
.val asin : float -> float
Standard.atan2
.val atan : float -> float
Standard.atan2
.val atan2 : float -> float -> float
val cosh : float -> float
Standard.tanh
.val sinh : float -> float
Standard.tanh
.val tanh : float -> float
val ceil : float -> float
Standard.floor
.val floor : float -> float
floor f
returns the greatest integer value less than or
equal to f
.
ceil f
returns the least integer value greater than or
equal to f
.val abs_float : float -> float
val mod_float : float -> float -> float
mod_float a b
returns the remainder of a
with respect to
b
. The returned value is a -. n *. b
, where n
is the quotient a /. b
rounded towards zero to an integer.val frexp : float -> float * int
frexp f
returns the pair of the significant
and the exponent of f
. When f
is zero, the
significant x
and the exponent n
of f
are equal to
zero. When f
is non-zero, they are defined by
f = x *. 2 ** n
and 0.5 <= x < 1.0
.val ldexp : float -> int -> float
ldexp x n
returns x *. 2 ** n
.val modf : float -> float * float
modf f
returns the pair of the fractional and integral
part of f
.val float : int -> float
Standard.float_of_int
.val float_of_int : int -> float
val truncate : float -> int
Standard.int_of_float
.val int_of_float : float -> int
nan
or falls outside the
range of representable integers.val infinity : float
val neg_infinity : float
val nan : float
0.0 /. 0.0
. Stands for
``not a number''. Any floating-point operation with nan
as
argument returns nan
as result. As for floating-point comparisons,
=
, <
, <=
, >
and >=
return false
and <>
returns true
if one or both of their arguments is nan
.
More string operations are provided in module String
.
val (^) : string -> string -> string
val uppercase : string -> string
val lowercase : string -> string
More character operations are provided in module Char
.
val int_of_char : char -> int
val char_of_int : int -> char
Invalid_argument "char_of_int"
if the argument is
outside the range 0--255.
More unit operations are provided in module Unit
val ignore : 'a -> unit
()
.
For instance, ignore(f x)
discards the result of
the side-effecting function f
. It is equivalent to
f x; ()
, except that the latter may generate a
compiler warning; writing ignore(f x)
instead
avoids the warning.
These are the most common string conversion functions. For
additional string conversion functions, see in the corresponding
module (e.g. for conversion between int32
and string
,
see module Int32
).
val string_of_char : char -> string
val string_of_bool : bool -> string
val bool_of_string : string -> bool
Invalid_argument "bool_of_string"
if the string is not
"true"
or "false"
.val string_of_int : int -> string
val int_of_string : string -> int
0x
or 0X
), octal (if it begins with 0o
or 0O
),
or binary (if it begins with 0b
or 0B
).
Raise Failure "int_of_string"
if the given string is not
a valid representation of an integer, or if the integer represented
exceeds the range of integers representable in type int
.val string_of_float : float -> string
val float_of_string : string -> float
Failure "float_of_string"
if the given string is not a valid representation of a float.val dump : 'a -> string
Since types are lost at compile time, the representation might not
match your type. For example, None will be printed 0 since they
share the same runtime representation.
More list operations are provided in module List
.
val (@) : 'a list -> 'a list -> 'a list
This section only contains the most common input/output operations.
More operations may be found in modules IO
and File
.
val stdin : IO.input
Use this input to read what the user is writing on the keyboard.
val stdout : unit IO.output
Use this output to display regular messages.
val stderr : unit IO.output
Use this output to display warnings and error messages.
val stdnull : unit IO.output
Use this output to ignore messages.
val flush_all : unit -> unit
It is normally not necessary to call this function, as all pending
data is written when an output channel is closed or when the
program itself terminates, either normally or because of an
uncaught exception. However, this function is useful for
debugging, as it forces pending data to be written immediately.
val print_bool : bool -> unit
val print_char : char -> unit
val print_string : string -> unit
val print_int : int -> unit
val print_float : float -> unit
val print_endline : string -> unit
val print_newline : unit -> unit
val print_guess : 'a -> unit
Standard.dump
. This function is
useful mostly for debugging. As a general rule, it should not be
used in production code.val print_all : IO.input -> unit
val prerr_bool : bool -> unit
val prerr_char : char -> unit
val prerr_string : string -> unit
val prerr_int : int -> unit
val prerr_float : float -> unit
val prerr_endline : string -> unit
val prerr_newline : unit -> unit
val prerr_guess : 'a -> unit
Standard.dump
. This function is
useful mostly for debugging.val prerr_all : IO.input -> unit
val read_line : unit -> string
val read_int : unit -> int
Failure "int_of_string"
if the line read is not a valid representation of an integer.val read_float : unit -> float
val open_out : ?mode:File.open_out_flag list ->
?perm:File.permission -> string -> unit IO.output
You may use optional argument mode
to decide whether the
output will overwrite the contents of the file (by default) or
to add things at the end of the file, whether the file should be
created if it does not exist yet (the default) or not, whether
this operation should proceed if the file exists already (the
default) or not, whether the file should be opened as text
(the default) or as binary, and whether the file should be
opened for non-blocking operations.
You may use optional argument perm
to specify the permissions
of the file, as per Unix conventions. By default, files are created
with default permissions (which depend on your setup).
Raise Sys_error
if the file could not be opened.
val open_out_bin : string -> unit IO.output
Standard.open_out
, but the file is opened in binary mode, so
that no translation takes place during writes. On operating
systems that do not distinguish between text mode and binary
mode, this function behaves like Standard.open_out
without any
mode
or perm
.val open_out_gen : open_flag list -> int -> string -> unit IO.output
open_out instead
open_out_gen mode perm filename
opens the named file for writing,
as described above. The extra argument mode
specifies the opening mode. The extra argument perm
specifies
the file permissions, in case the file must be created.val flush : unit IO.output -> unit
val output_char : unit IO.output -> char -> unit
val output_string : unit IO.output -> string -> unit
val output_rope : unit IO.output -> Rope.t -> unit
val output : unit IO.output -> string -> int -> int -> unit
output oc buf pos len
writes len
characters from string buf
,
starting at offset pos
, to the given output channel oc
.
Raise Invalid_argument "output"
if pos
and len
do not
designate a valid substring of buf
.val output_byte : unit IO.output -> int -> unit
val output_binary_int : unit IO.output -> int -> unit
Standard.input_binary_int
function. The format is compatible across
all machines for a given version of Objective Caml.val output_value : unit IO.output -> 'a -> unit
Standard.input_value
. See the description of module
Marshal
for more information. Standard.output_value
is equivalent
to Marshal.output
with an empty list of flags.val close_out : unit IO.output -> unit
Sys_error
exception when they are
applied to a closed output channel, except close_out
and flush
,
which do nothing when applied to an already closed channel.
Note that close_out
may raise Sys_error
if the operating
system signals an error when flushing or closing.val close_out_noerr : unit IO.output -> unit
close_out
, but ignore all errors.val open_in : ?mode:File.open_in_flag list ->
?perm:File.permission -> string -> IO.input
You may use optional argument mode
to decide whether the opening
should fail if the file doesn't exist yet (by default) or whether
the file should be created if it doesn't exist yet, whether the
opening should fail if the file already exists or not (by
default), whether the file should be read as binary (by default)
or as text, and whether reading should be non-blocking.
You may use optional argument perm
to specify the permissions of
the file, should it be created, as per Unix conventions. By
default, files are created with default permissions (which depend
on your setup).
Raise Sys_error
if the file could not be opened.
val open_in_bin : string -> IO.input
Standard.open_in
, but the file is opened in binary mode,
so that no translation takes place during reads. On operating
systems that do not distinguish between text mode and binary
mode, this function behaves like Standard.open_in
.val open_in_gen : open_flag list -> int -> string -> IO.input
open_in instead
open_in mode perm filename
opens the named file for reading,
as described above. The extra arguments mode
and perm
specify the opening mode and file permissions.
Standard.open_in
and Standard.open_in_bin
are special
cases of this function.val input_char : IO.input -> char
End_of_file
if there are no more characters to read.val input_line : IO.input -> string
End_of_file
if the end of the file is reached
at the beginning of line.val input : IO.input -> string -> int -> int -> int
input ic buf pos len
reads up to len
characters from
the given channel ic
, storing them in string buf
, starting at
character number pos
.
It returns the actual number of characters read, between 0 and
len
(inclusive).
A return value of 0 means that the end of file was reached.
A return value between 0 and len
exclusive means that
not all requested len
characters were read, either because
no more characters were available at that time, or because
the implementation found it convenient to do a partial read;
input
must be called again to read the remaining characters,
if desired. (See also Standard.really_input
for reading
exactly len
characters.)
Exception Invalid_argument "input"
is raised if pos
and len
do not designate a valid substring of buf
.val really_input : IO.input -> string -> int -> int -> unit
really_input ic buf pos len
reads len
characters from channel ic
,
storing them in string buf
, starting at character number pos
.
Raise End_of_file
if the end of file is reached before len
characters have been read.
Raise Invalid_argument "really_input"
if
pos
and len
do not designate a valid substring of buf
.val input_byte : IO.input -> int
Standard.input_char
, but return the 8-bit integer representing
the character.
Raise End_of_file
if an end of file was reached.val input_binary_int : IO.input -> int
Standard.output_binary_int
.
Raise End_of_file
if an end of file was reached while reading the
integer.val input_value : IO.input -> 'a
Standard.output_value
, and return the corresponding value.
This function is identical to Marshal.input
;
see the description of module Marshal
for more information,
in particular concerning the lack of type safety.val close_in : IO.input -> unit
Sys_error
exception when they are applied to a closed input channel,
except close_in
, which does nothing when applied to an already
closed channel. Note that close_in
may raise Sys_error
if
the operating system signals an error.val close_in_noerr : IO.input -> unit
close_in
, but ignore all errors.
More operations on references are defined in module Ref
.
val ref : 'a -> 'a ref
val (!) : 'a ref -> 'a
!r
returns the current contents of reference r
.
Equivalent to fun r -> r.contents
.val (:=) : 'a ref -> 'a -> unit
r := a
stores the value of a
in reference r
.
Equivalent to fun r v -> r.contents <- v
.val incr : int ref -> unit
fun r -> r := succ !r
.val decr : int ref -> unit
fun r -> r := pred !r
.type('a, 'b, 'c, 'd)
format4 =('a, 'b, 'c, 'c, 'c, 'd) format6
type('a, 'b, 'c)
format =('a, 'b, 'c, 'c) format4
'a
is the type of the parameters of the format,
'c
is the result type for the "printf"-style function,
and 'b
is the type of the first argument given to
%a
and %t
printing functions.val string_of_format : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> string
val format_of_string : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('a, 'b, 'c, 'd, 'e, 'f) format6
format_of_string s
returns a format string read from the string
literal s
.val (^^) : ('a, 'b, 'c, 'd, 'e, 'f) format6 ->
('f, 'b, 'c, 'e, 'g, 'h) format6 -> ('a, 'b, 'c, 'd, 'g, 'h) format6
f1 ^^ f2
catenates formats f1
and f2
. The result is a format
that accepts arguments from f1
, then arguments from f2
.val identity : 'a -> 'a
val undefined : ?message:string -> 'a -> 'b
Evaluating undefined x
always fails and raises an exception
"Undefined". Optional argument message
permits the
customization of the error message.
val (|>) : 'a -> ('a -> 'b) -> 'b
x |> f
is equivalent to f x
.
This operator is commonly used to write a function composition by order of evaluation (the order used in object-oriented programming) rather than by inverse order (the order typically used in functional programming).
For instance, g (f x)
means "apply f
to x
, then apply g
to
the result." The corresponding notation in most object-oriented
programming languages would be somewhere along the lines of x.f.g
()
, or "starting from x
, apply f
, then apply g
." In OCaml,
operator ( |> ) this latest notation maps to x |> f |> g
, or
This operator may also be useful for composing sequences of
function calls without too many parenthesis.
val (**>) : ('a -> 'b) -> 'a -> 'b
f **> x
is equivalent to f x
.
This operators may be useful for composing sequences of function calls without too many parenthesis.
Note The name of this operator is not written in stone.
It is bound to change soon.
val (|-) : ('a -> 'b) -> ('b -> 'c) -> 'a -> 'c
f |- g
is fun x -> g (f x)
.
This is also equivalent to applying <**
twice.val (-|) : ('a -> 'b) -> ('c -> 'a) -> 'c -> 'b
f -| g
is fun x -> f (g x)
. Mathematically, this is
operator o.val flip : ('a -> 'b -> 'c) -> 'b -> 'a -> 'c
flip f x y
is f y x
. Don't abuse this function, it may shorten considerably
your code but it also has the nasty habit of making it harder to read.
val (***) : ('a -> 'b) -> ('c -> 'd) -> 'a * 'c -> 'b * 'd
f *** g
is fun (x,y) -> (f x, g y)
.
val (&&&) : ('a -> 'b) -> ('a -> 'c) -> 'a -> 'b * 'c
f &&& g
is fun x -> (f x, g x)
.
val first : ('a -> 'b) -> 'a * 'c -> 'b * 'c
first f (x, y)
is (f x, y)
val second : ('a -> 'b) -> 'c * 'a -> 'c * 'b
second f (x, y)
is (x, f y)
val curry : ('a * 'b -> 'c) -> 'a -> 'b -> 'c
curry f
is fun x y -> f (x,y)
val uncurry : ('a -> 'b -> 'c) -> 'a * 'b -> 'c
uncurry f
is fun (x, y) -> f x y
val const : 'a -> 'b -> 'a
const x
is the function which always returns x
.
val unique : unit -> int
Note This is thread-safe.
val finally : (unit -> unit) -> ('a -> 'b) -> 'a -> 'b
finally fend f x
calls f x
and then fend()
even if f x
raised
an exception.val args : unit -> string Enum.t
args ()
is given by the elements of Sys.argv
, minus the first element.
val exe : string
exe
is given by the first argument of Sys.argv
In OCaml Batteries Included, all data structures are enumerable,
which means that they support a number of standard operations,
transformations, etc. The general manner of enumerating the
contents of a data structure is to invoke the enum
function of
your data structure.
For instance, you may use the Standard.foreach
loop to apply a function
f
to all the consecutive elements of a string s
. For this
purpose, you may write either foreach (String.enum s) f
or open
String in foreach (enum s) f
. Either possibility states that you
are enumerating through a character string s
. Should you prefer
your enumeration to proceed from the end of the string to the
beginning, you may replace String.enum
with String.backwards
. Therefore, either foreach (String.backwards s)
f
or open String in foreach (backwards s) f
will apply f
to all the consecutive elements of string s
, from the last to
the first.
Similarly, you may use List.enum
instead of String.enum
to
visit the elements of a list in the usual order, or
List.backwards
instead of String.backwards
to visit them
in the opposite order, or Hashtbl.enum
for hash tables, etc.
More operations on enumerations are defined in module Enum
,
including the necessary constructors to make your own structures
enumerable.
The various kinds of loops are detailed further in this documentation.
val foreach : 'a Enum.t -> ('a -> unit) -> unit
foreach e f
applies function f
to each successive element of e
.
For instance, foreach (1 -- 10) print_int
invokes function print_int
on 1
, 2
, ..., 10
, printing 12345678910
.
Note This function is one of the many loops available on
enumerations. Other commonly used loops are Standard.iter
(same usage
scenario as foreach
, but with different notations), Standard.map
(convert an enumeration to another enumeration) or Standard.fold
(flatten an enumeration by applying an operation to each
element).
The following functions are the three main general-purpose loops available in OCaml. By opposition to the loops available in imperative languages, OCaml loops are regular functions, which may be passed, composed, currified, etc. In particular, each of these loops may be considered either as a manner of applying a function to a data structure or as transforming a function into another function which will act on a whole data structure.
For instance, if f
is a function operating on one value, you may
lift this function to operate on all values of an enumeration (and
consequently on all values of any data structure of OCaml Batteries
Included) by applying Standard.iter
, Standard.map
or Standard.fold
to this function.
val iter : ('a -> unit) -> 'a Enum.t -> unit
If f
is a function iter f
is a function which behaves as f
but acts upon enumerations rather than individual elements. As
indicated in the type of iter
, f
must produce values of type
unit
(i.e. f
has no meaningful result) the resulting function
produces no meaningful result either.
In other words, iter f
is a function which, when applied upon
an enumeration e
, calls f
with each element of e
in turn.
For instance, iter f (1 -- 10)
invokes function f
on 1
,
2
, ..., 10
and produces value ()
.
val map : ('a -> 'b) -> 'a Enum.t -> 'b Enum.t
If f
is a function, map f e
is a function which behaves as
f
but acts upon enumerations rather than individual elements --
and builds a new enumeration from the results of each application.
In other words, map f
is a function which, when applied
upon an enumeration containing elements e1
, e2
, ...,
produces enumeration f e1
, f e2
, ...
For instance, if odd
is the function which returns true
when applied to an odd number or false
when applied to
an even number, map odd (1 -- 10)
produces enumeration
true
, false
, true
, ..., false
.
Similarly, if square
is the function fun x -> x * x
,
map square (1 -- 10)
produces the enumeration of the
square numbers of all numbers between 1
and 10
.
val reduce : ('a -> 'a -> 'a) -> 'a Enum.t -> 'a
If f
is a function and e
is an enumeration, reduce f e
applies
function f
to the first two elements of e
, then to the result of this
expression and to the third element of e
, then to the result of this
new expression and to the fourth element of e
...
In other words, fold f e
returns a_1
if e
contains only
one element, otherwise f (... (f (f a1) a2) ...) aN
where
a1..N are the elements of e
.
val fold : ('a -> 'b -> 'a) -> 'a -> 'b Enum.t -> 'a
If f
is a function, fold f v e
applies f v
to the first
element of e
, then, calling acc_1
the result of this
operation, applies f acc_1
to the second element of e
, then,
calling acc_2
the result of this operation, applies f acc_2
to the third element of e
...
In other words, fold f v e
returns v
if e
is empty,
otherwise f (... (f (f v a1) a2) ...) aN
where a1..N are
the elements of e
.
For instance, if add
is the function fun x y -> x + y
,
fold add 0
is the function which computes the sum of the
elements of an enumeration. Therefore, fold add 0 (1 -- 10)
produces result 55
.
val scanl : ('a -> 'b -> 'a) -> 'a -> 'b Enum.t -> 'a Enum.t
Standard.fold
which returns not only the final
result of Standard.fold
but the enumeration of all the intermediate
results of Standard.fold
.
If f
is a function, scanl f v e
is applies f v
to the first
element of e
, then, calling acc_1
the result of this
operation, applies f acc_1
to the second element of e
, then,
calling acc_2
the result of this operation, applies f acc_2
to the third element of e
...
For instance, if add
is the function fun x y -> x + y
,
scanl add 0
is the function which computes the sum of the
elements of an enumeration. Therefore, scanl add 0 (1 -- 10)
produces result the enumeration with elements 0, 1, 3, 6, 10,
15, 21, 28, 36, 45, 55
.
val (/@) : 'a Enum.t -> ('a -> 'b) -> 'b Enum.t
val (@/) : ('a -> 'b) -> 'a Enum.t -> 'b Enum.t
These operators have the same meaning as function Standard.map
but are
sometimes more readable than this function, when chaining
several transformations in a row.
val exists : ('a -> bool) -> 'a Enum.t -> bool
exists f e
returns true
if there is some x
in e
such
that f x
val for_all : ('a -> bool) -> 'a Enum.t -> bool
exists f e
returns true
if for every x
in e
, f x
is trueval find : ('a -> bool) -> 'a Enum.t -> 'a
find f e
returns the first element x
of e
such that f x
returns
true
, consuming the enumeration up to and including the
found element, or, raises Not_found
if no such element exists
in the enumeration, consuming the whole enumeration in the search.
Since find
consumes a prefix of the enumeration, it can be used several
times on the same enumeration to find the next element.
val peek : 'a Enum.t -> 'a option
peek e
returns None
if e
is empty or Some x
where x
is
the next element of e
. The element is not removed from the
enumeration.val get : 'a Enum.t -> 'a option
get e
returns None
if e
is empty or Some x
where x
is
the next element of e
, in which case the element is removed
from the enumeration.val push : 'a Enum.t -> 'a -> unit
push e x
will add x
at the beginning of e
.val junk : 'a Enum.t -> unit
junk e
removes the first element from the enumeration, if any.val filter : ('a -> bool) -> 'a Enum.t -> 'a Enum.t
filter f e
returns an enumeration over all elements x
of e
such
as f x
returns true
.val (//) : 'a Enum.t -> ('a -> bool) -> 'a Enum.t
For instance, (1 -- 37) // odd
is the enumeration of all odd
numbers between 1 and 37.
val concat : 'a Enum.t Enum.t -> 'a Enum.t
concat e
returns an enumeration over all elements of all enumerations
of e
.val (--) : int -> int -> int Enum.t
5 -- 10
is the enumeration 5,6,7,8,9,10.
10 -- 5
is the empty enumeration
val (--.) : float * float -> float -> float Enum.t
(a, step) --. b)
creates a float enumeration from a
to b
with an
increment of step
between elements.
(5.0, 1.0) --. 10.0
is the enumeration 5.0,6.0,7.0,8.0,9.0,10.0.
(10.0, -1.0) --. 5.0
is the enumeration 10.0,9.0,8.0,7.0,6.0,5.0.
(10.0, 1.0) --. 1.0
is the empty enumeration.
val (---) : int -> int -> int Enum.t
--
, but accepts enumerations in reverse order.
5 --- 10
is the enumeration 5,6,7,8,9,10.
10 --- 5
is the enumeration 10,9,8,7,6,5.
val (--~) : char -> char -> char Enum.t
val print : ?first:string ->
?last:string ->
?sep:string ->
('a Extlib.InnerIO.output -> 'b -> unit) ->
'a Extlib.InnerIO.output -> 'b Enum.t -> unit
type('a, 'b)
result =('a, 'b) Extlib.Std.result
=
| |
Ok of |
| |
Bad of |
val sexp_of_result : ('a -> Sexplib.Sexp.t) ->
('b -> Sexplib.Sexp.t) ->
('a, 'b) result -> Sexplib.Sexp.t
val result_of_sexp : (Sexplib.Sexp.t -> 'a) ->
(Sexplib.Sexp.t -> 'b) ->
Sexplib.Sexp.t -> ('a, 'b) result
Unless you are attempting to adapt Batteries Included to a new model of
concurrency, you probably won't need this.
val lock : Concurrency.lock ref
By default, this is Concurrency.nolock
. However, if you're using a version
of Batteries compiled in threaded mode, this uses Threads.Mutex
. If you're attempting
to use Batteries with another concurrency model, set the lock appropriately.