Index of values


( * ) [Int_intf.S]
( * ) [Float]
(!) [Ref]
(+) [Int_intf.S]
(+) [Float]
(-) [Int_intf.S]
(-) [Float]
(/) [Int_intf.S]
(/) [Float]
(:=) [Ref]
(<) [Comparable.Infix]
(<.) [Robustly_comparable.S]
(</>) [Core_string.Infix]
(<=) [Comparable.Infix]
(<=.) [Robustly_comparable.S]
(<>) [Equatable.Infix]
(<>) [Comparable.Infix]
(<>.) [Robustly_comparable.S]
(<|) [Core_hashtbl.S.Infix]
(<|) [Core_hashtbl.Infix]
(<|>) [Core_array.Infix]
(=) [Equatable.Infix]
(=) [Comparable.Infix]
(=.) [Robustly_comparable.S]
(==>) [Quickcheck]
(>) [Comparable.Infix]
(>.) [Robustly_comparable.S]
(>=) [Comparable.Infix]
(>=.) [Robustly_comparable.S]
(>>=) [Monad.Infix]
t >>= f returns a computation that sequences the computations represented by two monad elements.
(>>|) [Monad.Infix]
t >>| f is t >>= (fun a -> return (f a)).
(@) [Core_list.Infix]
(|>) [Core_hashtbl.S.Infix]
(|>) [Core_hashtbl.Infix]
(|?>) [Core_hashtbl.S.Infix]
(|?>) [Core_hashtbl.Infix]

A
abort [Unix_ext]
abs [Int_intf.S]
abs [Float]
accept [Core_unix]
Accept connections on the given socket.
access [Core_unix]
Check that the process has the given permissions over the named file.
add [Unix_ext.RUsage]
RUsage.add ru1 ru2 adds two rusage structures (e.g.
add [Timer]
add timer handler ?randomize ?interval span
add [PSet]
add [Linux_ext.Epoll]
add [Int_intf.S]
add [Hash_set.Mono_or_poly]
add [Hash_set.Make_mono_or_poly]
add [Float]
add [Fast_hashtbl]
add [Core_hashtbl.S]
add [Core_hashtbl]
add [Bag]
add t v adds v to the bag t, returning an element that can later be removed from the bag.
add_abs [Timer]
add_abs timer handler ?randomize ?interval time same as Timer.add, but takes an absolute time time for scheduling the event rather than a span.
add_buffer [Bigbuffer]
add_buffer b1 b2 appends the current contents of buffer b2 at the end of buffer b1.
add_channel [Bigbuffer]
add_channel b ic n reads exactly n character from the input channel ic and stores them at the end of buffer b.
add_char [Bigbuffer]
add_char b c appends the character c at the end of the buffer b.
add_string [Bigbuffer]
add_string b s appends the string s at the end of the buffer b.
add_substitute [Bigbuffer]
add_substitute b f s appends the string pattern s at the end of the buffer b with substitution.
add_substring [Bigbuffer]
add_substring b s ofs len takes len characters from offset ofs in string s and appends them at the end of the buffer b.
alarm [Core_unix]
Schedule a SIGALRM signal after the given number of seconds.
align [Core_arg]
all [Pretty_printer]
all [Interned.Make]
allocated_bytes [Core_gc]
Return the total number of bytes allocated since the program was started.
always [Quickcheck]
generator that always returns given value
append [Core_list]
Tail-recursive append.
append [Core_array]
apply [Result]
apply [Option]
apply x f run optional function on argument and return an option
apr [Month]
ascending [Comparable.S]
ascending [Comparable.Inherit]
ascending [Comparable.From_compare]
ascending [Comparable.Poly]
assoc [Core_list]
assoc' [Core_list]
assoc_exn' [Core_list]
assoc_opt [Core_list]
assoc_opt a l returns the value associated with key a in the list of pairs l * as an option.
aug [Month]

B
back_index [Dequeue]
basename [Core_filename]
best [Core_list]
best is an alias for reduce.
best [Core_array]
best is an alias for reduce.
big_contents [Bigbuffer]
Return a copy of the current contents of the buffer as a bigstring.
bigstring_kind [Unix_ext.IOVec]
bind [Result]
bind [Monad.Basic]
bind [Monad.Make]
bind [Monad.S]
bind t f = t >>= f
bind [Core_unix]
Bind a socket to an address.
bits_of_float [Core_int64]
bits_of_float [Core_int32]
blit [Core_string]
blit [Core_array]
blit [Bigstring]
blit_bigstring_string [Bigstring]
blit_string_bigstring [Bigstring]
bot [Fqueue]
like bot_exn, but returns result optionally, without exception
bot_exn [Fqueue]
returns the bottom (most-recently enqueued element).
bprintf [Core_printf]
bprintf [Bigbuffer.Printf]
bprintf [Bigbuffer.Format]

C
call [Result]
call [Option]
call x f run optional function on argument
capitalize [Core_string]
cardinal [PSet]
cartesian_product [Core_list]
cartesian_product [Core_array]
cg [Quickcheck]
chdir [Core_unix]
Change the process working directory.
check [Error_check.Step]
check [Error_check.Timer]
check [Error_check.ToggleN]
check [Error_check.Toggle]
check_args [Bigstring]
check_heap_property [Heap]
check_prefix [Core_string]
check_prefix s pref returns true if the string s starts with the prefix pref
check_suffix [Core_string]
check_suffix s suff returns true if the string s ends with the suffix suff
check_suffix [Core_filename]
chmod [Core_unix]
Change the permissions of the named file.
choose [PSet]
choose_exn [PSet]
chop_extension [Core_filename]
chop_prefix [Core_string]
drop_prefix t suff returns a copy t without the trailing pref
chop_suffix [Core_string]
drop_suffix t suff returns a copy t without the trailing suff
chop_suffix [Core_filename]
chown [Core_unix]
Change the owner uid and owner gid of the named file.
chroot [Core_unix]
Change the process root directory.
classify [Float]
clear [Squeue]
clears the queue
clear [Hash_set.Mono_or_poly]
clear [Hash_set.Make_mono_or_poly]
clear [Hash_queue.S]
clear [Hash_queue.Make]
clear [Fast_hashtbl]
clear [Doubly_linked]
clear t removes all elements from the list in constant time.
clear [Core_stack]
clear t discards all elements from t.
clear [Core_queue]
clear t discards all elements from t.
clear [Core_hashtbl.S]
clear [Core_hashtbl]
clear [Bigbuffer]
Empty the buffer.
clear [Bag]
clear t removes all elements from the bag.
clear_close_on_exec [Core_unix]
Clear the ``close-on-exec'' flag on the given descriptor.
clear_nonblock [Core_unix]
Clear the ``non-blocking'' flag on the given descriptor.
clock_getres [Unix_ext]
clock_gettime [Unix_ext]
clock_process_cputime_id [Linux_ext]
clock_process_cputime_id the clock measuring the CPU-time of a process.
clock_settime [Unix_ext]
clock_thread_cputime_id [Linux_ext]
clock_thread_cputime_id the clock measuring the CPU-time of a thread.
close [Out_channel]
close [In_channel]
close [Core_unix]
Close a file descriptor.
close_linebuf [Linebuf]
Closes the line buffer (and the underlying file).
close_noerr [Out_channel]
close_noerr [In_channel]
close_process [Core_unix]
Close channels opened by UnixLabels.open_process, wait for the associated command to terminate, and return its termination status.
close_process_full [Core_unix]
Close channels opened by UnixLabels.open_process_full, wait for the associated command to terminate, and return its termination status.
close_process_in [Core_unix]
Close channels opened by UnixLabels.open_process_in, wait for the associated command to terminate, and return its termination status.
close_process_out [Core_unix]
Close channels opened by UnixLabels.open_process_out, wait for the associated command to terminate, and return its termination status.
closed_linebuf [Linebuf]
Returns whether or not the line buffer is closed
closedir [Core_unix]
Close a directory descriptor.
combine [Core_list]
Tail-recursive combine.
combine [Core_array]
combine ar combines two arrays to an array of pairs.
compact [Core_gc]
Perform a full major collection and compact the heap.
compare [Tuple.T3]
compare [Tuple.T2]
compare [PSet]
compare [Interned.S]
compare [Interned.Make]
compare [Core_string]
compare [Comparable.S]
compare [Comparable.Inherit]
compare [Comparable.From_compare]
concat [Core_string]
concat [Core_list]
Concatenate a list of lists.
concat [Core_filename]
concat [Core_array]
concat_array [Core_string]
concat_array sep ar like String.concat, but operates on arrays
concat_map [Core_list]
Map a function over a list and concatenate the results.
cond_pop [Heap]
cond_pop heap cond
cond_pop_heap_el [Heap]
cond_pop_heap_el heap cond
condition_timedwait [Unix_ext]
condition_timedwait cnd mtx timeout waits on condition variable cond with mutex mtx until either the condition is signalled, or until timeout expires.
connect [Core_unix]
Connect a socket to an address.
cons [Core_list]
contains [Interval_set]
contains [Core_string]
contains_dup [Core_list]
contains_dup True if there are any two elements in the list which are the same.
contains_from [Core_string]
contains_set [Interval_set]
contents [Bigbuffer]
Return a copy of the current contents of the buffer.
convert [Int_conversions]
copy [Heap]
copy heap
copy [Doubly_linked]
copy t returns a copy of t.
copy [Core_string]
copy [Core_stack]
copy t returns a copy of t.
copy [Core_queue]
copy t returns a copy of t.
copy [Core_hashtbl.S]
copy [Core_hashtbl]
copy [Core_array]
count [Core_list]
count f l is the number of elements in l that satisfy the predicate f.
counters [Core_gc]
Return (minor_words, promoted_words, major_words).
crc32 [Crc]
Compute the 32-bit crc
crc32hex [Crc]
String version of the crc, encoded in hex.
create [Unique_id.Int64]
create [Unique_id.Unit_ref]
create [Tuple.T3]
create [Tuple.T2]
create [Timer]
create ?min_size ?tick_unit () creates a new timer.
create [Squeue]
create maxsize returns a synchronized queue bounded to have no more than maxsize elements.
create [Space_safe_tuple.T3]
create [Space_safe_tuple.T2]
create [Ref]
create [Piecewise_linear.S]
create [Out_channel]
create [Month]
create [Linux_ext.Epoll]
create [Interval_set]
create [In_channel]
create [Heap]
create ?min_size cmp
create [Hash_set.Mono_or_poly]
create [Hash_set.Make_mono_or_poly]
create [Hash_queue.S]
create [Hash_queue.Make]
create [Force_once]
create f creates a new force_once
create [Fast_hashtbl]
create [Error_check.Step]
create [Error_check.Timer]
create [Error_check.ToggleN]
create [Error_check.Toggle]
create [Doubly_linked]
creating doubly-linked lists
create [Dequeue]
create [Core_string]
create [Core_stack]
create () returns an empty stack.
create [Core_queue]
create () returns an empty queue.
create [Core_mutex]
create [Core_hashtbl.S]
create [Core_hashtbl]
create [Core_array]
create [Bigstring]
create length
create [Bigbuffer]
create n returns a fresh buffer, initially empty.
create [Bag]
create () returns an empty bag.
create_alarm [Core_gc]
create_alarm f will arrange for f to be called at the end of each major GC cycle, starting with the current cycle or the next one.
create_process [Core_unix]
create_process prog args new_stdin new_stdout new_stderr forks a new process that executes the program in file prog, with arguments args.
create_process_env [Core_unix]
create_process_env prog args env new_stdin new_stdout new_stderr works as UnixLabels.create_process, except that the extra argument env specifies the environment passed to the program.
critical_section [Core_mutex]
current [Unique_id.Int64]
current [Core_arg]
current_dir_name [Core_filename]
functions from the standard library For these function definitions check the standard library
curry [Tuple.T3]
curry [Tuple.T2]

D
data [Core_hashtbl.S]
data [Core_hashtbl]
deactivate [Timer]
deactivate timer deactives a timer.
dec [Month]
decr [Int_intf.S]
dedup [Core_list]
dedup (de-duplicate).
del [Linux_ext.Epoll]
delete_alarm [Core_gc]
delete_alarm a will stop the calls to the function associated to a.
deq [Fqueue]
alias for pop
deq_exn [Fqueue]
alias for pop_exn
dequeue [Hash_queue.S]
dequeue [Hash_queue.Make]
dequeue [Core_queue]
dequeue t returns None if t is empty, otherwise it removes and returns the front of t
dequeue_all [Hash_queue.S]
dequeue_all [Hash_queue.Make]
dequeue_exn [Core_queue]
dequeue_exn t removes and returns the front of t, raising Empty if t is empty.
dequeue_with_key [Hash_queue.S]
dequeue_with_key [Hash_queue.Make]
descending [Comparable.S]
descending [Comparable.Inherit]
descending [Comparable.From_compare]
descending [Comparable.Poly]
descr_of_in_channel [Core_unix]
Return the descriptor corresponding to an input channel.
descr_of_out_channel [Core_unix]
Return the descriptor corresponding to an output channel.
diff [PSet]
dirfd [Unix_ext]
Extract a file descriptor from a directory handle.
dirname [Core_filename]
discard [Fqueue]
Returns version of queue with top element removed
div [Int_intf.S]
domain_of_sockaddr [Core_unix]
Return the socket domain adequate for the given socket address.
drop [Unix_ext.IOVec]
drop_back [Dequeue]
drop_front [Dequeue]
drop_indices_greater_than [Dequeue]
drop_indices_less_than [Dequeue]
drop_n_back [Dequeue]
drop_n_front [Dequeue]
drop_prefix_n [Core_string]
drop_prefix_n string n drops the prefix of t of length n
drop_suffix_n [Core_string]
drop_suffix_n string n drops the suffix of t of length n
dup [Core_unix]
Return a new file descriptor referencing the same file as the given descriptor.
dup2 [Core_unix]
dup2 fd1 fd2 duplicates fd1 to fd2, closing fd2 if already opened.

E
elements [PSet]
empty [Unix_ext.IOVec]
empty the empty I/O-vector.
empty [PSet]
empty [Fqueue]
The empty queue
enq [Fqueue]
alias for push
enqueue [Hash_queue.S]
enqueue [Hash_queue.Make]
enqueue [Core_queue]
enqueue t x adds x to the end of t.
environment [Core_unix]
Return the process environment, as an array of strings with the format ``variable=value''.
eprintf [Core_printf]
epsilon [Float]
equal [Unique_id.Unit_ref]
equal [Ref]
equal t1 t2 returns true if t1 and t2 are the same ref cell.
equal [PSet]
equal [Option]
equal [Interned.Make]
equal [Hashable.S]
equal [Equatable.S]
equal [Doubly_linked.Elt]
equal [Doubly_linked]
predicates
equal [Core_string]
fast equality function on strings, doesn't use compare_val
equal [Bag.Elt]
error_message [Core_unix]
Return a string describing the given error code.
escaped [Core_string]
escaped [Core_char]
establish_server [Core_unix]
Establish a server on the given address.
execv [Core_unix]
execv prog args execute the program in file prog, with the arguments args, and the current process environment.
execve [Core_unix]
Same as UnixLabels.execv, except that the third argument provides the environment to the program executed.
execvp [Core_unix]
Same as UnixLabels.execv respectively, except that the program is searched in the path.
execvpe [Core_unix]
Same as UnixLabels.execvp respectively, except that the program is searched in the path.
exists [PSet]
exists [Hash_queue.Make]
exists [Container.S1]
exists [Container.S0_phantom]
exists [Container.S0]
exists2 [Core_list]

F
failwithf [Sexpable]
failwithf [Core_printf]
failwith and invalid_arg accepting printf's format.
fast_sort [Core_list]
fast_sort [Core_array]
fchmod [Core_unix]
Change the permissions of an opened file.
fchown [Core_unix]
Change the owner uid and owner gid of an opened file.
fdatasync [Unix_ext]
Synchronize the kernel buffers of a given file descriptor with disk, but do not necessarily write file attributes.
feb [Month]
fg [Quickcheck]
file_descr_of_int [Unix_ext]
file_descr_of_int n converts an integer to a file descriptor.
file_descr_realpath [Linux_ext]
file_descr_realpath fd
fill [Core_string]
fill [Core_array]
filter [PSet]
filter [Core_list]
filter [Core_array]
filter ~f array removes the elements for which f returns false.
filter_map [PSet]
filter_map [Core_list]
filter_map f l is the sublist of l containing only elements for which f returns Some e.
filter_map [Core_array]
filter_map ~f array maps f over array and filters None out of the results.
filter_mapi [Core_array]
Same as filter_map but uses Array.mapi.
filter_opt [PSet]
filter_opt [Core_list]
filter_opt l is the sublist of l containing only elements which are Some e.
filter_opt [Core_array]
filter_opt array returns a new array where None entries are omitted and Some x entries are replaced with x.
filteri [Core_array]
Like filter except f also receives the index.
finalise [Core_gc]
finalise f v registers f as a finalisation function for v.
finalise_release [Core_gc]
A finalisation function may call finalise_release to tell the GC that it can launch the next finalisation function without waiting for the current one to return.
find [Hash_queue.Make]
find [Fast_hashtbl]
find [Core_hashtbl.S]
find [Core_hashtbl]
find [Container.S1]
find [Container.S0_phantom]
find [Container.S0]
find_a_dup [Core_list]
find_a_dup returns a duplicate from the list (no guarantees about which duplicate you get), or None if there are no dups.
find_all [Core_list]
find_all [Core_hashtbl.S]
find_all [Core_hashtbl]
find_default [Core_hashtbl.S]
find_default [Core_hashtbl]
find_elt [Doubly_linked]
find_elt t ~f finds the first element in t that satisfies f, by testing each of element of t in turn until f succeeds.
find_elt [Bag]
find_elt t ~f looks at elements in the bag one-by-one until it finds one elt such that f (Elt.value elt), in which case it returns Some elt.
find_exn [Fast_hashtbl]
find_exn [Core_list]
find_exn t ~f returns the first element of t that satisfies f.
find_exn [Core_hashtbl.S]
find_exn [Core_hashtbl]
find_exn [Core_array]
find_exn f t returns in first a in t for which f t.(i) is true.
find_heap_el [Heap]
find_heap_el heap el
find_opt [Hash_queue.S]
find_opt [Hash_queue.Make]
findi [Core_string]
findi string ~f returns the index i of the first character in t satisfying f i t.[i].
findi [Core_array]
findi f ar returns in first index i of ar for which f ar.(i) is true
findi_exn [Core_array]
findi_exn f ar returns in first index i of ar for which f ar.(i) is true.
first [Doubly_linked]
first_elt [Doubly_linked]
constant-time extraction of first and last elements.
first_n [Core_list]
first_n n l is fst (split_n n l).
flag_to_string [Linux_ext.Epoll]
flatten [Core_list]
Same as concat.
float_of_bits [Core_int64]
float_of_bits [Core_int32]
flush [Out_channel]
fold [PSet]
fold [Hash_set.Mono_or_poly]
fold [Hash_set.Make_mono_or_poly]
fold [Hash_queue.Make]
fold [Fast_hashtbl]
fold [Dequeue]
fold [Core_hashtbl.S]
fold [Core_hashtbl]
fold [Container.S1]
fold [Container.S0_phantom]
fold [Container.S0]
fold_keys [Hash_queue.S]
fold_keys [Hash_queue.Make]
fold_left [Core_list]
fold_left [Core_array]
fold_left2 [Core_list]
fold_left_term [Core_list]
fold_left_term is like fold_left, except that you can halt early.
fold_lefti [Core_list]
fold_lefti is just like fold_left, but it also passes in the index of each element as the first argument to the folded function.
fold_lines [In_channel]
fold_lines ?fix_win_eol t ~init ~f folds over the lines read from t using input_line.
fold_right [Core_list]
Tail-recursive fold_right.
fold_right [Core_array]
fold_right2 [Core_list]
Tail-recursive fold_right2.
foldi [Dequeue]
foldn [Quickcheck]
for_all [PSet]
for_all [Hash_queue.Make]
for_all [Container.S1]
for_all [Container.S0_phantom]
for_all [Container.S0]
for_all2 [Core_list]
force [Force_once]
force t runs the thunk if it hadn't already been forced, else it raises an exception.
fork [Core_unix]
Fork a new process.
formatter_of_buffer [Bigbuffer.Format]
fprintf [Core_printf]
frange [Core_list]
frange is similar to range, but for floats.
frequency [Quickcheck]
Given list of (frequency,value) pairs, returns value with probability proportional to given frequency
frequencyl [Quickcheck]
like frequency, but returns generator
front_index [Dequeue]
fstat [Core_unix.LargeFile]
fstat [Core_unix]
Return the information for the file associated with the given descriptor.
fsync [Unix_ext]
Synchronize the kernel buffers of a given file descriptor with disk.
ftruncate [Core_unix.LargeFile]
ftruncate [Core_unix]
Truncates the file corresponding to the given descriptor to the given size.
full_major [Core_gc]
Do a minor collection, finish the current major collection cycle, and perform a complete new cycle.

G
general [Memo]
Returns memoized version of any function with a single argument.
get [Piecewise_linear.S]
get [Month]
get [Dequeue]
get [Core_string]
get [Core_gc]
Return the current values of the GC parameters in a control record.
get [Core_array]
get1 [Tuple.T3]
get1 [Tuple.T2]
get1 [Space_safe_tuple.T3]
get1 [Space_safe_tuple.T2]
get2 [Tuple.T3]
get2 [Tuple.T2]
get2 [Space_safe_tuple.T3]
get2 [Space_safe_tuple.T2]
get3 [Tuple.T3]
get3 [Space_safe_tuple.T3]
get_back [Dequeue]
get_cmp [Heap]
get_cmp heap
get_digit [Core_char]
get_digit 'i' = Some i if is_digit i and None otherwise.
get_digit_exn [Core_char]
get_event_interval [Timer]
get_event_interval event
get_event_time [Timer]
get_event_time event
get_flags [Linux_ext.Epoll]
get_flags flags
get_front [Dequeue]
get_opt_len [Bigstring]
get_pos_len [Ordered_collection_common]
get_pos_len_exn [Ordered_collection_common]
get_pos_len ?pos ?len length takes an optional position and a length and returns (pos', len') specifying a subrange of 0, length-1 such that: pos' = match pos with None -> 0 | Some i -> i len' = match pos with None -> length string - pos | Some i -> i get_pos_len also checks pos' and len' for sanity, and raises Invalid_arg if they do not specify a valid subrange of 0, length-1.
get_terminal_size [Linux_ext]
get_terminal_size ()
get_timer [Timer]
get_timer event
getaddrinfo [Core_unix]
getaddrinfo host service opts returns a list of Unix.addr_info records describing socket parameters and addresses suitable for communicating with the given host and service.
getcwd [Core_unix]
Return the name of the current working directory.
getegid [Core_unix]
Return the effective group id under which the process runs.
getenv [Core_unix]
Return the value associated to a variable in the process environment.
getenv [Core_sys]
getenv_exn [Core_unix]
Return the value associated to a variable in the process environment.
getenv_exn [Core_sys]
geteuid [Core_unix]
Return the effective user id under which the process runs.
getgid [Core_unix]
Return the group id of the user executing the process.
getgrgid [Core_unix]
Find an entry in group with the given group id, or raise Not_found.
getgrnam [Core_unix]
Find an entry in group with the given name, or raise Not_found.
getgroups [Core_unix]
Return the list of groups to which the user executing the process belongs.
gethostbyaddr [Core_unix]
Find an entry in hosts with the given address, or raise Not_found.
gethostbyname [Core_unix]
Find an entry in hosts with the given name, or raise Not_found.
gethostname [Core_unix]
Return the name of the local host.
getitimer [Core_unix]
Return the current status of the given interval timer.
getlogin [Core_unix]
Return the login name of the user executing the process.
getnameinfo [Core_unix]
getnameinfo addr opts returns the host name and service name corresponding to the socket address addr.
getpeername [Core_unix]
Return the address of the host connected to the given socket.
getpid [Core_unix]
Return the pid of the process.
getppid [Core_unix]
Return the pid of the parent process.
getprotobyname [Core_unix]
Find an entry in protocols with the given name, or raise Not_found.
getprotobynumber [Core_unix]
Find an entry in protocols with the given protocol number, or raise Not_found.
getpwnam [Core_unix]
Find an entry in passwd with the given name, or raise Not_found.
getpwuid [Core_unix]
Find an entry in passwd with the given user id, or raise Not_found.
getrlimit [Unix_ext]
getrusage [Unix_ext]
getservbyname [Core_unix]
Find an entry in services with the given name, or raise Not_found.
getservbyport [Core_unix]
Find an entry in services with the given service number, or raise Not_found.
getsockname [Core_unix]
Return the address of the given socket.
getsockopt [Core_unix]
Return the current status of a boolean-valued option in the given socket.
getsockopt_float [Core_unix]
Same as UnixLabels.getsockopt for a socket option whose value is a floating-point number.
getsockopt_int [Core_unix]
Same as UnixLabels.getsockopt for an integer-valued socket option.
getsockopt_optint [Core_unix]
Same as UnixLabels.getsockopt for a socket option whose value is an int option.
gettcpopt_bool [Linux_ext]
gettcpopt_bool sock opt
gettimeofday [Core_unix]
Same as UnixLabels.time, but with resolution better than 1 second.
getuid [Core_unix]
Return the user id of the user executing the process.
gmtime [Core_unix]
Convert a time in seconds, as returned by UnixLabels.time, into a date and a time.
group_by [PSet]

H
handle_unix_error [Core_unix]
handle_unix_error f x applies f to x and returns the result.
has_err [Linux_ext.Epoll]
has_err flags
has_et [Linux_ext.Epoll]
has_et flags
has_hup [Linux_ext.Epoll]
has_hup flags
has_in [Linux_ext.Epoll]
has_in flags
has_oneshot [Linux_ext.Epoll]
has_oneshot flags
has_out [Linux_ext.Epoll]
has_out flags
has_pri [Linux_ext.Epoll]
has_pri flags
hash [Interned.Make]
hash [Hashable.S]
hash [Core_string]
slightly faster hash function on strings
hash [Core_hashtbl]
hash_param [Core_hashtbl]
hd [Core_list]
hd_exn [Core_list]
heap_el_get_el [Heap]
heap_el_get_el heap_el
heap_el_is_valid [Heap]
heap_el_is_valid heap_el
heap_el_mem [Heap]
heap_el_mem heap heap_el

I
ident [Memo]
Returns memoized version of any function where data is kept until argument changes.
ifprintf [Core_printf]
ignore [Monad.Make]
ignore [Monad.S]
ignore t = map t ~f:(fun _ -> ()).
ignore [Force_once]
ignore () = create (fun () -> ())
in_channel_of_descr [Core_unix]
Create an input channel reading from the given descriptor.
in_channel_realpath [Linux_ext]
in_channel_realpath ic
incr [Int_intf.S]
index [Core_string]
index_from [Core_string]
inet6_addr_any [Core_unix]
A special IPv6 address, for use only with bind, representing all the Internet addresses that the host machine possesses.
inet6_addr_loopback [Core_unix]
A special IPv6 address representing the host machine (::1).
inet_addr_any [Core_unix]
A special IPv4 address, for use only with bind, representing all the Internet addresses that the host machine possesses.
inet_addr_loopback [Core_unix]
A special IPv4 address representing the host machine (127.0.0.1).
inet_addr_of_string [Core_unix]
Conversion from the printable representation of an Internet address to its internal representation.
init [Core_string]
init [Core_list]
init f n is [(f 0); (f 1); ...; (f (n-1))].
init [Core_array]
initgroups [Unix_ext]
input [In_channel]
input [Bigstring]
input_all [In_channel]
input_binary_int [In_channel]
input_byte [In_channel]
input_char [In_channel]
input_line [In_channel]
input_line ?fix_win_eol t reads a line from t and returns it, without the newline ("\n") character at the end, and, if fix_win_eol the trailing "\r\n" is dropped.
input_lines [In_channel]
input_lines ?fix_win_eol t returns the list of lines read from t using input_line.
input_value [In_channel]
insert_after [Doubly_linked]
insert_before [Doubly_linked]
constant-time insertion of a new element.
insert_first [Doubly_linked]
insert_last [Doubly_linked]
int [Int_conversions]
int32 [Int_conversions]
int32_to_int64 [Int_conversions]
int32_to_nativeint [Int_conversions]
int64 [Int_conversions]
int_of_file_descr [Unix_ext]
int_of_file_descr fd converts file descriptor fd to the internal integer value.
int_to_int64 [Int_conversions]
int_to_nativeint [Int_conversions]
inter [PSet]
invalid_argf [Core_printf]
invariant [Month]
invariant [Hash_queue.S]
invariant [Hash_queue.Make]
invariant [Doubly_linked]
invariant [Core_stack]
invariant [Core_queue]
invariant [Bag]
is_activated [Timer]
is_activated timer
is_digit [Core_char]
Predicates
is_empty [PSet]
is_empty [Heap]
is_empty heap
is_empty [Hash_queue.Make]
is_empty [Fqueue]
is_empty [Dequeue]
is_empty [Core_string]
is_empty t returns true iff t is empty (i.e.
is_empty [Container.S1]
is_empty [Container.S0_phantom]
is_empty [Container.S0]
is_error [Result]
is_first [Doubly_linked]
is_implicit [Core_filename]
is_inf [Float]
Ordinary t-only infinity test.
is_last [Doubly_linked]
is_lowercase [Core_char]
is_mmapped [Bigstring]
is_mmapped bstr
is_nan [Float]
Ordinary t-only nan test.
is_none [Option]
is_none t returns true iff t = None.
is_ok [Result]
is_posix_valid [Core_filename]
is_posix_valid f
is_print [Core_char]
is_relative [Core_filename]
is_some [Option]
is_some t returns true iff t = Some x.
is_uppercase [Core_char]
is_whitespace [Core_char]
isatty [Core_unix]
Return true if the given file descriptor refers to a terminal or console window, false otherwise.
iter [Result]
iter [PSet]
iter [Heap]
iter [Hash_set.Mono_or_poly]
iter [Hash_set.Make_mono_or_poly]
iter [Hash_queue.Make]
iter [Fast_hashtbl]
iter [Dequeue]
iter [Core_hashtbl.S]
iter [Core_hashtbl]
iter [Container.S1]
iter [Container.S0_phantom]
iter [Container.S0]
iter2 [Core_list]
iter_keys [Hash_queue.S]
iter_keys [Hash_queue.Make]
iter_lines [In_channel]
iter_lines ?fix_win_eol t ~f applies f to each line read from t using input_line.
iter_vals [Core_hashtbl.S]
iter_vals [Core_hashtbl]
iteri [Dequeue]
iteri [Core_list]
iteri is just like iter, but it also passes in the index of each element as the first argument to the iter'd function.
iteri [Core_array]

J
jan [Month]
join [Monad.Make]
join [Monad.S]
join t is t >>= (fun t' -> t').
jul [Month]
jun [Month]

K
kbprintf [Core_printf]
keep_prefix_n [Core_string]
keep_prefix_n string n returns the prefix of t of length n
keep_suffix_n [Core_string]
keep_suffix_n string n returns the suffix of t of length n
keys [Core_hashtbl.S]
keys [Core_hashtbl]
kfprintf [Core_printf]
kill [Core_unix]
kill pid sig sends signal number sig to the process with id pid.
ksprintf [Core_printf]

L
last [Doubly_linked]
last [Core_list]
The final element of a list.
last [Core_array]
last_elt [Doubly_linked]
laws [Quickcheck]
laws iter gen func applies func repeatedly (iter times) on output of gen, and if func ever returns false, then the input that caused the failure is returned optionally.
laws2 [Quickcheck]
laws_exn [Quickcheck]
Like laws, but throws an exception instead of returning an option.
lbound [Interval_set]
length [Squeue]
returns the number of elements in the queue.
length [Out_channel]
length [In_channel]
length [Heap]
length heap
length [Hash_set.Mono_or_poly]
length [Hash_set.Make_mono_or_poly]
length [Hash_queue.Make]
length [Fqueue]
length [Fast_hashtbl]
length [Dequeue]
length [Core_string]
length [Core_hashtbl.S]
length [Core_hashtbl]
length [Container.S1]
length [Container.S0_phantom]
length [Container.S0]
length [Bigstring]
length bstr
length [Bigbuffer]
Return the number of characters currently contained in the buffer.
lg [Quickcheck]
link [Core_unix]
link source dest creates a hard link named dest to the file named new.
listen [Core_unix]
Set up a socket for receiving connection requests.
load_file [Bigstring]
localtime [Core_unix]
Convert a time in seconds, as returned by UnixLabels.time, into a date and a time.
lock [Core_mutex]
lockf [Core_unix]
lockf fd cmd size puts a lock on a region of the file opened as fd.
logand [Int_intf.S]
lognot [Int_intf.S]
logor [Int_intf.S]
logxor [Int_intf.S]
lowercase [Core_string]
lowercase [Core_char]
lpop [Squeue]
returns the element popped and the length of the queue after * this element was popped.
lseek [Core_unix.LargeFile]
lseek [Core_unix]
Set the current position for a file descriptor
lstat [Core_unix.LargeFile]
lstat [Core_unix]
Same as UnixLabels.stat, but in case the file is a symbolic link, return the information for the link itself.
lstrip [Core_string]
lstrip str returns a new string with consecutive white space (tabs, spaces, newlines, and carriage returns) stripped from the beginning of str.

M
major [Core_gc]
Do a minor collection and finish the current major collection cycle.
major_slice [Core_gc]
Do a minor collection and a slice of major collection.
make [Core_string]
make_absolute [Core_filename]
make_flags [Linux_ext.Epoll]
make_flags ar
make_matrix [Core_array]
many_readers_many_writers [Thread_safe_queue]
many_readers_one_writer [Thread_safe_queue]
map [Result]
map [PSet]
map [Option]
map o f map 'a option to a 'b option using ~f
map [Monad.Make]
map [Monad.S]
map t ~f is t >>| f.
map [Core_string]
map f s applies f to each character in s, and returns the resulting string.
map [Core_list]
Tail-recursive map.
map [Core_array]
map1 [Tuple.T3]
map1 [Tuple.T2]
map2 [Tuple.T3]
map2 [Tuple.T2]
map2 [Core_list]
Tail-recursive map2.
map2 [Core_array]
map3 [Tuple.T3]
map3 [Core_list]
map_file [Bigstring]
map_file shared fd n memory-maps n characters of the data associated with descriptor fd to a bigstring.
mapi [Core_list]
mapi is just like map, but it also passes in the index of each element as the first argument to the mapped function.
mapi [Core_array]
mar [Month]
max [Comparable.S]
max [Comparable.Inherit]
max [Comparable.From_compare]
max_elt [PSet]
max_elt_exn [PSet]
max_inan [Float]
max_int [Int_intf.S]
max_iovecs [Unix_ext.IOVec]
max_value [Float]
may [Month]
maybe_pop [Heap]
maybe_pop heap
maybe_pop_heap_el [Heap]
maybe_pop_heap_el heap
maybe_top [Heap]
maybe_top heap
mem [PSet]
mem [Heap]
mem heap el
mem [Hash_set.Mono_or_poly]
mem [Hash_set.Make_mono_or_poly]
mem [Hash_queue.S]
mem [Hash_queue.Make]
mem [Fast_hashtbl]
mem [Core_list]
mem [Core_hashtbl.S]
mem [Core_hashtbl]
mem [Core_array]
mem el arr returns true iff arr.(i) = el for some i
mem_assoc [Core_list]
mem_assoc' [Core_list]
memq [Core_list]
merge [Core_list]
min [Comparable.S]
min [Comparable.Inherit]
min [Comparable.From_compare]
min_combine [Core_list]
min_combine combines two lists, possibly of different length, and returns a list the length of the shorter list.
min_elt [PSet]
min_elt_exn [PSet]
min_inan [Float]
min that returns the other value if one of the values is a nan.
min_int [Int_intf.S]
min_normal_pos [Float]
min_value [Float]
minor [Core_gc]
Trigger a minor collection.
minus_one [Int_intf.S]
mkdir [Core_unix]
Create a directory with the given permissions.
mkdtemp [Unix_ext]
mkdtemp pattern pattern must end with XXXXXX.
mkfifo [Core_unix]
Create a named pipe with the given permissions.
mknod [Unix_ext]
mktime [Core_unix]
Convert a date and time, specified by the tm argument, into a time in seconds, as returned by UnixLabels.time.
modify [Linux_ext.Epoll]
mul [Int_intf.S]
mutex_timedlock [Unix_ext]
mutex_timedlock mtx timeout tries to lock mtx, but returns once timeout expires.

N
nativeint [Int_conversions]
nativeint_to_int64 [Int_conversions]
neg [Int_intf.S]
next [Doubly_linked]
constant-time move to next or previous element.
nget [Core_string]
nget s i Gets the char at normalized position i in s.
nget [Core_array]
Array access with normalized index.
nice [Core_unix]
Change the process priority.
nng [Quickcheck]
normalize [Ordered_collection_common]
normalize [Core_array]
normalize array index returns a new index into the array such that if index is less than zero, the returned index will "wrap around" -- i.e.
not [Bool]
nov [Month]
nset [Core_string]
nset s i c Sets the char at normalized position i to c.
nset [Core_array]
Array modification with normalized index.
nth [Core_list]
nth [Bigbuffer]
get the n-th character of the buffer.
nth_exn [Core_list]
num_bits [Word_size]

O
oct [Month]
of_alist [Core_hashtbl.S]
of_alist [Core_hashtbl]
of_array [PSet]
of_array [Heap]
of_array ?min_size cmp ar
of_bigstring [Unix_ext.IOVec]
of_char [Core_string]
of_float [Floatable.S]
of_int [Month]
of_int i returns i'th month if i is in 1,2,...,12.
of_int [Float]
of_int [Core_nativeint]
of_int [Core_int64]
of_int [Core_int32]
of_int [Core_int]
of_int [Core_char]
of_int [Bool]
of_int32 [Core_nativeint]
of_int32 [Core_int64]
of_int32 [Core_int32]
of_int32 [Core_int]
of_int32_exn [Core_int]
of_int64 [Core_nativeint]
of_int64 [Core_int64]
of_int64 [Core_int32]
of_int64 [Core_int]
of_int64_exn [Core_nativeint]
of_int64_exn [Core_int32]
of_int64_exn [Core_int]
of_int_exn [Month]
of_int_exn i should have i in 1,2,...,12 and returns the i'th month.
of_int_exn [Core_int32]
of_int_exn [Core_char]
of_list [PSet]
of_list [Hash_set.Mono_or_poly]
of_list [Hash_set.Make_mono_or_poly]
of_list [Doubly_linked]
of_list l returns a doubly-linked list t with the same elements as l and in the same order (i.e.
of_list [Core_queue]
of_list list returns a queue t with the elements of list in the same order as the elements of list (i.e.
of_list [Core_array]
of_nativeint [Core_nativeint]
of_nativeint [Core_int64]
of_nativeint [Core_int32]
of_nativeint [Core_int]
of_nativeint_exn [Core_int32]
of_nativeint_exn [Core_int]
of_string [Unix_ext.IOVec]
of_string [Sexpable.To_stringable]
of_string [Interned.Make]
of_string [Stringable.S]
of_string [Bigstring]
of_string ?pos ?len str
one [Int_intf.S]
one_reader_many_writers [Thread_safe_queue]
one_reader_one_writer [Thread_safe_queue]
oneof [Quickcheck]
Given a list of generators, returns generator that randomly uses one of the generators from the list
oneofl [Quickcheck]
given a list, returns generator that picks at random from list
open_connection [Core_unix]
Connect to a server at the given address.
open_linebuf [Linebuf]
Open a line buffer from the passed filename.
open_process [Core_unix]
See UnixLabels.open_process_in.
open_process_full [Core_unix]
Similar to UnixLabels.open_process, but the second argument specifies the environment passed to the command.
open_process_in [Core_unix]
High-level pipe and process management.
open_process_out [Core_unix]
See UnixLabels.open_process_in.
open_temp_file [Core_filename]
Same as Core_filename.temp_file, but returns both the name of a fresh temporary file, and an output channel opened (atomically) on this file.
opendir [Core_unix]
Open a descriptor on a directory
openfile [Core_unix]
Open the named file with the given flags.
out_channel_of_descr [Core_unix]
Create an output channel writing on the given descriptor.
out_channel_realpath [Linux_ext]
out_channel_realpath oc
output [Out_channel]
output [Bigstring]
output_binary_int [Out_channel]
output_buffer [Bigbuffer]
output_buffer oc b writes the current contents of buffer b on the output channel oc.
output_byte [Out_channel]
output_char [Out_channel]
output_string [Out_channel]
output_value [Out_channel]

P
pack_float [Binary_packing]
pack_signed_16 [Binary_packing]
encode and pack the specified int as a signed 2 byte int, and place it in the buffer starting at pos
pack_signed_32 [Binary_packing]
encode and pack the specified int32 as a signed 4 byte int, and place it in the buffer starting at pos
pack_signed_32_int [Binary_packing]
encode and pack the specified int32 as a signed 4 byte int, and place it in the buffer starting at pos.
pack_signed_8 [Binary_packing]
encode and pack the specified int as a signed 1 byte int, and place it in the buffer starting at pos
parent_dir_name [Core_filename]
parse [Core_arg]
parse_argv [Core_arg]
partition [PSet]
partition [Core_list]
partition_map [Core_list]
partition_map f l partitions l into those elements which Pass f and those which Fail f.
pause [Core_unix]
Wait until a non-ignored, non-blocked signal is delivered.
peek [Core_queue]
peek t returns None if t is empty, otherwise it returns Some x where x is the front of t.
peek_exn [Core_queue]
peek_exn t raises Empty if t is empty, otherwise it returns the front of t.
permute [Core_array]
permute ar randomly permutes ar in place
pfg [Quickcheck]
pg [Quickcheck]
phys_length [Dequeue]
pipe [Core_unix]
Create a pipe.
pop [Squeue]
pops an element off the queue, blocking until something is * available
pop [Heap]
pop heap
pop [Fqueue]
Like pop_exn, but returns result optionally, without exception
pop [Core_stack]
pop t returns None if t is empty, otherwise it returns Some x where x is the top of t and removes x from the top of t.
pop_exn [Fqueue]
Like top_exn, but returns pair of the top element, and a new queue with the top element removed
pop_exn [Core_stack]
pop_exn t removes and returns the top element of t, raising Empty if t is empty.
pop_heap_el [Heap]
pop_heap_el heap
pos [Out_channel]
pos [In_channel]
pp [Exn]
pp [Core_string]
This has to be public for interactive top-levels.
pr_get_pdeathsig [Linux_ext]
pr_get_pdeathsig () get the signal that will be sent to the currently executing process when its parent dies.
pr_set_pdeathsig [Linux_ext]
pr_set_pdeathsig s sets the signal s to be sent to the executing process when its parent dies.
pred [Int_intf.S]
prev [Doubly_linked]
print [Backtrace]
print_stat [Core_gc]
Print the current values of the memory management counters (in human-readable form) into the channel argument.
printf [Core_printf]
protect [Exn]
protectx [Exn]
A common idiom used in functional languages, that executes f and afterwards executes finally, whether f throws an exception or not.
pselect [Unix_ext]
pselect rfds wfds efds timeout sigmask like Unix.select but also allows one to wait for the arrival of signals.
pthread_getcpuclockid [Unix_ext]
push [Squeue]
Blocks until there's room on the queue, then pushes.
push [Heap]
push heap el pushes element el on heap.
push [Fqueue]
push a single element on queue
push [Core_stack]
push t x adds x to the top of stack t.
push_back [Dequeue]
push_front [Dequeue]
push_heap_el [Heap]
push_heap_el heap heap_el pushes heap_el on heap.
push_or_drop [Squeue]
Pushes an event on the queue if the queue is less than maxsize, otherwise drops it.
push_top [Fqueue]
push a single element on the *top* of the queue
push_uncond [Squeue]
Does not block, may grow the queue past maxsize
putenv [Core_unix]
Unix.putenv name value sets the value associated to a variable in the process environment.

Q
quick_stat [Core_gc]
Same as stat except that live_words, live_blocks, free_words, free_blocks, largest_free, and fragments are set to 0.
quote [Core_filename]

R
range [Core_list]
range stride low high is the list of integers from low(inclusive) to high(exclusive), stepping by stride.
rcontains_from [Core_string]
read [Linebuf]
Calls try_read every 0.01 seconds and returns when a line is available.
read [Core_unix]
read fd buff ofs len reads len characters from descriptor fd, storing them in string buff, starting at position ofs in string buff.
read [Bigstring]
read_assume_nonblocking [Unix_ext]
read_assume_nonblocking [Bigstring]
readdir [Core_unix]
Return the next entry in a directory.
readdir_ino [Unix_ext]
readdir_ino dh return the next entry in a directory (((filename, inode)).
readlink [Core_unix]
Read the contents of a link.
really_input [In_channel]
really_input [Bigstring]
really_output [Bigstring]
really_read [Bigstring]
really_recv [Bigstring]
really_send_no_sigpipe [Bigstring]
really_write [Bigstring]
realpath [Unix_ext]
realpath path
recv [Core_unix]
Receive data from an unconnected socket.
recv_fd [Linux_ext]
recvfrom [Core_unix]
Receive data from an unconnected socket.
reduce [Core_list]
reduce f [a1; ...; an] is f (... (f (f a1 a2) a3) ...) an.
reduce [Core_array]
reduce f [a1; ...; an] is f (... (f (f a1 a2) a3) ...) an.
register [Pretty_printer]
register_converter [Exn]
rem [Int_intf.S]
remove [Timer]
remove event removes event from its associated timer.
remove [PSet]
remove [Heap]
remove heap_el removes heap_el from its associated heap.
remove [Hash_set.Mono_or_poly]
remove [Hash_set.Make_mono_or_poly]
remove [Hash_queue.S]
remove [Hash_queue.Make]
remove [Fast_hashtbl]
remove [Doubly_linked]
constant-time removal of an element.
remove [Core_hashtbl.S]
remove [Core_hashtbl]
remove [Bag]
remove t elt removes elt from the bag t, raising an exception if elt is not in the bag.
remove_assoc [Core_list]
remove_assoc' [Core_list]
remove_first [Doubly_linked]
remove_last [Doubly_linked]
remove_one [Bag]
remove_one t removes some element from the bag, and returns its value.
rename [Core_unix]
rename old new changes the name of a file from old to new.
replace [Ref]
replace t f is t := f !t
replace [Hash_queue.S]
replace [Hash_queue.Make]
replace [Fast_hashtbl]
replace [Core_hashtbl.S]
replace [Core_hashtbl]
replace [Core_array]
replace t i ~f = t.(i) <- f (t.(i)).
replace_all [Core_array]
modifies an array in place -- ar.(i) will be set to f(ar.(i))
reschedule [Timer]
reschedule event ?randomize ?interval span reschedules event to start by time span span later than originally scheduled, and change its interval behaviour as described for Timer.add.
reset [Bigbuffer]
Empty the buffer and deallocate the internal string holding the buffer contents, replacing it with the initial internal string of length n that was allocated by Buffer.create n.
return [Result]
return [Monad.Basic]
return [Monad.Make]
return [Monad.S]
return v returns the (trivial) computation that returns v.
rev [Core_list]
rev [Core_array]
rev ar reverses ar in place
rev_append [Core_list]
rev_filter_map [Core_list]
rev_filter_map f l is the reversed sublist of l containing only elements for which f returns Some e.
rev_map [Core_list]
rev_map2 [Core_list]
rev_map3 [Core_list]
rev_map_append [Core_list]
rev_map_append ~f l1 l2 reverses l1 mapping f over each element, and appends the result to the front of l2.
reverse_pairs [Core_list]
reverse_pairs l reverses each tuple inside an association list.
rewinddir [Core_unix]
Reposition the descriptor to the beginning of the directory
rindex [Core_string]
rindex_from [Core_string]
rmdir [Core_unix]
Remove an empty directory.
round [Float]
rsplit2 [Core_string]
rsplit2 line delim optionally returns line split into two strings around the * first appearance of delim from the right
rsplit2_exn [Core_string]
if string contains the character char, then rsplit2_exn string char returns a pair containing string split around the first appearance of char (from the right)
rstrip [Core_string]
rstrip str returns a new string with consecutive white space (tabs, spaces, newlines, and carriage returns) stripped from the end of str.
ru_idrss [Unix_ext.RUsage]
ru_inblock [Unix_ext.RUsage]
ru_isrss [Unix_ext.RUsage]
ru_ixrss [Unix_ext.RUsage]
ru_majflt [Unix_ext.RUsage]
ru_maxrss [Unix_ext.RUsage]
ru_minflt [Unix_ext.RUsage]
ru_msgrcv [Unix_ext.RUsage]
ru_msgsnd [Unix_ext.RUsage]
ru_nivcsw [Unix_ext.RUsage]
ru_nsignals [Unix_ext.RUsage]
ru_nswap [Unix_ext.RUsage]
ru_nvcsw [Unix_ext.RUsage]
ru_oublock [Unix_ext.RUsage]
ru_stime [Unix_ext.RUsage]
ru_utime [Unix_ext.RUsage]

S
scale [Float]
seek [Out_channel]
seek [In_channel]
select [Core_unix]
Wait until some input/output operations become possible on some channels.
send [Core_unix]
Send data over an unconnected socket.
send_fd [Linux_ext]
send_no_sigpipe [Linux_ext]
send_nonblocking_no_sigpipe [Linux_ext]
send_nonblocking_no_sigpipe [Bigstring]
sendfile [Linux_ext]
sendmsg_nonblocking_no_sigpipe [Linux_ext]
sendmsg_nonblocking_no_sigpipe [Bigstring]
sendto [Core_unix]
Send data over an unconnected socket.
sep [Month]
set [Dequeue]
set [Core_string]
set [Core_gc]
set r changes the GC parameters according to the control record r.
set [Core_array]
set_binary_mode [Out_channel]
set_binary_mode [In_channel]
set_close_on_exec [Core_unix]
Set the ``close-on-exec'' flag on the given descriptor.
set_nonblock [Core_unix]
Set the ``non-blocking'' flag on the given descriptor.
setgid [Core_unix]
Set the real group id and effective group id for the process.
setitimer [Core_unix]
setitimer t s sets the interval timer t and returns its previous status.
setrlimit [Unix_ext]
setsid [Core_unix]
Put the calling process in a new session and detach it from its controlling terminal.
setsockopt [Core_unix]
Set or clear a boolean-valued option in the given socket.
setsockopt_float [Core_unix]
Same as UnixLabels.setsockopt for a socket option whose value is a floating-point number.
setsockopt_int [Core_unix]
Same as UnixLabels.setsockopt for an integer-valued socket option.
setsockopt_optint [Core_unix]
Same as UnixLabels.setsockopt for a socket option whose value is an int option.
settcpopt_bool [Linux_ext]
settcpopt_bool sock opt v sets the current value of the boolean TCP socket option opt for socket sock to value v.
setuid [Core_unix]
Set the real user id and effective user id for the process.
sexp_of_t [Sexpable.S2]
sexp_of_t [Sexpable.S1]
sexp_of_t [Sexpable.Of_stringable]
sexp_of_t [PSet]
sexp_of_t [Interval_set]
sexp_of_t [Interned.Make]
sexp_of_t [Sexpable.S]
sexp_of_t [Hash_set.Mono]
sexp_of_t [Hash_set.Make]
sexp_of_t [Hash_set.Make_mono_or_poly]
sexp_of_t [Force_once]
sexp_of_t [Fast_hashtbl]
sexp_of_t [Exn]
sexp_of_t [Error_check.Step]
sexp_of_t [Error_check.Timer]
sexp_of_t [Error_check.ToggleN]
sexp_of_t [Error_check.Toggle]
sexp_of_t [Doubly_linked.Elt]
sexp_of_t [Doubly_linked]
sexp_of_t [Dequeue]
sexp_of_t [Core_unix.File_descr]
sexp_of_t [Core_hashtbl.HashedType]
sexp_of_t [Core_hashtbl.S]
sexp_of_t [Core_hashtbl]
sexp_of_t [Bag.Elt]
sexp_of_t [Bag]
sg [Quickcheck]
shift [Month]
shift t i goes forward (or backward) the specified number of months
shift_left [Int_intf.S]
shift_right [Int_intf.S]
shift_right_logical [Int_intf.S]
shuffle [Core_list]
shuffle l shuffles l, using Random.int
shutdown [Core_unix]
Shutdown a socket connection.
shutdown_connection [Core_unix]
``Shut down'' a connection established with UnixLabels.open_connection; that is, transmit an end-of-file condition to the server reading on the other side of the connection.
sigpending [Core_unix]
Return the set of blocked signals that are currently pending.
sigprocmask [Core_unix]
sigprocmask cmd sigs changes the set of blocked signals.
sigsuspend [Core_unix]
sigsuspend sigs atomically sets the blocked signals to sig and waits for a non-ignored, non-blocked signal to be delivered.
single_write [Core_unix]
Same as write but ensures that all errors are reported and that no character has ever been written when an error is reported.
singleton [PSet]
sleep [Core_unix]
Stop execution for the given number of seconds.
slice [Ordered_collection_common]
slice [Core_string]
slice s start stop gets a slice of s between start and stop where * start and stop are normalized.
slice [Core_list]
slice l start stop returns a new list including elements l.(start) through l.(stop-1), normalized python-style.
slice [Core_array]
slice array start stop returns a fresh array including elements array.(start) through array.(stop-1) with the small tweak that the start and stop positions are normalized and a stop index of 0 means the same thing a stop index of Array.length array.
socket [Core_unix]
Create a new socket in the given domain, and with the given kind.
socketpair [Core_unix]
Create a pair of unnamed sockets, connected together.
some_elt [Bag]
some_elt t returns some element in the bag.
sort [Core_list]
sort [Core_array]
sort_and_align [Core_arg]
sorted_copy [Core_array]
sorted_copy ar cmp returns a shallow copy of ar that is sorted.
split [PSet]
split [Core_list]
Tail-recursive split.
split2 [Core_string]
split2 line delim optionally returns line split into two strings around the * first appearance of delim from the left
split2_exn [Core_string]
if string contains the character char, then split2_exn string char returns a pair containing string split around the first appearance of char (from the left)
split_n [Core_list]
split_n n [e1; ...; em] is ([e1; ...; en], [en+1; ...; em]).
split_on_char [Core_string]
split_on_char str delim
split_on_chars [Core_string]
split_on_chars str delims
split_on_comma [Core_string]
split_on_comma str
split_on_dot [Core_string]
split_on_dot str
split_on_pipe [Core_string]
split_on_pipe str
sprintf [Core_printf]
stable_dedup [Core_list]
stable_dedup Same as dedup but maintains the order of the list.
stable_sort [Core_list]
stable_sort [Core_array]
stat [Core_unix.LargeFile]
stat [Core_unix]
Return the information for the named file.
stat [Core_gc]
Return the current values of the memory management counters in a stat record.
state [Error_check.Step]
state [Error_check.Timer]
state [Error_check.ToggleN]
state [Error_check.Toggle]
statistic [Quickcheck]
statistic_number [Quickcheck]
stderr [Out_channel]
stderr [Core_unix]
File descriptor for standard standard error.
stdin [In_channel]
stdin [Core_unix]
File descriptor for standard input.
stdout [Out_channel]
stdout [Core_unix]
File descriptor for standard output.
store_file [Bigstring]
store_file ?create ?exclusive ?append ?perm fname ?pos ?len bstr store len bytes starting at position pos of bigstring bstr in file fname using the appropriate flags for opening (creation, exclusivity, appending, permissions).
strict_add [Hash_set.Mono_or_poly]
strict_add [Hash_set.Make_mono_or_poly]
strict_remove [Hash_set.Mono_or_poly]
strict_remove [Hash_set.Make_mono_or_poly]
string_kind [Unix_ext.IOVec]
string_of_inet_addr [Core_unix]
Return the printable representation of the given Internet address.
strip [Core_string]
strip str returns a new string with consecutive white space (tabs, spaces, newlines, and carriage returns) stripped from the beginning and end of str.
sub [Int_intf.S]
sub [Float]
sub [Core_string]
sub [Core_list]
sub pos len l is the len-element sublist of l, starting at pos.
sub [Core_array]
sub [Bigstring]
sub ?pos ?len bstr
sub [Bigbuffer]
Buffer.sub b off len returns (a copy of) the substring of the current contents of the buffer b starting at offset off of length len bytes.
subset [PSet]
subsets [PSet]
succ [Int_intf.S]
sum_int [Quickcheck]
swap [Ref]
swap t1 t2 swaps the values in t1 and t2.
swap [Core_array]
swap arr i j swaps the value at index i with that at index j.
symlink [Core_unix]
symlink source dest creates the file dest as a symbolic link to the file source.
sync [Unix_ext]
Synchronize all filesystem buffers with disk.
sysconf [Unix_ext]
system [Core_unix]
Execute the given command, wait until it terminates, and return its termination status.

T
t_of_sexp [Sexpable.S2]
t_of_sexp [Sexpable.S1]
t_of_sexp [Sexpable.Of_stringable]
t_of_sexp [PSet]
t_of_sexp [Interval_set]
t_of_sexp [Interned.Make]
t_of_sexp [Sexpable.S]
t_of_sexp [Hash_set.Mono]
t_of_sexp [Hash_set.Make]
t_of_sexp [Hash_set.Make_mono_or_poly]
t_of_sexp [Dequeue]
t_of_sexp [Core_hashtbl.HashedType]
t_of_sexp [Core_hashtbl.S]
t_of_sexp [Core_hashtbl]
tail [Linebuf]
Seeks to the end of the file and blocks until another line is available -- this new line is not returned.
take_back [Dequeue]
take_front [Dequeue]
tcdrain [Core_unix]
Waits until all output written on the given file descriptor has been transmitted.
tcflow [Core_unix]
Suspend or restart reception or transmission of data on the given file descriptor, depending on the second argument: TCOOFF suspends output, TCOON restarts output, TCIOFF transmits a STOP character to suspend input, and TCION transmits a START character to restart input.
tcflush [Core_unix]
Discard data written on the given file descriptor but not yet transmitted, or data received but not yet read, depending on the second argument: TCIFLUSH flushes data received but not read, TCOFLUSH flushes data written but not transmitted, and TCIOFLUSH flushes both.
tcgetattr [Core_unix]
Return the status of the terminal referred to by the given file descriptor.
tcsendbreak [Core_unix]
Send a break condition on the given file descriptor.
tcsetattr [Core_unix]
Set the status of the terminal referred to by the given file descriptor.
temp_dir [Core_filename]
Same as temp_file but creates a temporary directory.
temp_dir_name [Core_filename]
temp_file [Core_filename]
temp_file ?temp_dir_name prefix suffix
test [Binary_packing]
test_invariants [Fqueue]
test via asserts whether invariants hold
tg [Quickcheck]
time [Core_unix]
Return the current time since 00:00:00 GMT, Jan.
times [Core_unix]
Return the execution times of the process.
tl [Core_list]
tl_exn [Core_list]
to_alist [Core_hashtbl.S]
to_alist [Core_hashtbl]
to_array [PSet]
to_array [Hash_queue.Make]
to_array [Container.S1]
to_array [Container.S0_phantom]
to_array [Container.S0]
to_float [Floatable.S]
to_int [Month]
to_int t returns an int in 1,2,...12.
to_int [Float]
to_int [Core_unix.File_descr]
to_int [Core_nativeint]
to_int [Core_int64]
to_int [Core_int32]
to_int [Core_int]
to_int [Core_char]
to_int [Bool]
to_int32 [Core_nativeint]
to_int32 [Core_int64]
to_int32 [Core_int32]
to_int32 [Core_int]
to_int32_exn [Core_nativeint]
to_int32_exn [Core_int64]
to_int32_exn [Core_int]
to_int64 [Core_nativeint]
to_int64 [Core_int64]
to_int64 [Core_int32]
to_int64 [Core_int]
to_int_exn [Core_nativeint]
to_int_exn [Core_int64]
to_int_exn [Core_int32]
to_list [PSet]
to_list [Hash_set.Mono_or_poly]
to_list [Hash_set.Make_mono_or_poly]
to_list [Hash_queue.Make]
to_list [Fqueue]
converts queue to list, from most to least recently enqueued item
to_list [Container.S1]
to_list [Container.S0_phantom]
to_list [Container.S0]
to_nativeint [Core_nativeint]
to_nativeint [Core_int64]
to_nativeint [Core_int32]
to_nativeint [Core_int]
to_nativeint_exn [Core_int64]
to_string [Sexpable.To_stringable]
to_string [Interned.Make]
to_string [Stringable.S]
to_string [Exn]
to_string [Core_list]
to_string [Core_char]
to_string [Bigstring]
to_string_hum [Float]
to_string_hum [Core_int]
top [Heap]
top heap
top [Fqueue]
like top_exn, but returns result optionally, without exception
top [Core_stack]
top t returns None if t is empty, otherwise it returns Some x where x is the top of t.
top_exn [Fqueue]
Like bot_exn, except returns top (least-recently enqueued element
top_exn [Core_stack]
top_exn t returns the top element of t, raising Empty if t is empty.
tr [Core_string]
tr target replacement s replaces every instance of target in s with replacement.
transfer [Doubly_linked]
transfer ~src ~dst has the same behavior as iter src ~f:(insert_last dst); clear src except that it runs in constant time.
transfer [Core_queue]
transfer ~src ~dst adds all of the elements of src to the end of dst, then clears src.
transfer_queue [Squeue]
Transfers all elements from the squeue to an ordinary queue.
transfer_queue_in [Squeue]
Transfers all the elements from an ordinary queue into the squeue.
transfer_queue_nowait [Squeue]
Transfers all elements from the squeue to an ordinary queue.
translate [Core_string]
Like map, but allows replacement of a single character with zero or two or more characters.
truncate [Float]
truncate [Core_unix.LargeFile]
truncate [Core_unix]
Truncates the named file to the given size.
try_lock [Core_mutex]
try_read [Linebuf]
Tries to read a line from the file.
try_read_lnum [Linebuf]
try_read_lnum is like try_read except also provides the line number of the read line.
try_read_lnum_verbose [Linebuf]
Like try_read, except that it returns more verbose errors

U
ubound [Interval_set]
uig [Quickcheck]
umask [Core_unix]
Set the process creation mask, and return the previous mask.
uncapitalize [Core_string]
uncurry [Tuple.T3]
uncurry [Tuple.T2]
unescaped [Core_string]
unescaped s is the inverse operation of escaped: it takes a string where all the special characters are escaped following the lexical convention of OCaml and returns an unescaped copy.
unescaped_res [Core_string]
Same as unescaped but instead of raising Failure _ returns an error message with the position in the string in case of failure.
union [PSet]
unit [Monad.Make]
unit [Memo]
Returns memoized version of any function with argument unit.
unit [Monad.S]
unit = return ()
unix_error [Unix_ext]
unlink [Core_unix]
Removes the named file
unlock [Core_mutex]
unpack_float [Binary_packing]
unpack_signed_16 [Binary_packing]
unpack a signed 2 byte int from the given buf starting at pos
unpack_signed_32 [Binary_packing]
unpack a signed 4 byte int32 from the given buf starting at pos
unpack_signed_32_int [Binary_packing]
unpack a signed 4 byte int32 from the given buf starting at pos.
unpack_signed_8 [Binary_packing]
unsafe_blit [Bigstring]
unsafe_blit ~src_pos ~src ~dst_pos ~dst ~len similar to Bigstring.blit, but does not perform any bounds checks.
unsafe_blit_bigstring_string [Bigstring]
unsafe_blit_bigstring_string ~src_pos bstr ~dst_pos str ~len similar to Bigstring.blit_bigstring_string, but does not perform any bounds checks.
unsafe_blit_string_bigstring [Bigstring]
unsafe_blit_string_bigstring_stub ~src_pos str ~dst_pos bstr ~len similar to Bigstring.blit_string_bigstring, but does not perform any bounds checks.
unsafe_input [Bigstring]
unsafe_input ~min_len ic ~pos ~len bstr similar to Bigstring.input, but does not perform any bounds checks.
unsafe_of_int [Core_char]
unsafe_output [Bigstring]
unsafe_output ~min_len oc ~pos ~len bstr similar to Bigstring.output, but does not perform any bounds checks.
unsafe_read [Bigstring]
unsafe_read ~min_len fd ~pos ~len bstr similar to Bigstring.read, but does not perform any bounds checks.
unsafe_read_assume_nonblocking [Bigstring]
unsafe_read_assume_nonblocking fd ~pos ~len bstr similar to Bigstring.read_assume_nonblocking, but does not perform any bounds checks.
unsafe_really_recv [Bigstring]
unsafe_really_recv sock ~pos ~len bstr similar to Bigstring.really_recv, but does not perform any bounds checks.
unsafe_really_send_no_sigpipe [Bigstring]
unsafe_really_send_no_sigpipe sock ~pos ~len bstr similar to Bigstring.send, but does not perform any bounds checks.
unsafe_really_write [Bigstring]
unsafe_really_write fd ~pos ~len bstr similar to Bigstring.write, but does not perform any bounds checks.
unsafe_send_nonblocking_no_sigpipe [Bigstring]
unsafe_send_nonblocking_no_sigpipe sock ~pos ~len bstr similar to Bigstring.send_nonblocking_no_sigpipe, but does not perform any bounds checks.
unsafe_sendmsg_nonblocking_no_sigpipe [Bigstring]
unsafe_sendmsg_nonblocking_no_sigpipe fd iovecs count similar to Bigstring.sendmsg_nonblocking_no_sigpipe, but does not perform any bounds checks.
unsafe_tail [Linebuf]
Same as tail except it may return before a new line is available on the file (i.e.
unsafe_write [Bigstring]
unsafe_write fd ~pos ~len bstr similar to Bigstring.write, but does not perform any bounds checks.
unsafe_write_assume_nonblocking [Bigstring]
unsafe_write_assume_nonblocking fd ~pos ~len bstr similar to Bigstring.write_assume_nonblocking, but does not perform any bounds checks.
unsafe_writev [Bigstring]
unsafe_writev fd iovecs count similar to Bigstring.writev, but does not perform any bounds checks.
until_empty [Core_stack]
until_empty t f repeatedly pops an element v off of t and runs f v until t becomes empty.
until_empty [Bag]
until_empty t f repeatedly removes a value v from t and runs f v, continuing until t is empty.
update [Heap]
update heap_el el updates heap_el with element el in its associated heap.
uppercase [Core_string]
uppercase [Core_char]
usage [Core_arg]
utimes [Core_unix]
Set the last access time (second arg) and last modification time (third arg) for a file.

V
value [Option]
value None ~default = default value (Some x) ~default = x
value [Doubly_linked.Elt]
value [Bag.Elt]
value_exn [Option]
value_exn (Some x) = x.

W
wait [Linux_ext.Epoll]
wait [Core_unix]
Wait until one of the children processes die, and return its pid and termination status.
wait_not_empty [Squeue]
wait_not_empty sq Waits for something to be available.
waitpid [Core_unix]
Same as UnixLabels.wait, but waits for the process whose pid is given.
with_set [Ref]
with_set t x f sets t to x and runs f x, returning t to its original value once f () completes.
word_size [Word_size]
write [Core_unix]
write fd buff ofs len writes len characters to descriptor fd, taking them from string buff, starting at position ofs in string buff.
write [Bigstring]
write_assume_nonblocking [Unix_ext]
write_assume_nonblocking [Bigstring]
writev [Bigstring]
writev_assume_nonblocking [Unix_ext]
writev_assume_nonblocking [Bigstring]

Z
zero [Int_intf.S]
zero [Float]