( * ) [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
normalize d 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
normalize d 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] |