(%:) [Command.Spec] | (name %: typ) specifies a required anonymous argument of type typ .
|
(+) [Time_stamp_counter.Span] | |
(+) [Span] |
Basic operations on spans
|
(++) [Command.Spec] |
command-line spec composition
|
(+<) [Command.Spec] |
add a leftmost parameter onto the type of main
|
(+>) [Command.Spec] |
add a rightmost parameter onto the type of main
|
(-) [Time_stamp_counter.Span] | |
(-) [Span] | |
(/) [Span] | |
(//) [Span] | |
(^/) [Std] | |
(^/) [Common] | |
__bin_read_sockaddr__ [Unix] | |
__bin_read_socket_domain__ [Unix] | |
__bin_read_socket_type__ [Unix] | |
__bin_read_t__ [Time0.Stable.V1.C] | |
__bin_read_t__ [Time_stamp_counter.Span] | |
__bin_read_t__ [Time_stamp_counter.Calibrator] | |
__bin_read_t__ [Time_stamp_counter] | |
__bin_read_t__ [Time] | |
__bin_read_t__ [Zone.Stable.V1] | |
__bin_read_t__ [User_and_group.Stable.V1] | |
__bin_read_t__ [Time.Stable.V1] | |
__bin_read_t__ [Span.Stable.V1] | |
__bin_read_t__ [Span] | |
__bin_read_t__ [Signal] | |
__bin_read_t__ [Piecewise_linear_intf.Float_like] | |
__bin_read_t__ [Piecewise_linear_intf.S] | |
__bin_read_t__ [Ofday.Stable.V1] | |
__bin_read_t__ [Ofday.Zoned.Stable.V1] | |
__bin_read_t__ [Ofday.Zoned] | |
__bin_read_t__ [Ofday] | |
__bin_read_t__ [Linux_ext.Timerfd.Clock] | |
__bin_read_t__ [Linux_ext.Timerfd] | |
__bin_read_t__ [Linux_ext.Sysinfo] | |
__bin_read_t__ [Interval_intf.S.Set] | |
__bin_read_t__ [Interval_intf.S] | |
__bin_read_t__ [Interval_intf.S1.Set] | |
__bin_read_t__ [Interval_intf.S1] | |
__bin_read_t__ [Interval.Stable.V1.Ofday] | |
__bin_read_t__ [Interval.Stable.V1.Time] | |
__bin_read_t__ [Interval.Stable.V1.Int] | |
__bin_read_t__ [Interval.Stable.V1.Float] | |
__bin_read_t__ [Date0.Stable.V1] | |
__bin_read_t__ [Date0] | |
__bin_read_t__ [Unix.Cidr] | |
__bin_read_t__ [Unix.Inet_addr] | |
__bin_read_t__ [Unix.Protocol_family] | |
__bin_read_t__ [Unix.File_descr] | |
__bin_read_tcp_bool_option__ [Linux_ext] | |
__env_of_sexp__ [Unix] | |
__error_of_sexp__ [Unix.Exit_or_signal_or_stop] | |
__error_of_sexp__ [Unix.Exit_or_signal] | |
__error_of_sexp__ [Unix.Exit] | |
__sys_behavior_of_sexp__ [Signal] | |
__t_of_sexp__ [Time0.Stable.V1.Epoch_cache] | |
__t_of_sexp__ [Unix.Scheduler.Policy] | |
__t_of_sexp__ [Unix.Protocol_family] | |
__wait_on_of_sexp__ [Unix] | |
_squelch_unused_module_warning_ [Std] | |
A | |
abbreviation [Zone] | abbreviation zone t returns t abbreviation name such as EDT, EST, JST of given
zone at the time t .
|
abort [Unix] | |
abrt [Signal] | Dump_core Abnormal termination
|
abs [Span] |
absolute value
|
abs_diff [Time_internal.T] | |
abs_diff [Time] | abs_diff t1 t2 returns the absolute span of time t1 minus time t2 .
|
accept [Unix] |
Accept connections on the given socket.
|
access [Unix] |
Check that the process has the given permissions over the named file.
|
access_exn [Unix] | |
ad_hoc [Command.Deprecated.Spec] | |
add [Timing_wheel_intf.S.Priority_queue] | add t ~key value adds a new value to t and returns an element that can later
be supplied to remove the element from t .
|
add [Timing_wheel_intf.S] | add t ~at a adds a new value a to t and returns an alarm that can later be
supplied to remove the alarm from t .
|
add [Time_internal.T] | |
add [Time_stamp_counter] | |
add [Time] | add t s adds the span s to time t and returns the resulting time.
|
add [Ofday] | add t s shifts the time of day t by the span s .
|
add [Unix.Resource_usage] | add ru1 ru2 adds two rusage structures (e.g.
|
add_at_interval_num [Timing_wheel_intf.S] | |
add_business_days [Date0] | add_business_days t ~is_holiday n returns a business day even when
n=0 .
|
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_days [Date0] | |
add_finalizer [Gc.Expert] | add_finalizer b f ensures that f runs after b becomes unreachable.
|
add_finalizer_exn [Gc.Expert] | |
add_months [Date0] | add_months t n returns date with max days for the month if the date would be
invalid.
|
add_weekdays [Date0] | add_weekdays t 0 returns the next weekday if t is a weekend and t otherwise.
|
addr_info_of_sexp [Unix] |
Address information returned by
Unix.getaddrinfo .
|
advance [Iobuf] | advance t amount advances the lower bound of the window by amount .
|
advance_clock [Timing_wheel_intf.S] | advance_clock t ~to_ ~handle_fired advances t 's clock to to_ .
|
alarm [Unix] |
Schedule a
SIGALRM signal after the given number of seconds.
|
alarm_precision [Timing_wheel_intf.S.Config] |
accessors
|
alarm_precision [Timing_wheel_intf.S] |
Accessors
|
alarm_upper_bound [Timing_wheel_intf.S] | alarm_upper_bound t returns the upper bound on an at that can be supplied to
add .
|
alrm [Signal] | Terminate Timeout
|
am [Debug] | am , ams , and amf output a source code position and backtrace to stderr.
|
am_recording [Backtrace.Exn] | |
amf [Debug] | |
ams [Debug] | |
anon [Command.Spec] | anon spec specifies a command that, among other things, takes
the anonymous arguments specified by spec .
|
append [Unix.Open_flags] | |
are_disjoint [Interval_intf.Gen] | are_disjoint ts returns true iff the intervals in ts are pairwise disjoint.
|
are_disjoint_as_open_intervals [Interval_intf.Gen] |
Returns true iff a given set of intervals would be disjoint if considered as open
intervals.
|
args [Command.Spec] |
the arguments passed to the command
|
argv [Sys] |
The command line arguments given to the process.
|
at [Timing_wheel_intf.S.Alarm] |
All
Alarm functions will raise if not (Timing_wheel.mem timing_wheel t) .
|
B | |
base_address [Unix.Cidr] |
Accessors.
|
basename [Filename] |
Respects the posix semantic.
|
basic [Command] | basic ~summary ?readme spec main is a basic command that executes a function main
which is passed parameters parsed from the command line according to spec .
|
bigstring [Iobuf_intf.Accessors] | |
bigstring_kind [Unix.IOVec] | |
bin_prot [Iobuf_intf.Accessors] | |
bin_read_sockaddr [Unix] | |
bin_read_socket_domain [Unix] | |
bin_read_socket_type [Unix] | |
bin_read_t [Time0.Stable.V1.C] | |
bin_read_t [Time_stamp_counter.Span] | |
bin_read_t [Time_stamp_counter.Calibrator] | |
bin_read_t [Time_stamp_counter] | |
bin_read_t [Time] | |
bin_read_t [Zone.Stable.V1] | |
bin_read_t [User_and_group.Stable.V1] | |
bin_read_t [Time.Stable.V1] | |
bin_read_t [Span.Stable.V1] | |
bin_read_t [Span] | |
bin_read_t [Signal] | |
bin_read_t [Piecewise_linear_intf.Float_like] | |
bin_read_t [Piecewise_linear_intf.S] | |
bin_read_t [Ofday.Stable.V1] | |
bin_read_t [Ofday.Zoned.Stable.V1] | |
bin_read_t [Ofday.Zoned] | |
bin_read_t [Ofday] | |
bin_read_t [Linux_ext.Timerfd.Clock] | |
bin_read_t [Linux_ext.Timerfd] | |
bin_read_t [Linux_ext.Sysinfo] | |
bin_read_t [Interval_intf.S.Set] | |
bin_read_t [Interval_intf.S] | |
bin_read_t [Interval_intf.S1.Set] | |
bin_read_t [Interval_intf.S1] | |
bin_read_t [Interval.Stable.V1.Ofday] | |
bin_read_t [Interval.Stable.V1.Time] | |
bin_read_t [Interval.Stable.V1.Int] | |
bin_read_t [Interval.Stable.V1.Float] | |
bin_read_t [Date0.Stable.V1] | |
bin_read_t [Date0] | |
bin_read_t [Unix.Cidr] | |
bin_read_t [Unix.Inet_addr] | |
bin_read_t [Unix.Protocol_family] | |
bin_read_t [Unix.File_descr] | |
bin_read_tcp_bool_option [Linux_ext] | |
bin_reader_sockaddr [Unix] | |
bin_reader_socket_domain [Unix] | |
bin_reader_socket_type [Unix] | |
bin_reader_t [Time0.Stable.V1.C] | |
bin_reader_t [Time_stamp_counter.Span] | |
bin_reader_t [Time_stamp_counter.Calibrator] | |
bin_reader_t [Time_stamp_counter] | |
bin_reader_t [Time] | |
bin_reader_t [Zone.Stable.V1] | |
bin_reader_t [User_and_group.Stable.V1] | |
bin_reader_t [Time.Stable.V1] | |
bin_reader_t [Span.Stable.V1] | |
bin_reader_t [Span] | |
bin_reader_t [Signal] | |
bin_reader_t [Piecewise_linear_intf.Float_like] | |
bin_reader_t [Piecewise_linear_intf.S] | |
bin_reader_t [Ofday.Stable.V1] | |
bin_reader_t [Ofday.Zoned.Stable.V1] | |
bin_reader_t [Ofday.Zoned] | |
bin_reader_t [Ofday] | |
bin_reader_t [Linux_ext.Timerfd.Clock] | |
bin_reader_t [Linux_ext.Timerfd] | |
bin_reader_t [Linux_ext.Sysinfo] | |
bin_reader_t [Interval_intf.S.Set] | |
bin_reader_t [Interval_intf.S] | |
bin_reader_t [Interval_intf.S1.Set] | |
bin_reader_t [Interval_intf.S1] | |
bin_reader_t [Interval.Stable.V1.Ofday] | |
bin_reader_t [Interval.Stable.V1.Time] | |
bin_reader_t [Interval.Stable.V1.Int] | |
bin_reader_t [Interval.Stable.V1.Float] | |
bin_reader_t [Date0.Stable.V1] | |
bin_reader_t [Date0] | |
bin_reader_t [Unix.Cidr] | |
bin_reader_t [Unix.Inet_addr] | |
bin_reader_t [Unix.Protocol_family] | |
bin_reader_t [Unix.File_descr] | |
bin_reader_tcp_bool_option [Linux_ext] | |
bin_size_sockaddr [Unix] | |
bin_size_socket_domain [Unix] | |
bin_size_socket_type [Unix] | |
bin_size_t [Time0.Stable.V1.C] | |
bin_size_t [Time_stamp_counter.Span] | |
bin_size_t [Time_stamp_counter.Calibrator] | |
bin_size_t [Time_stamp_counter] | |
bin_size_t [Time] | |
bin_size_t [Zone.Stable.V1] | |
bin_size_t [User_and_group.Stable.V1] | |
bin_size_t [Time.Stable.V1] | |
bin_size_t [Span.Stable.V1] | |
bin_size_t [Span] | |
bin_size_t [Signal] | |
bin_size_t [Piecewise_linear_intf.Float_like] | |
bin_size_t [Piecewise_linear_intf.S] | |
bin_size_t [Ofday.Stable.V1] | |
bin_size_t [Ofday.Zoned.Stable.V1] | |
bin_size_t [Ofday.Zoned] | |
bin_size_t [Ofday] | |
bin_size_t [Linux_ext.Timerfd.Clock] | |
bin_size_t [Linux_ext.Timerfd] | |
bin_size_t [Linux_ext.Sysinfo] | |
bin_size_t [Interval_intf.S.Set] | |
bin_size_t [Interval_intf.S] | |
bin_size_t [Interval_intf.S1.Set] | |
bin_size_t [Interval_intf.S1] | |
bin_size_t [Interval.Stable.V1.Ofday] | |
bin_size_t [Interval.Stable.V1.Time] | |
bin_size_t [Interval.Stable.V1.Int] | |
bin_size_t [Interval.Stable.V1.Float] | |
bin_size_t [Date0.Stable.V1] | |
bin_size_t [Date0] | |
bin_size_t [Unix.Cidr] | |
bin_size_t [Unix.Inet_addr] | |
bin_size_t [Unix.Protocol_family] | |
bin_size_t [Unix.File_descr] | |
bin_size_tcp_bool_option [Linux_ext] | |
bin_sockaddr [Unix] |
The type of socket addresses.
|
bin_socket_domain [Unix] |
The type of socket domains.
|
bin_socket_type [Unix] |
The type of socket kinds, specifying the semantics of
communications.
|
bin_t [Time0.Stable.V1.C] | |
bin_t [Time_stamp_counter.Span] | |
bin_t [Time_stamp_counter.Calibrator] | |
bin_t [Time_stamp_counter] | |
bin_t [Time] | |
bin_t [Zone.Stable.V1] | |
bin_t [User_and_group.Stable.V1] | |
bin_t [Time.Stable.V1] | |
bin_t [Span.Stable.V1] | |
bin_t [Span] | |
bin_t [Signal] | |
bin_t [Piecewise_linear_intf.Float_like] | |
bin_t [Piecewise_linear_intf.S] | |
bin_t [Ofday.Stable.V1] | |
bin_t [Ofday.Zoned.Stable.V1] | |
bin_t [Ofday.Zoned] | |
bin_t [Ofday] | |
bin_t [Linux_ext.Timerfd.Clock] | |
bin_t [Linux_ext.Timerfd] | |
bin_t [Linux_ext.Sysinfo] | |
bin_t [Interval_intf.S.Set] | |
bin_t [Interval_intf.S] | |
bin_t [Interval_intf.S1.Set] | |
bin_t [Interval_intf.S1] | |
bin_t [Interval.Stable.V1.Ofday] | |
bin_t [Interval.Stable.V1.Time] | |
bin_t [Interval.Stable.V1.Int] | |
bin_t [Interval.Stable.V1.Float] | |
bin_t [Date0.Stable.V1] | |
bin_t [Date0] | |
bin_t [Unix.Cidr] | |
bin_t [Unix.Inet_addr] | |
bin_t [Unix.Protocol_family] | |
bin_t [Unix.File_descr] | |
bin_tcp_bool_option [Linux_ext] | |
bin_write_sockaddr [Unix] | |
bin_write_socket_domain [Unix] | |
bin_write_socket_type [Unix] | |
bin_write_t [Time0.Stable.V1.C] | |
bin_write_t [Time_stamp_counter.Span] | |
bin_write_t [Time_stamp_counter.Calibrator] | |
bin_write_t [Time_stamp_counter] | |
bin_write_t [Time] | |
bin_write_t [Zone.Stable.V1] | |
bin_write_t [User_and_group.Stable.V1] | |
bin_write_t [Time.Stable.V1] | |
bin_write_t [Span.Stable.V1] | |
bin_write_t [Span] | |
bin_write_t [Signal] | |
bin_write_t [Piecewise_linear_intf.Float_like] | |
bin_write_t [Piecewise_linear_intf.S] | |
bin_write_t [Ofday.Stable.V1] | |
bin_write_t [Ofday.Zoned.Stable.V1] | |
bin_write_t [Ofday.Zoned] | |
bin_write_t [Ofday] | |
bin_write_t [Linux_ext.Timerfd.Clock] | |
bin_write_t [Linux_ext.Timerfd] | |
bin_write_t [Linux_ext.Sysinfo] | |
bin_write_t [Interval_intf.S.Set] | |
bin_write_t [Interval_intf.S] | |
bin_write_t [Interval_intf.S1.Set] | |
bin_write_t [Interval_intf.S1] | |
bin_write_t [Interval.Stable.V1.Ofday] | |
bin_write_t [Interval.Stable.V1.Time] | |
bin_write_t [Interval.Stable.V1.Int] | |
bin_write_t [Interval.Stable.V1.Float] | |
bin_write_t [Date0.Stable.V1] | |
bin_write_t [Date0] | |
bin_write_t [Unix.Cidr] | |
bin_write_t [Unix.Inet_addr] | |
bin_write_t [Unix.Protocol_family] | |
bin_write_t [Unix.File_descr] | |
bin_write_tcp_bool_option [Linux_ext] | |
bin_writer_sockaddr [Unix] | |
bin_writer_socket_domain [Unix] | |
bin_writer_socket_type [Unix] | |
bin_writer_t [Time0.Stable.V1.C] | |
bin_writer_t [Time_stamp_counter.Span] | |
bin_writer_t [Time_stamp_counter.Calibrator] | |
bin_writer_t [Time_stamp_counter] | |
bin_writer_t [Time] | |
bin_writer_t [Zone.Stable.V1] | |
bin_writer_t [User_and_group.Stable.V1] | |
bin_writer_t [Time.Stable.V1] | |
bin_writer_t [Span.Stable.V1] | |
bin_writer_t [Span] | |
bin_writer_t [Signal] | |
bin_writer_t [Piecewise_linear_intf.Float_like] | |
bin_writer_t [Piecewise_linear_intf.S] | |
bin_writer_t [Ofday.Stable.V1] | |
bin_writer_t [Ofday.Zoned.Stable.V1] | |
bin_writer_t [Ofday.Zoned] | |
bin_writer_t [Ofday] | |
bin_writer_t [Linux_ext.Timerfd.Clock] | |
bin_writer_t [Linux_ext.Timerfd] | |
bin_writer_t [Linux_ext.Sysinfo] | |
bin_writer_t [Interval_intf.S.Set] | |
bin_writer_t [Interval_intf.S] | |
bin_writer_t [Interval_intf.S1.Set] | |
bin_writer_t [Interval_intf.S1] | |
bin_writer_t [Interval.Stable.V1.Ofday] | |
bin_writer_t [Interval.Stable.V1.Time] | |
bin_writer_t [Interval.Stable.V1.Int] | |
bin_writer_t [Interval.Stable.V1.Float] | |
bin_writer_t [Date0.Stable.V1] | |
bin_writer_t [Date0] | |
bin_writer_t [Unix.Cidr] | |
bin_writer_t [Unix.Inet_addr] | |
bin_writer_t [Unix.Protocol_family] | |
bin_writer_t [Unix.File_descr] | |
bin_writer_tcp_bool_option [Linux_ext] | |
bind [Unix] |
Bind a socket to an address.
|
bind_any [Unix.Inet_addr] |
A special address, for use only with
bind , representing all the Internet addresses
that the host machine possesses.
|
bind_any_inet6 [Unix.Inet_addr] | |
bind_to_interface [Linux_ext] | |
bits [Unix.Cidr] | |
blit_string_of_int_2_digits [Time_internal.Helpers] | |
blit_string_of_int_3_digits [Time_internal.Helpers] | |
blit_string_of_int_4_digits [Time_internal.Helpers] | |
block_forever [Thread] | block_forever () will block the calling thread forever.
|
blocking_create [Lock_file.Nfs] | blocking_create ?message path like create, but sleeps for 1 second between lock
attempts and does not return until it succeeds or timeout expires.
|
blocking_create [Lock_file] | blocking_create t tries to create the lock.
|
bool [Command.Spec] | |
bound [Interval_intf.Gen] | bound t x returns None iff is_empty t .
|
bounded_compact [Iobuf] | |
bounded_flip_hi [Iobuf] | |
bounded_flip_lo [Iobuf] | |
bounds [Interval_intf.Gen] | |
bounds_exn [Interval_intf.Gen] | |
broadcast [Condition] | |
build_info [Command.Deprecated] | |
business_dates_between [Date0] | |
C | |
c_int_size [Sys] | c_int_size returns the number of bits in a C int .
|
calibrate [Time_stamp_counter.Calibrator] | calibrate ~t updates t by measuring the current value of the TSC and
Time.now .
|
can_read [Unix.Open_flags] | can_read t iff t has rdonly or rdwr
|
can_send_to [Signal] | can_send_to pid returns true if pid is running and the current process has
permission to send it signals.
|
can_write [Unix.Open_flags] | can_read t iff t has wronly or rdwr
|
capacity [Iobuf] | capacity t returns the size of t 's limits subrange.
|
catch_break [Sys] |
Warning: this function clobbers the Signal.int (SIGINT) handler.
|
char [Iobuf_intf.Accessors] | |
chdir [Unix] |
Change the process working directory.
|
chdir [Sys] |
Change the current working directory of the process.
|
check_invariant [Timing_wheel_intf.Timing_wheel.Debug] | |
check_invariant [Iobuf_debug.Make] | |
check_suffix [Filename] | check_suffix name suff returns true if the filename name
ends with the suffix suff .
|
chld [Signal] | Ignore Child process terminated
|
chmod [Unix] |
Change the permissions of the named file.
|
chop_extension [Filename] |
Return the given file name without its extension.
|
chop_suffix [Filename] | chop_suffix name suff removes the suffix suff from
the filename name .
|
chown [Unix] |
Change the owner uid and owner gid of the named file.
|
chroot [Unix] |
Change the process root directory.
|
clear [Timing_wheel_intf.S.Priority_queue] | clear t removes all elts from t .
|
clear [Timing_wheel_intf.S] | clear t removes all alarms from t .
|
clear [Squeue] |
clears the queue
|
clear [Linux_ext.Timerfd] | clear t causes t to not fire any more.
|
clear_close_on_exec [Unix] |
Clear the ``close-on-exec'' flag on the given descriptor.
|
clear_nonblock [Unix] |
Clear the ``non-blocking'' flag on the given descriptor.
|
cloexec [Linux_ext.Timerfd.Flags] | |
close [Linux_ext.Epoll] | |
close [Unix] |
Close a file descriptor.
|
close_process [Unix] |
Close channels opened by
UnixLabels.open_process ,
wait for the associated command to terminate,
and return its termination status.
|
close_process_full [Unix] |
Close channels opened by
UnixLabels.open_process_full ,
wait for the associated command to terminate,
and return its termination status.
|
close_process_in [Unix] |
Close channels opened by
UnixLabels.open_process_in ,
wait for the associated command to terminate,
and return its termination status.
|
close_process_out [Unix] |
Close channels opened by
UnixLabels.open_process_out ,
wait for the associated command to terminate,
and return its termination status.
|
closedir [Unix] |
Close a directory descriptor.
|
code [Unix.Exit] | |
command [Sys] |
Execute the given shell command and return its exit code.
|
command_exn [Sys] | |
compact [Iobuf] | compact t copies data from the window to the lower limit of the iobuf and sets the
window to range from the end of the copied data to the upper limit.
|
comparator [Time0.Stable.V1.C] | |
compare [Time0.Stable.V1.C] | |
compare [Time_stamp_counter] | |
compare [Zone.Stable.V1] | |
compare [User_and_group.Stable.V1] | |
compare [Time.Stable.V1] | |
compare [Span.Stable.V1] | |
compare [Piecewise_linear_intf.S] | |
compare [Ofday.Stable.V1] | |
compare [Linux_ext.Timerfd.Clock] | |
compare [Linux_ext.Timerfd] | |
compare [Date0.Stable.V1] | |
compare_value [Interval_intf.Gen] | |
concat [Filename] | concat p1 p2 returns a path equivalent to p1 ^ "/" ^ p2 .
|
connect [Unix] |
Connect a socket to an address.
|
const [Command.Spec] |
a hard-coded parameter
|
consume_bin_prot [Iobuf] | |
consume_into_bigstring [Iobuf] | |
consume_into_string [Iobuf] | consume_into_string t s ~pos ~len reads len bytes from t , advancing t 's window
accordingly, and writes them into s starting at pos .
|
cont [Signal] | Continue Continue
|
contains [Interval_intf.Gen_set] | |
contains [Interval_intf.Gen] | |
contains_set [Interval_intf.Gen_set] | |
convert [Time0.Stable.V1] | |
convert [Time] | |
convex_hull [Interval_intf.Gen] | convex_hull ts returns an interval whose upperbound is the greatest upperbound of
the intervals in the list, and whose lowerbound is the least lowerbound of the
list.
|
core_file_size [Unix.RLimit] | |
cores [Linux_ext] | cores ()
|
cpu_mhz [Time_stamp_counter.Calibrator] |
Returns the estimated MHz of the CPU's time-stamp-counter based on the TSC and
Time.now () .
|
cpu_seconds [Unix.RLimit] | |
crc32 [Crc] |
Compute the 32-bit crc
|
crc32hex [Crc] |
String version of the crc, encoded in hex.
|
creat [Unix.Open_flags] |
creation
|
create [Timing_wheel_intf.S.Priority_queue] | create ?level_bits () creates a new empty timing wheel, t , with length t = 0
and min_allowed_key t = 0 .
|
create [Timing_wheel_intf.S.Config] | create raises if alarm_precision <= 0 .
|
create [Timing_wheel_intf.S] | create ~config ~start creates a new timing wheel with current time start .
|
create [Weak_hashtbl] | |
create [Uuid] | create () returns a new t guaranteed to not be equal to any other UUID generated
by any process anywhere.
|
create [User_and_group] | |
create [Time_stamp_counter.Calibrator] | create () creates an uninitialized calibrator instance.
|
create [Squeue] | create maxsize returns a synchronized queue bounded to have no more than
maxsize elements.
|
create [Span] | |
create [Piecewise_linear_intf.S] | create enforces that x (key) values are non-decreasing.
|
create [Ofday.Zoned] | |
create [Ofday] | |
create [Nano_mutex] | create () returns a new, unlocked mutex.
|
create [Mutex0] | |
create [Lock_file.Nfs] | create ?message path tries to create and lock the file at path by creating a hard
link to path .nfs_lock.
|
create [Lock_file] | create ?close_on_exec ?message path tries to create a file at path containing the
text message , which defaults to the pid of the locking process.
|
create [Linux_ext.Epoll] | create ~num_file_descrs creates a new epoll set able to watch file descriptors in
[0, num_file_descrs).
|
create [Linux_ext.Timerfd] | create ?flags clock creates a new timer file descriptor.
|
create [Iobuf] | create ~len creates a new iobuf, backed by a bigstring of length len ,
with the limits and window set to the entire bigstring.
|
create [Interval_intf.S] | |
create [Interval_intf.Gen_set] | |
create [Interval_intf.Gen] | create l u returns the interval with lower bound l and upper bound u , unless
l > u , in which case create returns the empty interval.
|
create [Unix.Resource_usage.Fields] | |
create [Thread] | Thread.create funct arg creates a new thread of control,
in which the function application funct arg
is executed concurrently with the other threads of the program.
|
create [Mutex] | |
create [Condition] | |
create [Command.Spec.Arg_type] |
an argument type includes information about how to parse values of that type from
the command line, and (optionally) how to auto-complete partial arguments of that
type via bash's programmable TAB-completion.
|
create_ending_after [Interval.Time] | create_ending_after ?zone (od1, od2) ~now returns the smallest interval (t1 t2)
with minimum t2 such that t2 >= now , to_ofday t1 = od1 , and to_ofday t2 =
od2 .
|
create_ending_before [Interval.Time] | create_ending_before ?zone (od1, od2) ~ubound returns the smallest interval (t1
t2) with maximum t2 such that t2 <= ubound , to_ofday t1 = od1 , and to_ofday
t2 = od2 .
|
create_exn [Timing_wheel_intf.S.Level_bits] |
In
create_exn bits , it is an error if any of the b_i in bits has b_i <= 0 ,
or if the sum of the b_i in bits is greater than max_num_bits .
|
create_exn [Lock_file.Nfs] | create_exn ?message path like create, but throws an exception when it fails to
obtain the lock
|
create_exn [Lock_file] | create_exn ?message path is like create except that it throws an exception on
failure instead of returning a boolean value
|
create_exn [Date0] | create_exn ~y ~m ~d creates the date specified in the arguments.
|
create_from_intervals [Interval_intf.Gen_set] | |
create_local [Ofday.Zoned] | |
create_process [Unix] | create_process ~prog ~args forks a new process that
executes the program prog with arguments args .
|
create_process_env [Unix] | |
critical_section [Nano_mutex] | |
critical_section [Mutex0] | |
critical_section [Lock_file.Nfs] | critical_section ?message ~timeout path ~f wrap function f (including exceptions
escaping it) by first locking (using Lock_file.Nfs.blocking_create ) and then unlocking the
given lock file.
|
critical_section [Mutex] | |
current_dir_name [Filename] |
The conventional name for the current directory (e.g.
|
current_thread_has_lock [Nano_mutex] | current_thread_has_lock t returns true iff the current thread has t locked.
|
D | |
daemonize [Daemon] | daemonize makes the executing process a daemon.
|
daemonize_wait [Daemon] | daemonize_wait makes the executing process a daemon, but delays full detachment
from the calling shell/process until the returned "release" closure is called.
|
data_segment [Unix.RLimit] | |
date [Command.Spec] | |
dates_between [Date0] | |
day [Span] | |
day [Date0] | |
day_of_week [Date0] | |
decr [Linux_ext.Priority] | |
default [Timing_wheel_intf.S.Config] | default is create () .
|
default [Timing_wheel_intf.S.Level_bits] | default returns the default value of level_bits used by Timing_wheel.create
and Timing_wheel.Priority_queue.create .
|
default_sys_behavior [Signal] | default_sys_behavior t
Query the default system behavior for a signal.
|
default_utc_offset_deprecated [Zone] | default_utc_offset returns the UTC offset of default regime for timezone t in
seconds.
|
delay [Thread] | delay d suspends the execution of the calling thread for
d seconds.
|
descr_of_in_channel [Unix] |
Return the descriptor corresponding to an input channel.
|
descr_of_out_channel [Unix] |
Return the descriptor corresponding to an output channel.
|
diff [Time_internal.T] | |
diff [Time_stamp_counter] | |
diff [Time] | diff t1 t2 returns time t1 minus time t2 .
|
diff [Ofday] | diff t1 t2 returns the difference in time between two ofdays, as if they occurred on
the same day
|
diff [Date0] | diff t1 t2 returns date t1 minus date t2 in days.
|
digest [Zone] | digest t return the MD5 digest of the file the t was created from (if any)
|
dir_sep [Filename] |
The directory separator (e.g.
|
dirfd [Unix] | |
dirname [Filename] |
See
Filename.basename .
|
does_match [Unix.Cidr] |
Is the given address inside the given Cidr.t? Note that the broadcast and network
addresses are considered valid so
does_match 10.0.0.0/8 10.0.0.0 is true.
|
domain_of_sockaddr [Unix] |
Return the socket domain adequate for the given socket address.
|
drop [Unix.IOVec] | drop iovec n drops n characters from iovec .
|
dsync [Unix.Open_flags] | |
dup [Unix] |
Return a new file descriptor referencing the same file as
the given descriptor.
|
dup2 [Unix] | dup2 fd1 fd2 duplicates fd1 to fd2 , closing fd2 if already
opened.
|
durations [Timing_wheel_intf.S.Config] | durations t returns the durations of the levels in t
|
E | |
empty [Interval_intf.Gen] | |
empty [Unix.IOVec] | empty the empty I/O-vector.
|
empty [Unix.Select_fds] | |
empty [Command.Spec] |
the empty command-line spec
|
end_of_day [Ofday] | |
endpwent [Unix.Passwd.Low_level] | |
env_of_sexp [Unix] | create_process_env ~prog ~args ~env as create process, but takes an additional
parameter that extends, or replaces the current environment.
|
environment [Unix] |
Return the process environment, as an array of strings
with the format ``variable=value''.
|
epoch [Time0.Stable.V1] | |
epoch [Time] | |
epsilon [Span] | |
equal [Signal] | |
equal [Nano_mutex] | equal is phys_equal
|
equal [Mutex0] | |
equal [Linux_ext.Priority] | |
equal [Mutex] | |
equal [Condition] | |
err [Linux_ext.Epoll.Flags] | |
error_message [Unix] |
Return a string describing the given error code.
|
error_of_sexp [Unix.Exit_or_signal_or_stop] | |
error_of_sexp [Unix.Exit_or_signal] | |
error_of_sexp [Unix.Exit] | |
error_of_sexp [Unix] | |
escape [Command.Deprecated.Spec] | |
escape [Command.Spec] | escape flags may be passed at most once.
|
establish_server [Unix] |
Establish a server on the given address.
|
et [Linux_ext.Epoll.Flags] | |
excl [Unix.Open_flags] | |
exec [Unix] | exec ~prog ~args ?search_path ?env execs prog with args .
|
executable_name [Sys] |
The name of the file containing the executable currently running.
|
execution_mode [Sys] | execution_mode tests whether the code being executed was compiled natively
or to bytecode.
|
exists [Unix.Resource_usage.Fields] | |
exit [Thread] |
Terminate prematurely the currently executing thread.
|
exit_immediately [Unix] | exit_immediately exit_code immediately calls the exit system call with the given
exit code without performing any other actions (unlike Pervasives.exit).
|
F | |
fchmod [Unix] |
Change the permissions of an opened file.
|
fchown [Unix] |
Change the owner uid and owner gid of an opened file.
|
fcntl_getfl [Unix] | fcntl_getfl fd gets the current flags for fd from the open-file-descriptor table
via the system call fcntl(fd, F_GETFL) .
|
fcntl_setfl [Unix] | fcntl_setfl fd flags sets the flags for fd in the open-file-descriptor table via
the system call fcntl(fd, F_SETFL, flags) .
|
fdatasync [Unix] |
Synchronize the kernel buffers of a given file descriptor with disk,
but do not necessarily write file attributes.
|
file [Command.Spec] | |
file_descr_realpath [Linux_ext] | file_descr_realpath fd
|
file_exists [Sys] | file_exists ~follow_symlinks path
|
file_exists_exn [Sys] |
Same as
file_exists but blows up on `Unknown
|
file_kind_of_sexp [Unix] | |
file_perm_of_sexp [Unix] |
The type of file access rights.
|
file_size [Unix.RLimit] | |
fill_bin_prot [Iobuf] | fill_bin_prot writes a bin-prot value to the lower bound of the window, prefixed by
its length, and advances by the amount written.
|
finalize_release [Gc.Expert] |
The runtime essentially maintains a bool ref:
|
find [Zone] | find name looks up a t by its name and returns it.
|
find [Weak_hashtbl] | |
find [Linux_ext.Epoll] |
map operations
|
find_exn [Zone] | |
find_exn [Linux_ext.Epoll] | |
find_office [Zone] | find_office office a more type-safe interface for pulling timezones related to
existing Jane Street offices/locations.
|
find_or_add [Weak_hashtbl] | |
first_strictly_after [Date0] | first_strictly_after t ~on:day_of_week returns the first occurrence of day_of_week
strictly after t .
|
flag [Command.Spec] | flag name spec ~doc specifies a command that, among other things, takes a flag
named name on its command line.
|
flags_of_args_exn [Command.Spec] | flags_of_args_exn args creates a spec from Arg.t s, for compatibility with
ocaml's base libraries.
|
flip_hi [Iobuf] | flip_hi t sets the window to range from the the upper bound of the current window to
the upper limit.
|
flip_lo [Iobuf] | flip_lo t sets the window to range from the lower limit to the lower bound of the
old window.
|
float [Command.Spec] | |
float_of_hh_mm_ss [Time_internal] | |
flock [Unix] | flock fd cmd places or releases a lock on the fd as per the flock C call of the same
name.
|
flow_action_of_sexp [Unix.Terminal_io] | |
flush_queue_of_sexp [Unix.Terminal_io] | |
fnmatch [Unix] | |
fold [Unix.Resource_usage.Fields.Direct] | |
fold [Unix.Resource_usage.Fields] | |
fold_dir [Sys] | |
fold_ready [Linux_ext.Epoll] | |
following_weekday [Date0] | |
for_all [Unix.Resource_usage.Fields] | |
for_this_process [User_and_group] |
Get the
t for the current process.
|
for_this_process_exn [User_and_group] | |
fork [Unix] | fork () forks a new process.
|
fork_exec [Unix] | fork_exec ~prog ~args ?use_path ?env () forks and execs prog with args in the
child process, returning the child pid to the parent.
|
format [Time0.Stable.V1] | |
format [Time] | format t fmt formats the given time according to fmt, which follows the formatting
rules given in 'man strftime'.
|
format [Date] |
This formats a date using the format patterns available in
strftime
|
fpe [Signal] | Dump_core Arithmetic exception
|
fstat [Unix.Native_file] |
Return the information for the file associated with the given
descriptor.
|
fstat [Unix] |
Return the information for the file associated with the given
descriptor.
|
fsync [Unix] | |
ftruncate [Unix.Native_file] | |
ftruncate [Unix] |
Truncates the file corresponding to the given descriptor
to the given size.
|
G | |
get [Piecewise_linear_intf.S] | get t x evaluates the piecewise linear function t at x .
|
get [Linux_ext.Timerfd] | get t returns the current state of the timer t .
|
get [Linux_ext.Clock] | |
get [Unix.Resource_usage] | |
get [Unix.RLimit] | |
get [Backtrace] | |
get_flag_names [Command.Deprecated] | |
get_hostname_and_pid [Lock_file.Nfs] | get_hostname_and_pid path reads the lock file at path and returns the hostname
and path in the file.
|
get_inverse [Piecewise_linear_intf.S_invertible] | get_inverse t value is the inverse operation of get t key .
|
get_ipv4_address_for_interface [Linux_ext] | |
get_mcast_loop [Unix] | get_mcast_loop sock reads the boolean argument that determines whether sent
multicast packets are looped back to local sockets.
|
get_mcast_ttl [Unix] | get_mcast_ttl sock reads the time-to-live value of outgoing multicast packets for
socket sock .
|
get_message [Lock_file.Nfs] | get_message path reads the lock file at path and returns the message in the
file.
|
get_opt [Backtrace] | get_opt () returns a backtrace if get is implemented.
|
get_process_clock [Linux_ext.Clock] | get_process_clock the clock measuring the CPU-time of a process.
|
get_resolution [Linux_ext.Clock] | |
get_sockaddr [Unix] |
Get a sockaddr from a hostname or IP, and a port
|
get_terminal_size [Linux_ext] | get_terminal_size ()
|
get_thread_clock [Linux_ext.Clock] | get_thread_clock the clock measuring the CPU-time of the current thread.
|
get_time [Linux_ext.Clock] | |
getaddrinfo [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.
|
getaddrinfo_option_of_sexp [Unix] |
Options to
Unix.getaddrinfo .
|
getbyaddr [Unix.Host] |
Find an entry in
hosts with the given address.
|
getbyaddr_exn [Unix.Host] | |
getbygid [Unix.Group] | |
getbygid_exn [Unix.Group] | |
getbyname [Unix.Service] |
Find an entry in
services with the given name.
|
getbyname [Unix.Protocol] |
Find an entry in
protocols with the given name.
|
getbyname [Unix.Host] |
Find an entry in
hosts with the given name.
|
getbyname [Unix.Group] | |
getbyname [Unix.Passwd] | |
getbyname_exn [Unix.Service] | |
getbyname_exn [Unix.Protocol] | |
getbyname_exn [Unix.Host] | |
getbyname_exn [Unix.Group] | |
getbyname_exn [Unix.Passwd] | |
getbynumber [Unix.Protocol] |
Find an entry in
protocols with the given protocol number.
|
getbynumber_exn [Unix.Protocol] | |
getbyport [Unix.Service] |
Find an entry in
services with the given service number.
|
getbyport_exn [Unix.Service] | |
getbyuid [Unix.Passwd] | |
getbyuid_exn [Unix.Passwd] | |
getcwd [Unix] |
Return the name of the current working directory.
|
getcwd [Sys] |
Return the current working directory of the process.
|
getegid [Unix] |
Return the effective group id under which the process runs.
|
getenv [Sys] |
Return the value associated to a variable in the process environment.
|
getenv_exn [Sys] | |
geteuid [Unix] |
Return the effective user id under which the process runs.
|
getgid [Unix] |
Return the group id of the user executing the process.
|
getgrouplist [Unix] | getgrouplist user group returns the list of groups to which user belongs.
|
getgroups [Unix] |
Return the list of groups to which the user executing the process belongs.
|
gethostname [Unix] |
Return the name of the local host.
|
getitimer [Unix] |
Return the current status of the given interval timer.
|
getlogin [Unix] |
Return the login name of the user executing the process.
|
getnameinfo [Unix] | getnameinfo addr opts returns the host name and service name
corresponding to the socket address addr .
|
getnameinfo_option_of_sexp [Unix] |
Options to
Unix.getnameinfo .
|
getpeername [Unix] |
Return the address of the host connected to the given socket.
|
getpid [Unix] |
Return the pid of the process.
|
getppid [Unix] |
Return the pid of the parent process.
|
getppid_exn [Unix] |
Return the pid of the parent process, if you're really sure
you're never going to be the init process.
|
getpriority [Linux_ext] |
Get the calling thread's priority in the linux scheduler
|
getpwent [Unix.Passwd.Low_level] | |
getpwent_exn [Unix.Passwd.Low_level] | |
getpwents [Unix.Passwd] | getpwents is a thread-safe wrapper over the low-level passwd database
functions.
|
getsockname [Unix] |
Return the address of the given socket.
|
getsockopt [Unix] | |
getsockopt_float [Unix] |
Same as
UnixLabels.getsockopt for a socket option whose value is a floating-point
number.
|
getsockopt_int [Unix] |
Same as
UnixLabels.getsockopt for an integer-valued socket option.
|
getsockopt_optint [Unix] |
Same as
UnixLabels.getsockopt for a socket option whose value is an int option .
|
gettcpopt_bool [Linux_ext] | gettcpopt_bool sock opt
|
gettid [Linux_ext] | |
gettimeofday [Unix] |
Same as
Unix.time above, but with resolution better than 1 second.
|
getuid [Unix] |
Return the user id of the user executing the process.
|
gmtime [Unix] |
Convert a time in seconds, as returned by
UnixLabels.time , into a date and
a time.
|
group [User_and_group] | |
group [Command] | group ~summary subcommand_alist is a compound command with named
subcommands, as found in subcommand_alist .
|
H | |
half_open_intervals_are_a_partition [Interval_intf.Gen] | |
handle [Signal.Expert] | handle t f is set t (`Handle f) .
|
handle_default [Signal] | handle_default t is set t `Default .
|
handle_unix_error [Unix] | handle_unix_error f runs f () and returns the result.
|
have_address_in_common [Unix.Host] | |
help [Command.Spec] |
the help text for the command
|
help_recursive [Command.Deprecated] | |
hour [Span] | |
hup [Signal] | Terminate Hangup on controlling terminal
|
hup [Linux_ext.Epoll.Flags] | |
I | |
id [Thread] |
Return the identifier of the given thread.
|
idrss [Unix.Resource_usage.Fields] | |
idrss [Unix.Resource_usage] | |
if_indextoname [Unix] | |
ignore [Signal] | ignore t is set t `Ignore .
|
ill [Signal] | Dump_core Invalid hardware instruction
|
in_ [Linux_ext.Epoll.Flags] | |
in_channel_of_descr [Unix] |
Create an input channel reading from the given descriptor.
|
in_channel_realpath [Linux_ext] | in_channel_realpath ic
|
inblock [Unix.Resource_usage.Fields] | |
inblock [Unix.Resource_usage] | |
incr [Linux_ext.Priority] | |
increase_min_allowed_key [Timing_wheel_intf.S.Priority_queue] | increase_min_allowed_key t ~key ~handle_removed increases the minimum allowed
key in t to key , and removes all elements with keys less than key , applying
handle_removed to each element that is removed.
|
inet4_addr_of_int32 [Unix.Inet_addr] |
Some things (like the kernel) report addresses as hex or decimal strings.
|
inet4_addr_to_int32_exn [Unix.Inet_addr] | inet4_addr_to_int32_exn t = 0l when t = Inet_addr.of_string ("0.0.0.0") .
|
init [Zone] | init () pre-load all available time zones from disk, this function has no effect if
it is called multiple times.
|
initgroups [Unix] | |
initialized_zones [Zone] | initialized_zones () returns a sorted list of time zone names that have been loaded
from disk thus far.
|
input [Bigstring] | input ?min_len ic ?pos ?len bstr tries to read len bytes
(guarantees to read at least min_len bytes (must be greater than
or equal to zero and smaller or equal to len ), if possible, before
returning) from input channel ic , and writes them to bigstring
bstr starting at position pos .
|
int [Signal] | Terminate Interactive interrupt (ctrl-C)
|
int [Command.Spec] | |
int16_be [Iobuf_intf.Accessors] | |
int16_le [Iobuf_intf.Accessors] | |
int32_be [Iobuf_intf.Accessors] | |
int32_le [Iobuf_intf.Accessors] | |
int64_be [Iobuf_intf.Accessors] | |
int64_le [Iobuf_intf.Accessors] | |
int64_t_be [Iobuf_intf.Accessors] | |
int64_t_le [Iobuf_intf.Accessors] | |
int8 [Iobuf_intf.Accessors] | |
interactive [Sys] |
This reference is initially set to
false in standalone programs and to
true if the code is being executed under the interactive toplevel system
ocaml .
|
interruptible_pause [Time0.Stable.V1] |
Pause but allow events to interrupt.
|
interruptible_pause [Time] | interruptible_pause span sleeps for span time unless interrupted (e.g.
|
intersect [Interval_intf.Gen] | |
interval_num [Timing_wheel_intf.S] | interval_num t time returns the number of the interval that time is in, where
0 is the interval that starts at start .
|
interval_num_start [Timing_wheel_intf.S] | interval_num_start t n is the start of the n 'th interval in t , i.e.:
|
interval_start [Timing_wheel_intf.S] | |
interval_timer_of_sexp [Unix] |
The three kinds of interval timers.
|
interval_timer_status_of_sexp [Unix] |
The type describing the status of an interval timer
|
invariant [Timing_wheel_intf.S.Priority_queue.Elt] | |
invariant [Nano_mutex] | |
invariant [Linux_ext.Epoll] | |
is_absolute [Filename] | |
is_business_day [Date0] | |
is_directory [Sys] |
Returns
`Yes if the file exists and is a directory
|
is_directory_exn [Sys] | |
is_empty [Timing_wheel_intf.S.Priority_queue] | is_empty t is length t = 0
|
is_empty [Timing_wheel_intf.S] |
One can think of a timing wheel as a set of alarms.
|
is_empty [Iobuf] | is_empty t is length t = 0 .
|
is_empty [Interval_intf.Gen] | |
is_empty_or_singleton [Interval_intf.Gen] | |
is_file [Sys] |
Returns
`Yes if the file exists and is a regular file
|
is_file_exn [Sys] | |
is_implicit [Filename] |
Return
true if the file name is relative and does not start
with an explicit reference to the current directory (./ or
../ in Unix), false if it starts with an explicit reference
to the root directory or the current directory.
|
is_locked [Lock_file] | is_locked path returns true when the file at path exists and is locked, false
otherwise.
|
is_posix_pathname_component [Filename] | is_posix_pathname_component f
|
is_relative [Filename] |
Return
true if the file name is relative to the current
directory, false if it is absolute (i.e.
|
is_subset [Interval_intf.Gen] | |
is_superset [Interval_intf.Gen] | is_superset i1 of_:i2 is whether i1 contains i2.
|
is_weekday [Date0] | |
is_weekend [Date0] | |
isatty [Unix] |
Return
true if the given file descriptor refers to a terminal or
console window, false otherwise.
|
isrss [Unix.Resource_usage.Fields] | |
isrss [Unix.Resource_usage] | |
iter [Timing_wheel_intf.S.Priority_queue] | |
iter [Timing_wheel_intf.S] | |
iter [Linux_ext.Epoll] | |
iter [Unix.Resource_usage.Fields.Direct] | |
iter [Unix.Resource_usage.Fields] | |
iter_ready [Linux_ext.Epoll] | iter_ready and fold_ready iterate over the ready set computed by the last
call to wait .
|
ixrss [Unix.Resource_usage.Fields] | |
ixrss [Unix.Resource_usage] | |
J | |
join [Thread] | join th suspends the execution of the calling thread
until the thread th has terminated.
|
K | |
key [Timing_wheel_intf.S.Priority_queue.Elt] | |
key [Timing_wheel_intf.S.Alarm] | |
key_is_using_space [Weak_hashtbl] | key_is_using_space t key returns true if key is using some space in t .
|
kill [Signal] | Terminate Termination (cannot be ignored)
|
L | |
lbound [Interval_intf.Gen_set] | |
lbound [Interval_intf.Gen] | |
lbound_exn [Interval_intf.Gen_set] | |
lbound_exn [Interval_intf.Gen] | |
length [Timing_wheel_intf.S.Priority_queue] | length t returns the number of elements in the timing wheel.
|
length [Timing_wheel_intf.S] | |
length [Squeue] |
returns the number of elements in the queue.
|
length [Iobuf] | length t returns the size of t 's window.
|
level_bits [Timing_wheel_intf.S.Config] | |
likely_machine_zones [Zone] | likely_machine_zones is a list of zone names that will be searched first when trying
to determine the machine zone of a box.
|
limit [Iobuf_intf.Bound] | |
limit_of_sexp [Unix.RLimit] | |
link [Unix] | link ?force ~target ~link_name () creates a hard link named link_name
to the file named target .
|
list_intersect [Interval_intf.Gen] |
Assuming that
ilist1 and ilist2 are lists of (disjoint) intervals,
list_intersect ilist1 ilist2 returns the list of disjoint intervals that
correspond to the intersection of ilist1 with ilist2 .
|
listed [Command.Spec] | listed flags may be passed zero or more times
|
listen [Unix] |
Set up a socket for receiving connection requests.
|
localhost [Unix.Inet_addr] |
Special addresses representing the host machine.
|
localhost_inet6 [Unix.Inet_addr] | |
localtime [Unix] |
Convert a time in seconds, as returned by
UnixLabels.time , into a date and
a time.
|
lock [Nano_mutex] | lock t locks the mutex t , blocking until it can be locked.
|
lock [Mutex] | lock mtx locks mtx , possibly waiting for it to be released
first by another thread.
|
lock_command_of_sexp [Unix] |
Commands for
Unix.lockf .
|
lock_exclusive [Unix.Flock_command] | |
lock_exn [Nano_mutex] | |
lock_shared [Unix.Flock_command] | |
lockf [Unix] | |
lpop [Squeue] |
returns the element popped and the length of the queue after
* this element was popped.
|
ls_dir [Sys] |
Same as
readdir , but return a list rather than an array.
|
lseek [Unix.Native_file] | |
lseek [Unix] | |
lstat [Unix.Native_file] |
Same as
UnixLabels.stat , but in case the file is a symbolic link,
return the information for the link itself.
|
lstat [Unix] |
Same as
UnixLabels.stat , but in case the file is a symbolic link,
return the information for the link itself.
|
M | |
machine [Unix.Utsname] | |
machine_zone [Zone] | machine_zone ?refresh () returns the machines zone (t).
|
majflt [Unix.Resource_usage.Fields] | |
majflt [Unix.Resource_usage] | |
make_creator [Unix.Resource_usage.Fields] | |
map [Interval_intf.Gen] | map t ~f returns create (f l) (f u) if bounds t = Some (l, u) , and empty if
t is empty.
|
map [Unix.Resource_usage.Fields] | |
map [Command.Spec] |
parameter transformation
|
map_anons [Command.Spec] | map_anons anons ~f transforms the parsed result of anons by applying f
|
map_flag [Command.Spec] | map_flag flag ~f transforms the parsed result of flag by applying f
|
map_poly [Unix.Resource_usage.Fields] | |
marshal_to_fd [Bigstring_marshal] | marshal_to_fd ?buf fd v marshals data v to file descriptor fd
using marshalling buffer buf , and marshalling flags flags .
|
marshal_to_sock_no_sigpipe [Bigstring_marshal] | marshal_to_sock_no_sigpipe ?buf sock v same as Bigstring_marshal.marshal_to_fd , but
writes to sockets only and uses Bigstring.really_send_no_sigpipe
to avoid SIGPIPE on sockets.
|
max_allowed_key [Timing_wheel_intf.S.Priority_queue] | max_allowed_key t is the maximum allowed key that can be stored in t .
|
max_iovecs [Unix.IOVec] | |
max_num_bits [Timing_wheel_intf.S.Level_bits] | |
max_representable_key [Timing_wheel_intf.S.Priority_queue] |
To avoid issues with arithmetic overflow, the implementation restricts keys to
being between
0 and max_representable_key , where:
|
maxrss [Unix.Resource_usage.Fields] | |
maxrss [Unix.Resource_usage] | |
maybe [Command.Spec] | (maybe anons) indicates that some anonymous arguments are optional
|
maybe_with_default [Command.Spec] | (maybe_with_default default anons) indicates an optional anonymous
argument with a default value
|
mcast_join [Unix] | mcast_join ?ifname sock addr join a multicast group at addr
with socket sock , optionally using network interface ifname .
|
mcast_leave [Unix] | mcast_leave ?ifname sock addr leaves a multicast group at addr
with socket sock , optionally using network interface ifname .
|
mem [Timing_wheel_intf.S.Priority_queue] | |
mem [Timing_wheel_intf.S] | |
mem [Weak_hashtbl] | |
memmove [Iobuf] | memmove blits len bytes from src_pos to dst_pos in an iobuf, both relative to
the lower bound of the window.
|
microsecond [Span] | |
millisecond [Span] | |
min_allowed_key [Timing_wheel_intf.S.Priority_queue] | min_allowed_key t is the minimum key that can be stored in t .
|
min_elt [Timing_wheel_intf.S.Priority_queue] | min_elt t returns an element in t that has the minimum key, if t is
nonempty.
|
min_key [Timing_wheel_intf.S.Priority_queue] | |
minflt [Unix.Resource_usage.Fields] | |
minflt [Unix.Resource_usage] | |
minute [Span] | |
mkdir [Unix] |
Create a directory.
|
mkdir_p [Unix] |
Create a directory recursively.
|
mkdtemp [Unix] | mkdtemp prefix creates a temporary directory with prefix ,
automatically appending a suffix of six random characters to make
the name unique.
|
mkfifo [Unix] |
Create a named pipe with the given permissions.
|
mknod [Unix] | mknod ?file_kind ?perm ?major ?minor path creates a filesystem
entry.
|
mkstemp [Unix] | mkstemp prefix creates and opens a unique temporary file with prefix ,
automatically appending a suffix of six random characters to make the name unique.
|
mktime [Unix] |
Convert a date and time, specified by the
tm argument, into
a time in seconds, as returned by UnixLabels.time .
|
mlockall [Unix.Mman] | |
monotonic [Linux_ext.Timerfd.Clock] |
Nonsettable clock.
|
month [Date0] | |
most_recent [Backtrace.Exn] | most_recent () returns a string containing the stack that was unwound by the
most recently raised exception.
|
msg_flag_of_sexp [Unix] |
The flags for
UnixLabels.recv , UnixLabels.recvfrom ,
UnixLabels.send and UnixLabels.sendto .
|
msgrcv [Unix.Resource_usage.Fields] | |
msgrcv [Unix.Resource_usage] | |
msgsnd [Unix.Resource_usage.Fields] | |
msgsnd [Unix.Resource_usage] | |
multicast [Unix.Cidr] |
IPv4 multicast address can be represented by the CIDR prefix 224.0.0.0/4,
(i.e.
|
munlockall [Unix.Mman] | |
N | |
name [Zone] | name zone returns the name of the time zone
|
name_info_of_sexp [Unix] |
Host and service information returned by
Unix.getnameinfo .
|
names [Unix.Resource_usage.Fields] | |
nanosecond [Span] | |
nanosleep [Unix] | nanosleep f delays execution of the program for at least f seconds.
|
narrow [Iobuf] | narrow t sets t 's limits to the current window.
|
neg [Span] |
negation
|
next_alarm_fires_at [Timing_wheel_intf.S] | next_alarm_fires_at t returns the minimum time to which the clock can be advanced
such that an alarm will fire, or None if t has no alarms.
|
next_clock_shift [Zone] |
Takes a
Time.t and returns the next Time.t , if any, that the time zone UTC offset
changes, and by how much it does so.
|
next_multiple [Time0.Stable.V1] | |
next_multiple [Time] | |
nice [Unix.Priority] | |
nice [Unix.RLimit] | |
nice [Unix] |
Change the process priority.
|
nivcsw [Unix.Resource_usage.Fields] | |
nivcsw [Unix.Resource_usage] | |
no_arg [Command.Deprecated.Spec] | |
no_arg [Command.Spec] | no_arg flags may be passed at most once.
|
no_arg_abort [Command.Spec] | no_arg_abort ~exit is like no_arg , but aborts command-line parsing
by calling exit .
|
no_arg_register [Command.Spec] | no_arg_register ~key ~value is like no_arg , but associates value
with key in the in the auto-completion environment
|
noctty [Unix.Open_flags] | |
nodename [Unix.Utsname] | |
nonblock [Linux_ext.Timerfd.Flags] | TFD_NONBLOCK
|
nonblock [Unix.Open_flags] | |
none [Linux_ext.Epoll.Flags] | |
now [Timing_wheel_intf.S] | |
now [Time_internal.T] | |
now [Time_stamp_counter] | |
now [Time.Ofday] | |
now [Time] | |
now_interval_num [Timing_wheel_intf.S] | |
nsignals [Unix.Resource_usage.Fields] | |
nsignals [Unix.Resource_usage] | |
nswap [Unix.Resource_usage.Fields] | |
nswap [Unix.Resource_usage] | |
num_bits [Timing_wheel_intf.S.Level_bits] | num_bits t is the sum of the b_i in t .
|
num_file_descriptors [Unix.RLimit] | |
num_threads [Thread] | num_threads () attempts to return the number of currently running
threads by parsing /proc.
|
nvcsw [Unix.Resource_usage.Fields] | |
nvcsw [Unix.Resource_usage] | |
O | |
ocaml_version [Sys] | ocaml_version is the version of Objective Caml.
|
occurrence [Time0.Stable.V1] | |
occurrence [Time] | occurrence side time ~ofday ~zone returns a Time.t that is the occurrence of ofday
(in the given zone ) that is the latest occurrence (<=) time or the earliest
occurrence (>=) time , according to side .
|
of_alist_exn [Command.Spec.Arg_type] |
convenience wrapper for
of_map .
|
of_bigstring [Iobuf] | of_bigstring bigstring ~pos ~len returns an iobuf backed by bigstring , with the
window and limits specified starting at pos and of length len .
|
of_bigstring [Unix.IOVec] | of_bigstring ?pos ?len bstr
|
of_caml_int [Signal] | of_caml_int constructs a Signal.t given an O'Caml internal signal number.
|
of_code [Unix.Exit] | |
of_date_ofday [Time0.Stable.V1] | |
of_date_ofday [Time] | |
of_date_ofday_precise [Time0.Stable.V1] | |
of_date_ofday_precise [Time] |
Because timezone offsets change throughout the year (clocks go forward or back) some
local times can occur twice or not at all.
|
of_day [Span] | |
of_epoch [Time0.Stable.V1] | |
of_epoch_internal [Time0.Stable.V1] | |
of_filename_string [Time0.Stable.V1] | |
of_filename_string [Time] | of_filename_string s converts s that has format YYYY-MM-DD_HH-MM-SS.mmm into
time
|
of_hr [Span] | |
of_int [Linux_ext.Priority] | |
of_int [Unix.File_descr] | |
of_int_sec [Span] | |
of_local_date_ofday [Time0.Stable.V1] | |
of_local_date_ofday [Time] | |
of_localized_string [Time0.Stable.V1] | |
of_localized_string [Time] | of_localized_string zone str read in the given string assuming that it represents
a time in zone and return the appropriate Time.t
|
of_map [Command.Spec.Arg_type] |
an auto-completing Arg_type over a finite set of values
|
of_min [Span] | |
of_ms [Span] | |
of_ns [Time_stamp_counter.Span] | |
of_ns [Span] | |
of_sec [Span] | |
of_span_since_start_of_day [Ofday] | |
of_string [Time0.Stable.V1] | |
of_string [Span] | |
of_string [Iobuf] | of_string s returns a new iobuf whose contents are s .
|
of_string [Unix.IOVec] | of_string ?pos ?len str
|
of_string [Unix.Inet_addr] |
Conversion from the printable representation of an Internet address to its internal
representation.
|
of_string_abs [Time0.Stable.V1] | |
of_string_abs [Time] | of_string_abs s is like of_string , but demands that s indicate the timezone the
time is expressed in.
|
of_string_fix_proto [Time0.Stable.V1] | |
of_string_fix_proto [Time] | |
of_string_gen [Time0.Stable.V1] | |
of_string_iso8601_basic [Date0] | |
of_string_iso8601_extended [Ofday] | |
of_string_or_getbyname [Unix.Inet_addr] |
Call
of_string and if that fails, use Host.getbyname .
|
of_system_int [Signal] | of_system_int and to_system_int return and take respectively a signal number
corresponding to those in the system's /usr/include/bits/signum.h (or equivalent).
|
of_system_int [Unix.Error] | |
of_time [Date] | |
of_tm [Date0] | |
of_unix [Unix.Exit_or_signal_or_stop] | of_unix assumes that any signal numbers in the incoming value are O'Caml internal
signal numbers.
|
of_unix [Unix.Exit_or_signal] | of_unix assumes that any signal numbers in the incoming value are O'Caml internal
signal numbers.
|
of_us [Span] | |
of_utc_offset [Zone] | of_utc_offset offset returns a timezone with a static UTC offset (given in
hours).
|
ofday [Ofday.Zoned] | |
offset_string [Time0.Stable.V1] | |
oneshot [Linux_ext.Epoll.Flags] | |
open_connection [Unix] |
Connect to a server at the given address.
|
open_flag_of_sexp [Unix] | |
open_process [Unix] |
See
UnixLabels.open_process_in .
|
open_process_full [Unix] | |
open_process_in [Unix] |
High-level pipe and process management.
|
open_process_out [Unix] |
See
UnixLabels.open_process_in .
|
open_temp_file [Filename] |
Same as
Filename.temp_file , but returns both the name of a fresh
temporary file, and an output channel opened (atomically) on
this file.
|
opendir [Unix] |
Open a descriptor on a directory
|
openfile [Unix] |
Open the named file with the given flags.
|
optional [Command.Spec] |
optional flags may be passed at most once
|
optional_with_default [Command.Spec] | optional_with_default flags may be passed at most once, and
default to a given value
|
or_error [Unix.Exit_or_signal_or_stop] | |
or_error [Unix.Exit_or_signal] | |
or_error [Unix.Exit] | |
os_type [Sys] |
Operating system currently executing the Caml program.
|
oublock [Unix.Resource_usage.Fields] | |
oublock [Unix.Resource_usage] | |
out [Linux_ext.Epoll.Flags] | |
out_channel_of_descr [Unix] |
Create an output channel writing on the given descriptor.
|
out_channel_realpath [Linux_ext] | out_channel_realpath oc
|
output [Bigstring] | output ?min_len oc ?pos ?len bstr tries to output
len bytes (guarantees to write at least min_len bytes (must be
equal to or greater than zero), if possible, before returning) from
bigstring bstr starting at position pos to output channel oc .
|
output_buffer [Bigbuffer] | output_buffer oc b writes the current contents of buffer b
on the output channel oc .
|
P | |
padded_fixed_string [Iobuf_intf.Accessors] | |
parent_dir_name [Filename] |
The conventional name for the parent of the current directory
(e.g.
|
parse_four_digits [Time_internal.Helpers] | |
parse_ssh_client [Process_env] | parse_ssh_client reads the SSH_CLIENT environment variable, retrieving the IP from
which you are currently sshing.
|
parse_two_digits [Time_internal.Helpers] | |
parts [Filename] | parts filename returns a list of path components in order.
|
path [Command.Spec] |
the subcommand path of the command
|
pause [Time0.Stable.V1] |
Pause and don't allow events to interrupt.
|
pause [Time] | pause span sleeps for span time.
|
pause [Unix] |
Wait until a non-ignored, non-blocked signal is delivered.
|
pause_for [Time0.Stable.V1] | |
pause_forever [Time0.Stable.V1] | |
pause_forever [Time] | pause_forever sleeps indefinitely.
|
phys_equal [Mutex0] | |
pipe [Signal] | Terminate Broken pipe
|
pipe [Unix] |
Create a pipe.
|
pop [Squeue] |
pops an element off the queue, blocking until something is
* available
|
pr_get_name [Linux_ext] | pr_get_name () gets the name of the executing thread.
|
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_name_first16 [Linux_ext] | pr_set_name_first16 name sets the name of the executing thread to name .
|
pr_set_pdeathsig [Linux_ext] | pr_set_pdeathsig s sets the signal s to be sent to the executing
process when its parent dies.
|
pread_assume_fd_is_nonblocking [Iobuf] | |
pread_assume_fd_is_nonblocking [Bigstring] | pread_assume_fd_is_nonblocking fd ~offset ?pos ?len bstr reads up to len bytes
from file descriptor fd at offset offset , and writes them to bigstring bstr
starting at position pos .
|
previous_weekday [Date0] | |
pri [Linux_ext.Epoll.Flags] | |
process_times_of_sexp [Unix] |
The execution times (CPU times) of a process.
|
prof [Signal] | Terminate Profiling interrupt
|
pselect [Unix] | pselect rfds wfds efds timeout sigmask like Unix.select but
also allows one to wait for the arrival of signals.
|
push [Squeue] |
Blocks until there's room on the queue, then pushes.
|
push_or_drop [Squeue] |
Pushes an event on the queue if the queue is less than maxsize, otherwise drops it.
|
push_uncond [Squeue] |
Does not block, may grow the queue past maxsize
|
putenv [Unix] | Unix.putenv ~key ~data sets the value associated to a
variable in the process environment.
|
pwrite_assume_fd_is_nonblocking [Iobuf] | |
pwrite_assume_fd_is_nonblocking [Bigstring] | pwrite_assume_fd_is_nonblocking fd ~offset ?pos ?len bstr writes up to len bytes
of bigstring bstr starting at position pos to file descriptor fd at position
offset .
|
Q | |
quit [Signal] | Dump_core Interactive termination
|
quote [Filename] |
Return a quoted version of a file name, suitable for use as
one argument in a command line, escaping all meta-characters.
|
R | |
randomize [Span] | randomize t ~percent returns a span +/- percent * original span.
|
rdonly [Unix.Open_flags] |
access mode.
|
rdwr [Unix.Open_flags] | |
read [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 ?min_len fd ?pos ?len bstr reads at least min_len (must be
greater than or equal zero) and at most len (must be greater than
or equal to min_len ) bytes from file descriptor fd , and writes
them to bigstring bstr starting at position pos .
|
read_assume_fd_is_nonblocking [Iobuf] | Iobuf has analogs of various Bigstring functions.
|
read_assume_fd_is_nonblocking [Unix] | read_assume_fd_is_nonblocking fd ?pos ?len buf calls the system call
read ASSUMING THAT IT IS NOT GOING TO BLOCK.
|
read_assume_fd_is_nonblocking [Bigstring] | read_assume_fd_is_nonblocking fd ?pos ?len bstr reads up to
len bytes into bigstring bstr starting at position pos from
file descriptor fd without yielding to other OCaml-threads.
|
readdir [Unix] |
Return the next entry in a directory.
|
readdir [Sys] |
Return the names of all files present in the given directory.
|
readdir_ino [Unix] | readdir_ino dh return the next entry in a directory (((filename,
inode) ).
|
readlink [Unix] |
Read the contents of a link.
|
really_input [Bigstring] | really_input ic ?pos ?len bstr reads exactly len bytes from
input channel ic , and writes them to bigstring bstr starting at
position pos .
|
really_output [Bigstring] | really_output oc ?pos ?len bstr outputs exactly len
bytes from bigstring bstr starting at position pos to output
channel oc .
|
really_read [Bigstring] | really_read fd ?pos ?len bstr reads len bytes from file descriptor
fd , and writes them to bigstring bstr starting at position pos .
|
really_recv [Bigstring] | really_recv sock ?pos ?len bstr receives len bytes from socket
sock , and writes them to bigstring bstr starting at position
pos .
|
really_send_no_sigpipe [Bigstring] | really_send_no_sigpipe sock ?pos ?len bstr sends len bytes in
bigstring bstr starting at position pos to socket sock without
blocking and ignoring SIGPIPE .
|
really_write [Bigstring] | really_write fd ?pos ?len bstr writes len bytes in bigstring
bstr starting at position pos to file descriptor fd .
|
realpath [Filename] | realpath path
|
realtime [Linux_ext.Timerfd.Clock] |
Settable system-wide clock.
|
reclaim_space_for_keys_with_unused_data [Weak_hashtbl] | reclaim_space_for_keys_with_unused_data t reclaims space for all keys in t whose
data has been detected (by a finalizer) to be unused.
|
recv [Unix] |
Receive data from an unconnected socket.
|
recvfrom [Unix] |
Receive data from an unconnected socket.
|
recvfrom_assume_fd_is_nonblocking [Iobuf] | |
recvfrom_assume_fd_is_nonblocking [Bigstring] | recvfrom_assume_fd_is_nonblocking sock ?pos ?len bstr reads up to
len bytes into bigstring bstr starting at position pos from
socket sock without yielding to other OCaml-threads.
|
recvmmsg_assume_fd_is_nonblocking [Iobuf] | |
recvmmsg_assume_fd_is_nonblocking [Bigstring] | recvmmsg_assume_fd_is_nonblocking fd iovecs ~count ~lens receives up to count
messages into iovecs from file descriptor fd without yielding to other OCaml
threads.
|
recvmmsg_assume_fd_is_nonblocking_no_options [Iobuf] | |
release [Unix.Utsname] | |
remove [Timing_wheel_intf.S.Priority_queue] | remove t elt removes elt from t .
|
remove [Timing_wheel_intf.S] | remove t alarm removes alarm from t .
|
remove [Weak_hashtbl] | |
remove [Linux_ext.Epoll] | |
remove [Unix] |
Removes the named file or directory
|
remove [Sys] |
Remove the given file name from the file system.
|
rename [Unix] | rename old new changes the name of a file from old to new .
|
rename [Sys] |
Rename a file.
|
replace [Weak_hashtbl] | |
required [Command.Spec] |
required flags must be passed exactly once
|
reset [Iobuf] | reset t sets the window to the limits.
|
resize [Iobuf] | resize t sets the length of t 's window, provided it does not exceed limits.
|
resource_of_sexp [Unix.RLimit] | |
restore [Iobuf_intf.Bound] | |
retry_until_no_eintr [Unix] | retry_until_no_eintr f returns f () unless f () fails with EINTR ; in which
case f () is run again until it raises a different error or returns a value.
|
rewind [Iobuf] | rewind t sets the lower bound of the window to the lower limit.
|
rewinddir [Unix] |
Reposition the descriptor to the beginning of the directory
|
rmdir [Unix] |
Remove an empty directory.
|
root [Filename] |
The path of the root.
|
rsync [Unix.Open_flags] | |
run [Command.Deprecated] | |
run [Command] |
Run a command against
Sys.argv , or argv if it is specified.
|
S | |
scale [Span] | |
sched_setaffinity [Linux_ext] | |
sched_setaffinity_this_thread [Linux_ext] | |
sec [Std] | |
second [Span] | |
seek_command_of_sexp [Unix] |
POSITIONING modes for
UnixLabels.lseek .
|
segv [Signal] | Dump_core Invalid memory reference
|
select [Unix] |
Setting restart to true means that we want select to restart automatically
on EINTR (instead of propagating the exception)...
|
self [Thread] |
Return the thread currently executing.
|
send [Signal] | send signal pid sends signal to the process whose process id is pid .
|
send [Unix] |
Send data over an unconnected socket.
|
send_exn [Signal] | send_exn signal ~pid sends signal to the process whose process id is
* pid .
|
send_i [Signal] | send_i signal ~pid sends signal to the process whose process id is pid .
|
send_no_sigpipe [Linux_ext] | send_no_sigpipe sock ?pos ?len buf tries to do a
blocking send on socket sock given buffer buf , offset pos
and length len .
|
send_nonblocking_no_sigpipe [Linux_ext] | send_nonblocking_no_sigpipe sock ?pos ?len buf tries to do a
nonblocking send on socket sock given buffer buf , offset pos
and length len .
|
send_nonblocking_no_sigpipe [Iobuf] | |
send_nonblocking_no_sigpipe [Bigstring] | send_nonblocking_no_sigpipe sock ?pos ?len bstr tries to send
len bytes in bigstring bstr starting at position pos to socket
sock .
|
sendfile [Linux_ext] | sendfile ?pos ?len ~fd sock sends mmap-able data from file
descriptor fd to socket sock using offset pos and length len .
|
sendmsg_nonblocking_no_sigpipe [Linux_ext] | sendmsg_nonblocking_no_sigpipe sock ?count iovecs tries to do
a nonblocking send on socket sock using count I/O-vectors
iovecs .
|
sendmsg_nonblocking_no_sigpipe [Bigstring] | sendmsg_nonblocking_no_sigpipe sock ?count iovecs sends
count iovecs of bigstrings to socket sock .
|
sendto [Unix] |
Send data over an unconnected socket.
|
sendto_nonblocking_no_sigpipe [Iobuf] | |
sendto_nonblocking_no_sigpipe [Bigstring] | sendto_nonblocking_no_sigpipe sock ?pos ?len bstr sockaddr tries
to send len bytes in bigstring bstr starting at position pos
to socket sock using address addr .
|
sequence [Command.Spec] | sequence anons specifies a sequence of anonymous arguments.
|
set [Signal.Expert] | set t b is ignore (signal t b)
|
set [Linux_ext.Epoll] | |
set [Linux_ext.Timerfd] | set t when sets t to fire once, at the time specified by when .
|
set [Unix.Scheduler] | |
set [Unix.RLimit] | |
set_bounds_and_buffer [Iobuf] | set_bounds_and_buffer ~src ~dst copies bounds (ie limits + window) and shallowly
copies the buffer from src to dst .
|
set_bounds_and_buffer_sub [Iobuf] | set_bounds_and_buffer_sub ?pos ?len ~src ~dst () is a more efficient version of:
set_bounds_and_buffer ~src:(Iobuf.sub ?pos ?len src) ~dst .
|
set_close_on_exec [Unix] |
Set the ``close-on-exec'' flag on the given descriptor.
|
set_in_channel_timeout [Unix] |
Set a timeout for a socket associated with an
in_channel
|
set_mcast_ifname [Unix] | set_mcast_ifname sock "eth0" sets outgoing multicast traffic on IPv4 UDP socket
sock to go out through interface eth0 .
|
set_mcast_loop [Unix] | set_mcast_loop sock loop sets the boolean argument that determines whether sent
multicast packets are looped back to local sockets.
|
set_mcast_ttl [Unix] | set_mcast_ttl sock ttl sets the time-to-live value of outgoing multicast packets for
socket sock to ttl .
|
set_nonblock [Unix] |
Set the ``non-blocking'' flag on the given descriptor.
|
set_out_channel_timeout [Unix] |
Set a timeout for a socket associated with an
out_channel
|
set_recording [Backtrace.Exn] | |
set_repeating [Linux_ext.Timerfd] | set_repeating ?initial t interval sets t to fire every interval starting at
when .
|
set_run_when_unused_data [Weak_hashtbl] | set_run_when_unused_data t ~thread_safe_f calls thread_safe_f in the finalizer
attached to each data in t , after ensuring the entry being finalized will be
handled in the next call to reclaim_space_for_keys_with_unused_data .
|
set_time [Linux_ext.Clock] | |
setgid [Unix] |
Set the real group id and effective group id for the process.
|
setitimer [Unix] | setitimer t s sets the interval timer t and returns
its previous status.
|
setpriority [Linux_ext] |
Set the calling thread's priority in the linux scheduler
|
setpwent [Unix.Passwd.Low_level] | |
setsid [Unix.Terminal_io] |
Put the calling process in a new session and detach it from
its controlling terminal.
|
setsockopt [Unix] |
Set or clear a boolean-valued option in the given socket.
|
setsockopt_float [Unix] |
Same as
UnixLabels.setsockopt for a socket option whose value is a floating-point
number.
|
setsockopt_int [Unix] |
Same as
UnixLabels.setsockopt for an integer-valued socket option.
|
setsockopt_optint [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 [Unix] |
Sets the real user id and effective user id for the process.
|
sexp_of_addr_info [Unix] | |
sexp_of_env [Unix] | |
sexp_of_error [Unix.Exit_or_signal_or_stop] | |
sexp_of_error [Unix.Exit_or_signal] | |
sexp_of_error [Unix.Exit] | |
sexp_of_error [Unix] |
Unknown error
|
sexp_of_file_kind [Unix] |
Socket
|
sexp_of_file_perm [Unix] | |
sexp_of_flow_action [Unix.Terminal_io] | |
sexp_of_flush_queue [Unix.Terminal_io] | |
sexp_of_getaddrinfo_option [Unix] | |
sexp_of_getnameinfo_option [Unix] | |
sexp_of_interval_timer [Unix] |
(for profiling) decrements both when the process
is running and when the system is running on behalf of the
process; it sends
SIGPROF when expired.
|
sexp_of_interval_timer_status [Unix] | |
sexp_of_limit [Unix.RLimit] | |
sexp_of_lock_command [Unix] |
Lock a region for reading, or fail if already locked
|
sexp_of_msg_flag [Unix] | |
sexp_of_name_info [Unix] |
Name of service or port number
|
sexp_of_no_seek [Iobuf_intf] | |
sexp_of_no_seek [Iobuf] | |
sexp_of_open_flag [Unix] |
Set the close-on-exec flag on the descriptor returned by
Unix.openfile
|
sexp_of_process_times [Unix] | |
sexp_of_resource [Unix.RLimit] | |
sexp_of_seek [Iobuf_intf] | |
sexp_of_seek [Iobuf] | |
sexp_of_seek_command [Unix] |
indicates positions relative to the end of the file
|
sexp_of_select_timeout [Unix] | |
sexp_of_setattr_when [Unix.Terminal_io] | |
sexp_of_shutdown_command [Unix] |
Close both
|
sexp_of_sockaddr [Unix] | |
sexp_of_socket_bool_option [Unix] |
Forbid binding an IPv6 socket to an IPv4 address
|
sexp_of_socket_domain [Unix] | |
sexp_of_socket_float_option [Unix] |
Timeout for output operations
|
sexp_of_socket_int_option [Unix] | |
sexp_of_socket_type [Unix] | |
sexp_of_stats [Unix.Native_file] | |
sexp_of_stats [Unix] | |
sexp_of_sys_behavior [Signal] | |
sexp_of_sysconf [Unix] | |
sexp_of_t [Timing_wheel_intf.S.Priority_queue.Elt] | |
sexp_of_t [Timing_wheel_intf.S.Priority_queue] | |
sexp_of_t [Timing_wheel_intf.S.Config] | |
sexp_of_t [Timing_wheel_intf.S.Level_bits] | |
sexp_of_t [Timing_wheel_intf.S.Alarm] | |
sexp_of_t [Timing_wheel_intf.S] | |
sexp_of_t [Time0.Stable.V1.C] | |
sexp_of_t [Time0.Stable.V1.Epoch_cache] | |
sexp_of_t [Time0.Stable.V1] | |
sexp_of_t [Uuid] | |
sexp_of_t [Time_stamp_counter.Span] | |
sexp_of_t [Time_stamp_counter.Calibrator] | |
sexp_of_t [Time_stamp_counter] | |
sexp_of_t [Time.Span.Parts] | |
sexp_of_t [Time] | |
sexp_of_t [Zone.Stable.V1] | |
sexp_of_t [User_and_group.Stable.V1] | |
sexp_of_t [Time.Stable.V1] | |
sexp_of_t [Squeue] | |
sexp_of_t [Span.Stable.V1] | |
sexp_of_t [Span.Parts] | |
sexp_of_t [Span] | |
sexp_of_t [Signal] | |
sexp_of_t [Piecewise_linear_intf.Float_like] | |
sexp_of_t [Piecewise_linear_intf.S] | |
sexp_of_t [Ofday.Stable.V1] | |
sexp_of_t [Ofday.Zoned.Stable.V1] | |
sexp_of_t [Ofday.Zoned] | |
sexp_of_t [Ofday] | |
sexp_of_t [Nano_mutex] | |
sexp_of_t [Linux_ext.Epoll.Flags] | |
sexp_of_t [Linux_ext.Epoll] | |
sexp_of_t [Linux_ext.Priority] | |
sexp_of_t [Linux_ext.Timerfd.Flags] | |
sexp_of_t [Linux_ext.Timerfd.Clock] | |
sexp_of_t [Linux_ext.Timerfd] | |
sexp_of_t [Linux_ext.Sysinfo] | |
sexp_of_t [Iobuf_intf.Bound] | |
sexp_of_t [Iobuf] |
The first type parameter controls whether the iobuf can be written to.
|
sexp_of_t [Interval_intf.S.Set] | |
sexp_of_t [Interval_intf.S] | |
sexp_of_t [Interval_intf.S1.Set] | |
sexp_of_t [Interval_intf.S1] | |
sexp_of_t [Interval.Stable.V1.Ofday] | |
sexp_of_t [Interval.Stable.V1.Time] | |
sexp_of_t [Interval.Stable.V1.Int] | |
sexp_of_t [Interval.Stable.V1.Float] | |
sexp_of_t [Date0.Stable.V1] | |
sexp_of_t [Date0] | |
sexp_of_t [Unix.Mman.Mcl_flags] | |
sexp_of_t [Unix.Scheduler.Policy] | |
sexp_of_t [Unix.Utsname] | |
sexp_of_t [Unix.Resource_usage] | |
sexp_of_t [Unix.RLimit] | |
sexp_of_t [Unix.IOVec] | |
sexp_of_t [Unix.Terminal_io] | |
sexp_of_t [Unix.Service] | |
sexp_of_t [Unix.Protocol] | |
sexp_of_t [Unix.Host] | |
sexp_of_t [Unix.Cidr] | |
sexp_of_t [Unix.Inet_addr] | |
sexp_of_t [Unix.Protocol_family] | |
sexp_of_t [Unix.Group] | |
sexp_of_t [Unix.Passwd] | |
sexp_of_t [Unix.Select_fds] | |
sexp_of_t [Unix.Process_info] | |
sexp_of_t [Unix.Open_flags] | |
sexp_of_t [Unix.Exit_or_signal_or_stop] | |
sexp_of_t [Unix.Exit_or_signal] | |
sexp_of_t [Unix.Exit] | |
sexp_of_t [Unix.File_descr] | |
sexp_of_t [Backtrace] | |
sexp_of_t_abs [Time0.Stable.V1] | |
sexp_of_tcp_bool_option [Linux_ext] | |
sexp_of_tm [Unix] | |
sexp_of_wait_on [Unix] | |
shift_epoch_time [Zone] | shift_epoch_time zone [`Local | `UTC] time Takes an epoch (aka "unix") time given
either in local or in UTC (as indicated in the arguments) and shifts it according to
the local time regime in force in zone.
|
show_messages [Timing_wheel_intf.Timing_wheel.Debug] | |
show_messages [Iobuf_debug.Make] | |
shutdown [Unix] | |
shutdown_command_of_sexp [Unix] |
The type of commands for
shutdown .
|
shutdown_connection [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.
|
sigmask [Thread] | sigmask cmd sigs changes the set of blocked signals for the
calling thread.
|
signal [Signal.Expert] | signal t sets the behavior of the system on receipt of signal t and returns the
behavior previously associated with t .
|
signal [Condition] | |
sigpending [Signal] | sigpending () returns the set of blocked signals that are currently
* pending.
|
sigprocmask [Signal] | sigprocmask cmd sigs changes the set of blocked signals.
|
sigsuspend [Signal] | sigsuspend sigs atomically sets the blocked signals to sigs and waits for
* a non-ignored, non-blocked signal to be delivered.
|
single_write [Unix] |
Same as
write but ensures that all errors are reported and
that no character has ever been written when an error is reported.
|
sleep [Unix] |
Stop execution for the given number of seconds.
|
small_diff [Ofday] | |
sockaddr_of_sexp [Unix] | |
socket [Unix] |
Create a new socket in the given domain, and with the
given kind.
|
socket_bool_option_of_sexp [Unix] |
The socket options that can be consulted with
UnixLabels.getsockopt
and modified with UnixLabels.setsockopt .
|
socket_domain_of_sexp [Unix] | |
socket_float_option_of_sexp [Unix] |
The socket options that can be consulted with
UnixLabels.getsockopt_float
and modified with UnixLabels.setsockopt_float .
|
socket_int_option_of_sexp [Unix] |
The socket options that can be consulted with
UnixLabels.getsockopt_int
and modified with UnixLabels.setsockopt_int .
|
socket_type_of_sexp [Unix] | |
socketpair [Unix] |
Create a pair of unnamed sockets, connected together.
|
split [Filename] | split filename returns (dirname filename, basename filename)
|
split_extension [Filename] | split_extension fn return the portion of the filename before the
extension and the (optional) extension.
|
stack [Unix.RLimit] | |
start [Timing_wheel_intf.S] | |
start_of_day [Ofday] | |
stat [Unix.Native_file] |
Return the information for the named file.
|
stat [Unix] |
Return the information for the named file.
|
stats_of_sexp [Unix.Native_file] | |
stats_of_sexp [Unix] |
The informations returned by the
UnixLabels.stat calls.
|
stderr [Unix] |
File descriptor for standard standard error.
|
stdin [Unix] |
File descriptor for standard input.
|
stdout [Unix] |
File descriptor for standard output.
|
step [Command.Spec] |
combinator for patching up how parameters are obtained or presented
|
stime [Unix.Resource_usage.Fields] | |
stime [Unix.Resource_usage] | |
stop [Signal] | Stop Stop
|
strftime [Unix] |
Convert a date and time, specified by the
tm argument, into a formatted string.
|
string [Iobuf_intf.Accessors] | |
string [Command.Spec] | |
string_kind [Unix.IOVec] | |
strptime [Unix] |
Given a format string, convert a corresponding string to a date and time
See 'man strptime' for format options.
|
sub [Time_internal.T] | |
sub [Time] | sub t s subtracts the span s from time t and returns the
resulting time.
|
sub [Ofday] | |
sub [Iobuf] | sub t ~pos ~len returns a new iobuf with limits and window set to the subrange of
t specified by pos and len .
|
summary [Command.Deprecated] | |
symlink [Unix] | symlink source dest creates the file dest as a symbolic link
to the file source .
|
sync [Unix.Open_flags] | |
sync [Unix] |
Synchronize all filesystem buffers with disk.
|
synchronize [Mutex0] | |
synchronize [Mutex] | synchronize f creates a mutex and returns a new function that is identical to f
except that the mutex is held during its execution.
|
sys_behavior_of_sexp [Signal] |
The default behaviour of the system if these signals trickle to the top level of a
program.
|
sysconf [Unix] | |
sysconf_of_sexp [Unix] |
System configuration
|
sysinfo [Linux_ext.Sysinfo] | |
sysname [Unix.Utsname] | |
system [Unix] |
Execute the given command, wait until it terminates, and return
its termination status.
|
T | |
t2 [Command.Spec] | |
t3 [Command.Spec] | |
t4 [Command.Spec] | |
t_of_sexp [Timing_wheel_intf.S.Config] | |
t_of_sexp [Timing_wheel_intf.S.Level_bits] | |
t_of_sexp [Time0.Stable.V1.C] | |
t_of_sexp [Time0.Stable.V1.Epoch_cache] | |
t_of_sexp [Time0.Stable.V1] | |
t_of_sexp [Uuid] | |
t_of_sexp [Time_stamp_counter.Span] | |
t_of_sexp [Time_stamp_counter.Calibrator] | |
t_of_sexp [Time_stamp_counter] | |
t_of_sexp [Time.Span.Parts] | |
t_of_sexp [Time] | |
t_of_sexp [Zone.Stable.V1] | |
t_of_sexp [User_and_group.Stable.V1] | |
t_of_sexp [Time.Stable.V1] | |
t_of_sexp [Span.Stable.V1] | |
t_of_sexp [Span.Parts] | |
t_of_sexp [Span] | |
t_of_sexp [Signal] | |
t_of_sexp [Piecewise_linear_intf.Float_like] | |
t_of_sexp [Piecewise_linear_intf.S] | |
t_of_sexp [Ofday.Stable.V1] | |
t_of_sexp [Ofday.Zoned.Stable.V1] | |
t_of_sexp [Ofday.Zoned] | |
t_of_sexp [Ofday] | |
t_of_sexp [Linux_ext.Priority] | |
t_of_sexp [Linux_ext.Timerfd.Clock] | |
t_of_sexp [Linux_ext.Timerfd] | |
t_of_sexp [Linux_ext.Sysinfo] | |
t_of_sexp [Interval_intf.S.Set] | |
t_of_sexp [Interval_intf.S] | |
t_of_sexp [Interval_intf.S1.Set] | |
t_of_sexp [Interval_intf.S1] | |
t_of_sexp [Interval.Stable.V1.Ofday] | |
t_of_sexp [Interval.Stable.V1.Time] | |
t_of_sexp [Interval.Stable.V1.Int] | |
t_of_sexp [Interval.Stable.V1.Float] | |
t_of_sexp [Date0.Stable.V1] | |
t_of_sexp [Date0] | |
t_of_sexp [Unix.Mman.Mcl_flags] | |
t_of_sexp [Unix.Scheduler.Policy] | |
t_of_sexp [Unix.Utsname] | |
t_of_sexp [Unix.Resource_usage] | |
t_of_sexp [Unix.RLimit] | |
t_of_sexp [Unix.IOVec] | |
t_of_sexp [Unix.Service] | |
t_of_sexp [Unix.Protocol] | |
t_of_sexp [Unix.Cidr] | |
t_of_sexp [Unix.Inet_addr] | |
t_of_sexp [Unix.Protocol_family] | |
t_of_sexp [Unix.Passwd] | |
t_of_sexp [Unix.Process_info] | |
t_of_sexp [Unix.Exit_or_signal_or_stop] | |
t_of_sexp [Unix.Exit_or_signal] | |
t_of_sexp [Unix.Exit] | |
t_of_sexp [Unix.File_descr] | |
t_of_sexp_abs [Time0.Stable.V1] | |
t_of_sexp_abs [Time] | t_of_sexp_abs sexp as t_of_sexp , but demands that sexp indicate the timezone the
time is expressed in.
|
t_of_sexp_gen [Time0.Stable.V1] | |
tcdrain [Unix.Terminal_io] |
Waits until all output written on the given file descriptor
has been transmitted.
|
tcflow [Unix.Terminal_io] |
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 [Unix.Terminal_io] |
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 [Unix.Terminal_io] |
Return the status of the terminal referred to by the given
file descriptor.
|
tcp_bool_option_of_sexp [Linux_ext] | |
tcsendbreak [Unix.Terminal_io] |
Send a break condition on the given file descriptor.
|
tcsetattr [Unix.Terminal_io] |
Set the status of the terminal referred to by the given
file descriptor.
|
temp_dir [Filename] | |
temp_dir_name [Filename] |
The name of the temporary directory:
|
temp_file [Filename] | |
term [Signal] | Terminate Termination
|
threads_have_been_created [Thread] | true iff Thread.create has ever been called, even if there is
currently only one running thread.
|
time [Unix] |
Return the current time since 00:00:00 GMT, Jan.
|
time_span [Command.Spec] | |
timedlock [Mutex] | timedlock mtx timeout like lock , but takes a timeout parameter.
|
timedwait [Condition] | timedwait cond mtx timeout waits on condition variable cond
with mutex mtx until either the condition is signalled, or until
timeout expires.
|
timegm [Unix] |
Convert a UTC time in a tm record to a time in seconds
|
times [Unix] |
Return the execution times of the process.
|
tm_of_sexp [Unix] |
The type representing wallclock time and calendar date.
|
to_caml_int [Signal] | |
to_date [Time0.Stable.V1] | |
to_date [Time] | |
to_date_ofday [Time0.Stable.V1] | |
to_date_ofday [Time] | |
to_day [Span] | |
to_epoch [Time0.Stable.V1] | |
to_epoch [Time] | to_epoch t returns the number of seconds since Jan 1, 1970 00:00:00 in UTC
|
to_filename_string [Time0.Stable.V1] | |
to_filename_string [Time] | to_filename_string t converts t to string with format YYYY-MM-DD_HH-MM-SS.mmm
which is suitable for using in filenames
|
to_hr [Span] | |
to_int [Linux_ext.Priority] | |
to_int [Unix.File_descr] | |
to_int63 [Time_stamp_counter] | to_int63 t returns the TSC value represented by t as an Int63.t .
|
to_knots [Piecewise_linear_intf.S] | |
to_list [Unix.Resource_usage.Fields] | |
to_local_date [Time0.Stable.V1] | |
to_local_date [Time] | |
to_local_date_ofday [Time0.Stable.V1] | |
to_local_date_ofday [Time] | |
to_local_ofday [Time0.Stable.V1] | |
to_local_ofday [Time] | |
to_millisec_string [Ofday] |
with milliseconds
|
to_min [Span] | |
to_ms [Span] | |
to_nanos_since_epoch [Time_stamp_counter] | to_nanos_since_epoch t converts a t to an integer number of nanos since the
epoch.
|
to_ns [Time_stamp_counter.Span] | |
to_ns [Span] | |
to_ofday [Time0.Stable.V1] | |
to_ofday [Time] | |
to_parts [Span] | |
to_parts [Ofday] | |
to_poly [Interval_intf.S.Set] | |
to_poly [Interval_intf.S] | |
to_sec [Span] | |
to_sec_string [Time0.Stable.V1] | |
to_sec_string [Time] | to_sec_string t Same as to_string, but without milliseconds
|
to_sec_string [Ofday] |
trailing milliseconds are trimmed
|
to_short_string [Span] | to_short_string t pretty-prints approximate time span using no more than
five characters if the span is positive, and six if the span is negative.
|
to_span_since_start_of_day [Ofday] | |
to_string [Time0.Stable.V1] | |
to_string [Span] | |
to_string [Signal] | to_string t returns a human-readable name: "sigabrt", "sigalrm", ...
|
to_string [Iobuf] | to_string t returns the bytes in t as a string.
|
to_string [Unix.Inet_addr] |
Return the printable representation of the given Internet address.
|
to_string [Backtrace] | |
to_string_abs [Time0.Stable.V1] | |
to_string_abs [Time] | to_string_abs ?zone t returns a string that represents an absolute time, rather than
a local time with an assumed time zone.
|
to_string_abs_parts [Time0.Stable.V1] | |
to_string_american [Date0] | |
to_string_fix_proto [Time0.Stable.V1] | |
to_string_fix_proto [Time] | |
to_string_hum [Unix.Exit_or_signal_or_stop] | |
to_string_hum [Unix.Exit_or_signal] | |
to_string_hum [Unix.Exit] | |
to_string_iso8601_basic [Date0] | |
to_string_trimmed [Time0.Stable.V1] | |
to_string_trimmed [Time] | to_string_trimmed t Same as to_string, but removes trailing seconds and
milliseconds if they are 0
|
to_string_trimmed [Ofday] |
trailing seconds and subseconds are trimmed off if they are 0
|
to_system_int [Signal] | |
to_time [Time_stamp_counter] | to_time t converts a t to a Time.t .
|
to_time [Time.Ofday.Zoned] | |
to_time_span [Time_stamp_counter.Span] | |
to_tm [Time_internal] | |
to_tm_utc [Time_internal] | |
to_us [Span] | |
today [Date] | |
transfer [Iobuf] | transfer blits len bytes from src to dst , advancing the lower bounds of both
windows.
|
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_in_uncond [Squeue] | |
transfer_queue_nowait [Squeue] |
Transfers all elements from the squeue to an ordinary queue.
|
trunc [Unix.Open_flags] | |
truncate [Unix.Native_file] | |
truncate [Unix] |
Truncates the named file to the given size.
|
try_lock [Nano_mutex] | try_lock t locks t if it can immediately do so.
|
try_lock [Mutex0] | |
try_lock [Mutex] | try_lock is like lock , but always returns immediately.
|
try_lock_exn [Nano_mutex] | |
tstp [Signal] | Stop Interactive stop
|
ttin [Signal] | Stop Terminal read from background process
|
ttou [Signal] | Stop Terminal write from background process
|
U | |
ubound [Interval_intf.Gen_set] | |
ubound [Interval_intf.Gen] | |
ubound_exn [Interval_intf.Gen_set] | |
ubound_exn [Interval_intf.Gen] | |
uint16_be [Iobuf_intf.Accessors] | |
uint16_le [Iobuf_intf.Accessors] | |
uint32_be [Iobuf_intf.Accessors] | |
uint32_le [Iobuf_intf.Accessors] | |
uint8 [Iobuf_intf.Accessors] | |
umask [Unix] |
Set the process creation mask, and return the previous mask.
|
uname [Unix] | |
unix_error [Unix] | |
unlink [Unix] |
Removes the named file
|
unlock [Nano_mutex] | unlock t unlocks t , if the current thread holds it.
|
unlock [Lock_file.Nfs] | |
unlock [Unix.Flock_command] | |
unlock [Mutex] | unlock mtx unlocks mtx .
|
unlock_exn [Nano_mutex] | |
unlock_exn [Lock_file.Nfs] | unlock_exn path unlocks path if path was locked from the same host and the pid
in the file is either the current pid or not the pid of a running process.
|
unmarshal_from_sock [Bigstring_marshal] | unmarshal_from_sock ?buf sock unmarshals data from socket sock
using unmarshalling buffer buf .
|
unsafe_input [Bigstring] | unsafe_input ~min_len ic ~pos ~len bstr similar to
Bigstring.input , but does not perform any bounds checks.
|
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_fd_is_nonblocking [Bigstring] | unsafe_read_assume_fd_is_nonblocking fd ~pos ~len bstr
similar to Bigstring.read_assume_fd_is_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_write [Bigstring] | unsafe_write fd ~pos ~len bstr similar to
Bigstring.write , but does not perform any bounds checks.
|
unsafe_write_assume_fd_is_nonblocking [Bigstring] | unsafe_write_assume_fd_is_nonblocking fd ~pos ~len bstr
similar to Bigstring.write_assume_fd_is_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.
|
unsetenv [Unix] | unsetenv name deletes the variable name from the environment.
|
update_broadcast [Mutex0] | |
update_broadcast [Mutex] | update_broadcast mtx cnd ~f updates some state within a critical
section protected by mutex mtx using function f and broadcasts
condition variable cnd after finishing.
|
update_signal [Mutex0] | |
update_signal [Mutex] | update_signal mtx cnd ~f updates some state within a critical
section protected by mutex mtx using function f and signals
condition variable cnd after finishing.
|
user [User_and_group] | |
usr1 [Signal] | Terminate Application-defined signal 1
|
usr2 [Signal] | Terminate Application-defined signal 2
|
utc [Zone] | utc the UTC time zone.
|
utc_mktime [Time_internal] | |
utc_offset [Time0.Stable.V1] | |
utc_offset [Time] | |
utime [Unix.Resource_usage.Fields] | |
utime [Unix.Resource_usage] | |
utimes [Unix] |
Set the last access time (second arg) and last modification time
(third arg) for a file.
|
V | |
value [Timing_wheel_intf.S.Priority_queue.Elt] | |
value [Timing_wheel_intf.S.Alarm] | |
version [Unix.Utsname] | |
version [Command.Deprecated] | |
virtual_memory [Unix.RLimit] | |
vtalrm [Signal] | Terminate Timeout in virtual time
|
W | |
wait [Linux_ext.Epoll] | wait t ~timeout blocks until at least one file descriptor in t is ready for one
of the events it is being watched for, or timeout passes.
|
wait [Unix] | |
wait [Condition] | |
wait_nohang [Unix] | |
wait_nohang_untraced [Unix] | |
wait_not_empty [Squeue] | wait_not_empty sq Waits for something to be available.
|
wait_on_of_sexp [Unix] | |
wait_read [Thread] |
See
Thread.wait_write .
|
wait_signal [Thread] | wait_signal sigs suspends the execution of the calling thread
until the process receives one of the signals specified in the
list sigs .
|
wait_timed_read [Thread] |
See
Thread.wait_timed_write .
|
wait_timed_write [Thread] |
Same as
Thread.wait_read and Thread.wait_write , but wait for at most
the amount of time given as second argument (in seconds).
|
wait_untraced [Unix] | |
wait_write [Thread] |
Suspend the execution of the calling thread until at least
one character is available for reading (
Thread.wait_read ) or
one character can be written without blocking (wait_write )
on the given Unix file descriptor.
|
waitpid [Unix] | waitpid pid waits for child process pid to terminate, and returns its exit status.
|
waitpid_exn [Unix] | |
weekdays_between [Date0] | |
window [Iobuf_intf.Bound] | |
with_file [Unix] | with_file file ~mode ~perm ~f opens file , and applies f to the resulting file
descriptor.
|
word_size [Sys] |
Size of one word on the machine currently executing the Caml program, in
bits: 32 or 64.
|
wordexp [Unix] | |
wrap [Command.Spec] |
combinator for defining a class of commands with common behavior
|
write [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 fd ?pos ?len bstr writes len
bytes in bigstring bstr starting at position pos to file
descriptor fd .
|
write_assume_fd_is_nonblocking [Iobuf] | |
write_assume_fd_is_nonblocking [Unix] | write_assume_fd_is_nonblocking fd ?pos ?len buf calls the system call
write ASSUMING THAT IT IS NOT GOING TO BLOCK.
|
write_assume_fd_is_nonblocking [Bigstring] | write_assume_fd_is_nonblocking fd ?pos ?len bstr writes len
bytes in bigstring bstr starting at position pos to file
descriptor fd without yielding to other OCaml-threads.
|
writev [Unix] | writev fd ?count iovecs like Unix.writev_assume_fd_is_nonblocking , but does
not require the descriptor to not block.
|
writev [Bigstring] | writev fd ?count iovecs writes count iovecs of
bigstrings to file descriptor fd .
|
writev_assume_fd_is_nonblocking [Unix] | writev_assume_fd_is_nonblocking fd ?count iovecs calls the system call
writev ASSUMING THAT IT IS NOT GOING TO BLOCK using count
I/O-vectors iovecs .
|
writev_assume_fd_is_nonblocking [Bigstring] | writev_assume_fd_is_nonblocking fd ?count iovecs writes count
iovecs of bigstrings to file descriptor fd without yielding to
other OCaml-threads.
|
wronly [Unix.Open_flags] | |
Y | |
year [Date0] | |
yield [Thread] |
Re-schedule the calling thread without suspending it.
|
Z | |
zero [Span] | |
zero [Signal] | Ignore No-op; can be used to test whether the target
process exists and the current process has
permission to signal it
|
zone [Ofday.Zoned] |