# Index of values

(%:) [Command.Anons] | `(name %: typ)` specifies a required anonymous argument of type `typ`.
(+) [Time_stamp_counter.Span] |
(+) [Time_ns.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] |
(-) [Time_ns.Span] |
(-) [Span] |
(/) [Time_ns.Span] |
(/) [Span] |
(//) [Time_ns.Span] |
(//) [Span] |
(^/) [Std] |
__bin_read_sockaddr__ [Core_unix] |
__bin_read_socket_domain__ [Core_unix] |
__bin_read_socket_type__ [Core_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_ns.Ofday.Stable.V1] |
__bin_read_t__ [Time_ns.Option.Stable.V1] |
__bin_read_t__ [Time_ns.Span.Option.Stable.V1] |
__bin_read_t__ [Time_ns.Span.Stable.V1] |
__bin_read_t__ [Time] |
__bin_read_t__ [Zone.Stable.V1] |
__bin_read_t__ [User_and_group.Stable.V1] |
__bin_read_t__ [Uuid.Stable.V1] |
__bin_read_t__ [Time_ns.Stable.V1] |
__bin_read_t__ [Time.Stable.With_utc_sexp.V1] |
__bin_read_t__ [Time.Stable.V1] |
__bin_read_t__ [Span.Stable.V2] |
__bin_read_t__ [Span.Stable.V1] |
__bin_read_t__ [Span] |
__bin_read_t__ [Signal] |
__bin_read_t__ [Piecewise_linear_intf.S] |
__bin_read_t__ [Piecewise_linear_intf.Float_like] |
__bin_read_t__ [Piecewise_linear.Stable.V1.Make_invertible] |
__bin_read_t__ [Piecewise_linear.Stable.V1.Make] |
__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__ [Limiter.Infinite_or_finite] |
__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__ [Date0.Stable.V1] |
__bin_read_t__ [Date0] |
__bin_read_t__ [Core_unix.Cidr] |
__bin_read_t__ [Core_unix.Inet_addr] |
__bin_read_t__ [Core_unix.Protocol_family] |
__bin_read_t__ [Core_unix.Thread_id] |
__bin_read_t__ [Core_unix.File_descr] |
__bin_read_tcp_bool_option__ [Linux_ext] |
__env_of_sexp__ [Core_unix] |
__error_of_sexp__ [Unix_error] |
__error_of_sexp__ [Core_unix.Exit_or_signal_or_stop] |
__error_of_sexp__ [Core_unix.Exit_or_signal] |
__error_of_sexp__ [Core_unix.Exit] |
__sys_behavior_of_sexp__ [Signal] |
__t_of_sexp__ [Unix_error] |
__t_of_sexp__ [Time0.Stable.V1.Epoch_cache] |
__t_of_sexp__ [Core_unix.Scheduler.Policy] |
__t_of_sexp__ [Core_unix.Protocol_family] |
__wait_on_of_sexp__ [Core_unix] |
_squelch_unused_module_warning_ [Std] |
_squelch_unused_module_warning_ [Stable] |
A
abbreviation [Zone] | `abbreviation zone t` returns t abbreviation name such as EDT, EST, JST of given `zone` at the time `t`.
abort [Core_unix] |
abrt [Signal] | `Dump_core` Abnormal termination
abs [Time_ns.Span] |
abs [Span] | absolute value
abs_diff [Time_internal.T] |
abs_diff [Time_ns] |
abs_diff [Time] | `abs_diff t1 t2` returns the absolute span of time `t1` minus time `t2`.
accept [Core_unix] | Accept connections on the given socket.
access [Core_unix] | Check that the process has the given permissions over the named file.
access_exn [Core_unix] |
ad_hoc [Command.Deprecated.Spec] |
add [Time_internal.T] |
add [Time_stamp_counter] |
add [Time_ns] |
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 [Core_unix.Resource_usage] | `add ru1 ru2` adds two rusage structures (e.g.
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_exn [Weak_hashtbl] |
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 [Core_unix] | Address information returned by `Unix.getaddrinfo`.
advance [Iobuf] | `advance t amount` advances the lower bound of the window by `amount`.
alarm [Core_unix] | Schedule a `SIGALRM` signal after the given number of seconds.
all [Syslog.Level] | Debug-level message
all_matching_addresses [Core_unix.Cidr] | Generate a sequence of all addresses in the block.
alrm [Signal] | `Terminate` Timeout
am [Debug] | `am`, `ams`, and `amf` output a source code position and backtrace to stderr.
amf [Debug] |
ams [Debug] |
anon [Command.Param.S] | `anon spec` specifies a command that, among other things, takes the anonymous arguments specified by `spec`.
append [Core_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.Param.S] | the arguments passed to the command
argv [Core_sys] | The command line arguments given to the process.
B
base_address [Core_unix.Cidr] | Accessors.
basename [Core_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`.
basic' [Command] | Same general behavior as `basic`, but takes a command line specification built up using `Params` instead of `Spec`.
big_endian [Core_sys] | Whether the machine currently executing the Caml program is big-endian.
bigstring [Iobuf_intf.Accessors] |
bigstring_crc32 [Crc] |
bigstring_kind [Core_unix.IOVec] |
bin_prot [Iobuf_intf.Accessors] |
bin_read_sockaddr [Core_unix] |
bin_read_socket_domain [Core_unix] |
bin_read_socket_type [Core_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_ns.Ofday.Stable.V1] |
bin_read_t [Time_ns.Option.Stable.V1] |
bin_read_t [Time_ns.Span.Option.Stable.V1] |
bin_read_t [Time_ns.Span.Stable.V1] |
bin_read_t [Time] |
bin_read_t [Zone.Stable.V1] |
bin_read_t [User_and_group.Stable.V1] |
bin_read_t [Uuid.Stable.V1] |
bin_read_t [Time_ns.Stable.V1] |
bin_read_t [Time.Stable.With_utc_sexp.V1] |
bin_read_t [Time.Stable.V1] |
bin_read_t [Span.Stable.V2] |
bin_read_t [Span.Stable.V1] |
bin_read_t [Span] |
bin_read_t [Signal] |
bin_read_t [Piecewise_linear_intf.S] |
bin_read_t [Piecewise_linear_intf.Float_like] |
bin_read_t [Piecewise_linear.Stable.V1.Make_invertible] |
bin_read_t [Piecewise_linear.Stable.V1.Make] |
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 [Limiter.Infinite_or_finite] |
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 [Date0.Stable.V1] |
bin_read_t [Date0] |
bin_read_t [Core_unix.Cidr] |
bin_read_t [Core_unix.Inet_addr] |
bin_read_t [Core_unix.Protocol_family] |
bin_read_t [Core_unix.Thread_id] |
bin_read_t [Core_unix.File_descr] |
bin_read_tcp_bool_option [Linux_ext] |
bin_reader_sockaddr [Core_unix] |
bin_reader_socket_domain [Core_unix] |
bin_reader_socket_type [Core_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_ns.Ofday.Stable.V1] |
bin_reader_t [Time_ns.Option.Stable.V1] |
bin_reader_t [Time_ns.Span.Option.Stable.V1] |
bin_reader_t [Time_ns.Span.Stable.V1] |
bin_reader_t [Time] |
bin_reader_t [Zone.Stable.V1] |
bin_reader_t [User_and_group.Stable.V1] |
bin_reader_t [Uuid.Stable.V1] |
bin_reader_t [Time_ns.Stable.V1] |
bin_reader_t [Time.Stable.With_utc_sexp.V1] |
bin_reader_t [Time.Stable.V1] |
bin_reader_t [Span.Stable.V2] |
bin_reader_t [Span.Stable.V1] |
bin_reader_t [Span] |
bin_reader_t [Signal] |
bin_reader_t [Piecewise_linear_intf.S] |
bin_reader_t [Piecewise_linear_intf.Float_like] |
bin_reader_t [Piecewise_linear.Stable.V1.Make_invertible] |
bin_reader_t [Piecewise_linear.Stable.V1.Make] |
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 [Limiter.Infinite_or_finite] |
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 [Date0.Stable.V1] |
bin_reader_t [Date0] |
bin_reader_t [Core_unix.Cidr] |
bin_reader_t [Core_unix.Inet_addr] |
bin_reader_t [Core_unix.Protocol_family] |
bin_reader_t [Core_unix.Thread_id] |
bin_reader_t [Core_unix.File_descr] |
bin_reader_tcp_bool_option [Linux_ext] |
bin_size_sockaddr [Core_unix] |
bin_size_socket_domain [Core_unix] |
bin_size_socket_type [Core_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_ns.Ofday.Stable.V1] |
bin_size_t [Time_ns.Option.Stable.V1] |
bin_size_t [Time_ns.Span.Option.Stable.V1] |
bin_size_t [Time_ns.Span.Stable.V1] |
bin_size_t [Time] |
bin_size_t [Zone.Stable.V1] |
bin_size_t [User_and_group.Stable.V1] |
bin_size_t [Uuid.Stable.V1] |
bin_size_t [Time_ns.Stable.V1] |
bin_size_t [Time.Stable.With_utc_sexp.V1] |
bin_size_t [Time.Stable.V1] |
bin_size_t [Span.Stable.V2] |
bin_size_t [Span.Stable.V1] |
bin_size_t [Span] |
bin_size_t [Signal] |
bin_size_t [Piecewise_linear_intf.S] |
bin_size_t [Piecewise_linear_intf.Float_like] |
bin_size_t [Piecewise_linear.Stable.V1.Make_invertible] |
bin_size_t [Piecewise_linear.Stable.V1.Make] |
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 [Limiter.Infinite_or_finite] |
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 [Date0.Stable.V1] |
bin_size_t [Date0] |
bin_size_t [Core_unix.Cidr] |
bin_size_t [Core_unix.Inet_addr] |
bin_size_t [Core_unix.Protocol_family] |
bin_size_t [Core_unix.Thread_id] |
bin_size_t [Core_unix.File_descr] |
bin_size_tcp_bool_option [Linux_ext] |
bin_sockaddr [Core_unix] | The type of socket addresses.
bin_socket_domain [Core_unix] | The type of socket domains.
bin_socket_type [Core_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_ns.Ofday.Stable.V1] |
bin_t [Time_ns.Option.Stable.V1] |
bin_t [Time_ns.Span.Option.Stable.V1] |
bin_t [Time_ns.Span.Stable.V1] |
bin_t [Time] |
bin_t [Zone.Stable.V1] |
bin_t [User_and_group.Stable.V1] |
bin_t [Uuid.Stable.V1] |
bin_t [Time_ns.Stable.V1] |
bin_t [Time.Stable.With_utc_sexp.V1] |
bin_t [Time.Stable.V1] |
bin_t [Span.Stable.V2] |
bin_t [Span.Stable.V1] |
bin_t [Span] |
bin_t [Signal] |
bin_t [Piecewise_linear_intf.S] |
bin_t [Piecewise_linear_intf.Float_like] |
bin_t [Piecewise_linear.Stable.V1.Make_invertible] |
bin_t [Piecewise_linear.Stable.V1.Make] |
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 [Limiter.Infinite_or_finite] |
bin_t [Interval_intf.S.Set] |
bin_t [Interval_intf.S] |
bin_t [Interval_intf.S1.Set] |
bin_t [Interval_intf.S1] |
bin_t [Date0.Stable.V1] |
bin_t [Date0] |
bin_t [Core_unix.Cidr] |
bin_t [Core_unix.Inet_addr] |
bin_t [Core_unix.Protocol_family] |
bin_t [Core_unix.Thread_id] |
bin_t [Core_unix.File_descr] |
bin_tcp_bool_option [Linux_ext] |
bin_write_sockaddr [Core_unix] |
bin_write_socket_domain [Core_unix] |
bin_write_socket_type [Core_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_ns.Ofday.Stable.V1] |
bin_write_t [Time_ns.Option.Stable.V1] |
bin_write_t [Time_ns.Span.Option.Stable.V1] |
bin_write_t [Time_ns.Span.Stable.V1] |
bin_write_t [Time] |
bin_write_t [Zone.Stable.V1] |
bin_write_t [User_and_group.Stable.V1] |
bin_write_t [Uuid.Stable.V1] |
bin_write_t [Time_ns.Stable.V1] |
bin_write_t [Time.Stable.With_utc_sexp.V1] |
bin_write_t [Time.Stable.V1] |
bin_write_t [Span.Stable.V2] |
bin_write_t [Span.Stable.V1] |
bin_write_t [Span] |
bin_write_t [Signal] |
bin_write_t [Piecewise_linear_intf.S] |
bin_write_t [Piecewise_linear_intf.Float_like] |
bin_write_t [Piecewise_linear.Stable.V1.Make_invertible] |
bin_write_t [Piecewise_linear.Stable.V1.Make] |
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 [Limiter.Infinite_or_finite] |
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 [Date0.Stable.V1] |
bin_write_t [Date0] |
bin_write_t [Core_unix.Cidr] |
bin_write_t [Core_unix.Inet_addr] |
bin_write_t [Core_unix.Protocol_family] |
bin_write_t [Core_unix.Thread_id] |
bin_write_t [Core_unix.File_descr] |
bin_write_tcp_bool_option [Linux_ext] |
bin_writer_sockaddr [Core_unix] |
bin_writer_socket_domain [Core_unix] |
bin_writer_socket_type [Core_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_ns.Ofday.Stable.V1] |
bin_writer_t [Time_ns.Option.Stable.V1] |
bin_writer_t [Time_ns.Span.Option.Stable.V1] |
bin_writer_t [Time_ns.Span.Stable.V1] |
bin_writer_t [Time] |
bin_writer_t [Zone.Stable.V1] |
bin_writer_t [User_and_group.Stable.V1] |
bin_writer_t [Uuid.Stable.V1] |
bin_writer_t [Time_ns.Stable.V1] |
bin_writer_t [Time.Stable.With_utc_sexp.V1] |
bin_writer_t [Time.Stable.V1] |
bin_writer_t [Span.Stable.V2] |
bin_writer_t [Span.Stable.V1] |
bin_writer_t [Span] |
bin_writer_t [Signal] |
bin_writer_t [Piecewise_linear_intf.S] |
bin_writer_t [Piecewise_linear_intf.Float_like] |
bin_writer_t [Piecewise_linear.Stable.V1.Make_invertible] |
bin_writer_t [Piecewise_linear.Stable.V1.Make] |
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 [Limiter.Infinite_or_finite] |
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 [Date0.Stable.V1] |
bin_writer_t [Date0] |
bin_writer_t [Core_unix.Cidr] |
bin_writer_t [Core_unix.Inet_addr] |
bin_writer_t [Core_unix.Protocol_family] |
bin_writer_t [Core_unix.Thread_id] |
bin_writer_t [Core_unix.File_descr] |
bin_writer_tcp_bool_option [Linux_ext] |
bind [Core_unix] | Bind a socket to an address.
bind_any [Core_unix.Inet_addr] | A special address, for use only with `bind`, representing all the Internet addresses that the host machine possesses.
bind_any_inet6 [Core_unix.Inet_addr] |
bind_to_interface [Linux_ext] |
bits [Core_unix.Cidr] |
blit [Iobuf_intf.Consuming_blit] |
blit [Iobuf.Blit_consume_and_fill] |
blit [Iobuf.Blit_fill] |
blit [Iobuf.Blit_consume] |
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] |
blito [Iobuf_intf.Consuming_blit] |
blito [Iobuf.Blit_consume_and_fill] |
blito [Iobuf.Blit_fill] |
blito [Iobuf.Blit_consume] |
block_forever [Core_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.Arg_type.Export] |
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 [Core_condition] |
bucket_size [Limiter] |
buf [Iobuf.Expert] |
build_info [Command.Deprecated] |
business_dates_between [Date0] |
C
c_int_size [Core_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 [Core_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 [Core_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 [Core_sys] | Warning: this function clobbers the Signal.int (SIGINT) handler.
char [Iobuf_intf.Accessors] |
char [Command.Arg_type.Export] |
char_of_digit [Time_internal.Helpers] |
chdir [Core_unix] | Change the process working directory.
chdir [Core_sys] | Change the current working directory of the process.
check_invariant [Iobuf_debug.Make] |
check_suffix [Core_filename] | `check_suffix name suff` returns `true` if the filename `name` ends with the suffix `suff`.
chld [Signal] | `Ignore` Child process terminated
chmod [Core_unix] | Change the permissions of the named file.
chop_extension [Core_filename] | Return the given file name without its extension.
chop_suffix [Core_filename] | `chop_suffix name suff` removes the suffix `suff` from the filename `name`.
chown [Core_unix] | Change the owner uid and owner gid of the named file.
chroot [Core_unix] | Change the process root directory.
clear [Squeue] | clears the queue
clear [Linux_ext.Timerfd] | `clear t` causes `t` to not fire any more.
clear_close_on_exec [Core_unix] | Clear the ``close-on-exec'' flag on the given descriptor.
clear_nonblock [Core_unix] | Clear the ``non-blocking'' flag on the given descriptor.
cloexec [Linux_ext.Timerfd.Flags] |
close [Linux_ext.Epoll] |
close [Core_unix] | Close a file descriptor.
close_process [Core_unix] | Close channels opened by `UnixLabels.open_process`, wait for the associated command to terminate, and return its termination status.
close_process_full [Core_unix] | Close channels opened by `UnixLabels.open_process_full`, wait for the associated command to terminate, and return its termination status.
close_process_in [Core_unix] | Close channels opened by `UnixLabels.open_process_in`, wait for the associated command to terminate, and return its termination status.
close_process_out [Core_unix] | Close channels opened by `UnixLabels.open_process_out`, wait for the associated command to terminate, and return its termination status.
closedir [Core_unix] | Close a directory descriptor.
closelog [Syslog] | `closelog ()` closes the connection to the `syslog` daemon.
code [Core_unix.Exit] |
command [Core_sys] | Execute the given shell command and return its exit code.
command_exn [Core_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 [Unix_error] |
compare [Time0.Stable.V1.C] |
compare [Syslog.Level] | Debug-level message
compare [Syscall_result_intf.Arg] |
compare [Syscall_result_intf.S] |
compare [Time_stamp_counter] |
compare [Zone.Stable.V1] |
compare [User_and_group.Stable.V1] |
compare [Uuid.Stable.V1] |
compare [Time_ns.Stable.V1] |
compare [Time.Stable.With_utc_sexp.V1] |
compare [Time.Stable.V1] |
compare [Span.Stable.V2] |
compare [Span.Stable.V1] |
compare [Span.Unit_of_time] |
compare [Piecewise_linear_intf.S] |
compare [Piecewise_linear.Stable.V1.Make_invertible] |
compare [Piecewise_linear.Stable.V1.Make] |
compare [Ofday.Stable.V1] |
compare [Linux_ext.Timerfd.Clock] |
compare [Linux_ext.Timerfd] |
compare [Date0.Stable.V1] |
compare [Core_unix.Exit_or_signal] |
compare [Core_unix.Exit] |
compare_error [Unix_error] |
compare_error [Core_unix.Exit_or_signal] |
compare_error [Core_unix.Exit] |
compare_t [Unix_error] |
compare_value [Interval_intf.Gen] |
concat [Core_filename] | `concat p1 p2` returns a path equivalent to `p1 ^ "/" ^ p2`.
connect [Core_unix] | Connect a socket to an address.
const [Command.Spec] | Superceded by `return`, preserved for backwards compatibility
consume_bin_prot [Iobuf] |
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 [Core_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 [Core_unix.RLimit] |
crc32 [Iobuf] |
crc32 [Crc] | Compute the 32-bit crc
crc32hex [Crc] | String version of the crc, encoded in hex.
creat [Core_unix.Open_flags] | creation
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 [Time_ns.Span] |
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 [Core_unix.Resource_usage.Fields] |
create [Core_unix.Cidr] |
create [Core_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 [Core_mutex] |
create [Core_condition] |
create [Command.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_error [Syscall_result_intf.S] |
create_error [Syscall_result] |
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 [Limiter.Expert] | - `time` is the reference time that other time accepting functions will use when they adjust `now`.
create_exn [Limiter.Throttled_rate_limiter] |
create_exn [Limiter.Throttle] |
create_exn [Limiter.Token_bucket] |
create_exn [Date0] | `create_exn ~y ~m ~d` creates the date specified in the arguments.
create_from_intervals [Interval_intf.Gen_set] |
create_from_linear_combination [Piecewise_linear_intf.S] | Returns the `t` such that `get t key` = sum (`get t_i key`) * `weight_i`.
create_local [Ofday.Zoned] |
create_ok [Syscall_result_intf.S] |
create_process [Core_unix] | `create_process ~prog ~args` forks a new process that executes the program `prog` with arguments `args`.
create_process_env [Core_unix] | `create_process_env ~prog ~args ~env` as `create_process`, but takes an additional parameter that extends or replaces the current environment.
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 [Core_mutex] |
current_dir_name [Core_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 [Core_unix.RLimit] |
date [Command.Arg_type.Export] | `time` requires a time zone.
dates_between [Date0] |
day [Time_ns.Span] |
day [Span] |
day [Date0] |
day_of_week [Date0] |
decimal [Iobuf.Poke] | `decimal t ~pos i` returns the number of bytes written at `pos`.
decimal [Iobuf.Fill] |
decr [Linux_ext.Priority] |
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 [Core_thread] | `delay d` suspends the execution of the calling thread for `d` seconds.
descr_of_in_channel [Core_unix] | Return the descriptor corresponding to an input channel.
descr_of_out_channel [Core_unix] | Return the descriptor corresponding to an output channel.
diff [Time_internal.T] |
diff [Time_stamp_counter] |
diff [Time_ns] |
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 [Core_filename] | The directory separator (e.g.
dirfd [Core_unix] |
dirname [Core_filename] | See `Filename.basename`.
div [Time_ns.Span] |
does_match [Core_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 [Core_unix] | Return the socket domain adequate for the given socket address.
drop [Core_unix.IOVec] | `drop iovec n` drops `n` characters from `iovec`.
dsync [Core_unix.Open_flags] |
dup [Core_unix] | Return a new file descriptor referencing the same file as the given descriptor.
dup2 [Core_unix] | `dup2 ~src ~dst` duplicates `src` to `dst`, closing `dst` if already opened.
E
empty [Interval_intf.Gen] |
empty [Core_unix.IOVec] | `empty` the empty I/O-vector.
empty [Core_unix.Select_fds] |
empty [Command.Spec] | the empty command-line spec
end_of_day [Time_ns.Ofday] |
endpwent [Core_unix.Passwd.Low_level] |
env_of_sexp [Core_unix] | `env` is used to control the environment of a child process, and can take three forms.
environment [Core_unix] | Return the process environment, as an array of strings with the format ``variable=value''.
epoch [Time0.Stable.V1] |
epoch [Time_ns] | Unix epoch (1970-01-01 00:00:00 UTC)
epoch [Time] | midnight, Jan 1, 1970 in UTC
equal [Signal] |
equal [Nano_mutex] | `equal` is `phys_equal`
equal [Mutex0] |
equal [Linux_ext.Priority] |
equal [Core_mutex] |
equal [Core_condition] |
err [Linux_ext.Epoll.Flags] |
error_exn [Syscall_result_intf.S] |
error_message [Core_unix] | Return a string describing the given error code.
error_of_sexp [Unix_error] |
error_of_sexp [Core_unix.Exit_or_signal_or_stop] |
error_of_sexp [Core_unix.Exit_or_signal] |
error_of_sexp [Core_unix.Exit] |
error_of_sexp [Core_unix] |
escape [Command.Deprecated.Spec] |
escape [Command.Flag] | `escape` flags may be passed at most once.
establish_server [Core_unix] | Establish a server on the given address.
et [Linux_ext.Epoll.Flags] |
eval_string [Core_install_printers] |
excl [Core_unix.Open_flags] |
exec [Core_unix] | `exec ~prog ~args ?search_path ?env` execs `prog` with `args`.
exec [Command] | `exec ~summary ~path_to_exe` runs `exec` on the executable at `path_to_exe`.
executable_name [Core_sys] | The name of the file containing the executable currently running.
execution_mode [Core_sys] | `execution_mode` tests whether the code being executed was compiled natively or to bytecode.
exists [Core_unix.Resource_usage.Fields] |
exit [Core_thread] | Terminate prematurely the currently executing thread.
exit_immediately [Core_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 [Core_unix] | Change the permissions of an opened file.
fchown [Core_unix] | Change the owner uid and owner gid of an opened file.
fcntl_getfl [Core_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 [Core_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 [Core_unix] | Synchronize the kernel buffers of a given file descriptor with disk, but do not necessarily write file attributes.
file [Command.Arg_type.Export] |
file [Command.Arg_type] | `file` defines an `Arg_type.t` that completes in the same way as `Command.Spec.file`, but perhaps with a different type than `string` or with an autocompletion key.
file_descr_realpath [Linux_ext] | `file_descr_realpath fd`
file_exists [Core_sys] | `file_exists ~follow_symlinks path`
file_exists_exn [Core_sys] | Same as `file_exists` but blows up on ``Unknown`
file_kind_of_sexp [Core_unix] |
file_perm_of_sexp [Core_unix] | The type of file access rights.
file_size [Core_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.
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_or_add [Weak_hashtbl] |
finish_job [Limiter.Throttled_rate_limiter] |
finish_job [Limiter.Throttle] |
first_knot [Piecewise_linear_intf.S] |
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.Param.S] | `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 `Caml.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.Arg_type.Export] |
float_of_hh_mm_ss [Time_internal] |
flock [Core_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 [Core_unix.Terminal_io] |
flush_queue_of_sexp [Core_unix.Terminal_io] |
fnmatch [Core_unix] |
fold [Core_unix.Resource_usage.Fields.Direct] |
fold [Core_unix.Resource_usage.Fields] |
fold_dir [Core_sys] |
fold_ready [Linux_ext.Epoll] |
following_weekday [Date0] |
for_all [Core_unix.Resource_usage.Fields] |
for_testing [Uuid.Stable.V1] |
for_this_process [User_and_group] | Get the `t` for the current process.
for_this_process_exn [User_and_group] |
fork [Core_unix] | `fork ()` forks a new process.
fork_exec [Core_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 [Core_unix.Native_file] | Return the information for the file associated with the given descriptor.
fstat [Core_unix] | Return the information for the file associated with the given descriptor.
fsync [Core_unix] |
ftruncate [Core_unix.Native_file] |
ftruncate [Core_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 [Core_unix.Resource_usage] |
get [Core_unix.RLimit] |
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 [Core_unix] | `get_mcast_loop sock` reads the boolean argument that determines whether sent multicast packets are looped back to local sockets.
get_mcast_ttl [Core_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_pid [Lock_file] | `get_pid path` reads the lock file at `path` and returns the pid in the file.
get_process_clock [Linux_ext.Clock] | `get_process_clock` the clock measuring the CPU-time of a process.
get_resolution [Linux_ext.Clock] |
get_sexp_zone [Time0.Stable.V1] |
get_sexp_zone [Time] | Sexp conversions use the local timezone by default.
get_sockaddr [Core_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 [Core_unix] | `getaddrinfo host service opts` returns a list of `Unix.addr_info` records describing socket parameters and addresses suitable for communicating with the given host and service.
getaddrinfo_option_of_sexp [Core_unix] | Options to `Unix.getaddrinfo`.
getbyaddr [Core_unix.Host] | Find an entry in `hosts` with the given address.
getbyaddr_exn [Core_unix.Host] |
getbygid [Core_unix.Group] |
getbygid_exn [Core_unix.Group] |
getbyname [Core_unix.Service] | Find an entry in `services` with the given name.
getbyname [Core_unix.Protocol] | Find an entry in `protocols` with the given name.
getbyname [Core_unix.Host] | Find an entry in `hosts` with the given name.
getbyname [Core_unix.Group] |
getbyname [Core_unix.Passwd] |
getbyname_exn [Core_unix.Service] |
getbyname_exn [Core_unix.Protocol] |
getbyname_exn [Core_unix.Host] |
getbyname_exn [Core_unix.Group] |
getbyname_exn [Core_unix.Passwd] |
getbynumber [Core_unix.Protocol] | Find an entry in `protocols` with the given protocol number.
getbynumber_exn [Core_unix.Protocol] |
getbyport [Core_unix.Service] | Find an entry in `services` with the given service number.
getbyport_exn [Core_unix.Service] |
getbyuid [Core_unix.Passwd] |
getbyuid_exn [Core_unix.Passwd] |
getcwd [Core_unix] | Return the name of the current working directory.
getcwd [Core_sys] | Return the current working directory of the process.
getegid [Core_unix] | Return the effective group id under which the process runs.
getenv [Core_sys] | Return the value associated to a variable in the process environment.
getenv_exn [Core_sys] |
geteuid [Core_unix] | Return the effective user id under which the process runs.
getgid [Core_unix] | Return the group id of the user executing the process.
getgrouplist [Core_unix] | `getgrouplist user group` returns the list of groups to which `user` belongs.
getgroups [Core_unix] | Return the list of groups to which the user executing the process belongs.
gethostname [Core_unix] | Return the name of the local host.
getitimer [Core_unix] | Return the current status of the given interval timer.
getlogin [Core_unix] | Return the login name of the user executing the process.
getnameinfo [Core_unix] | `getnameinfo addr opts` returns the host name and service name corresponding to the socket address `addr`.
getnameinfo_option_of_sexp [Core_unix] | Options to `Unix.getnameinfo`.
getpeername [Core_unix] | Return the address of the host connected to the given socket.
getpid [Core_unix] | Return the pid of the process.
getppid [Core_unix] | Return the pid of the parent process.
getppid_exn [Core_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 [Core_unix.Passwd.Low_level] |
getpwent_exn [Core_unix.Passwd.Low_level] |
getpwents [Core_unix.Passwd] | `getpwents` is a thread-safe wrapper over the low-level passwd database functions.
getsockname [Core_unix] | Return the address of the given socket.
getsockopt [Core_unix] |
getsockopt_float [Core_unix] | Same as `UnixLabels.getsockopt` for a socket option whose value is a floating-point number.
getsockopt_int [Core_unix] | Same as `UnixLabels.getsockopt` for an integer-valued socket option.
getsockopt_optint [Core_unix] | Same as `UnixLabels.getsockopt` for a socket option whose value is an `int option`.
gettcpopt_bool [Linux_ext] | `gettcpopt_bool sock opt`
gettid [Core_unix] | Get the numeric ID of the current thread, e.g.
gettimeofday [Core_unix] | Same as `Core_unix.time` above, but with resolution better than 1 second.
getuid [Core_unix] | Return the user id of the user executing the process.
gmtime [Core_unix] | Convert a time in seconds, as returned by `UnixLabels.time`, into a date and a time.
group [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 [Core_unix] | `handle_unix_error f` runs `f ()` and returns the result.
have_address_in_common [Core_unix.Host] |
help [Command.Param.S] | the help text for the command
help_recursive [Command.Deprecated] |
hi [Iobuf.Expert] |
hi_max [Iobuf.Expert] |
hopper_to_bucket_rate_per_sec [Limiter] |
hour [Time_ns.Span] |
hour [Span] |
hup [Signal] | `Terminate` Hangup on controlling terminal
hup [Linux_ext.Epoll.Flags] |
I
id [Core_thread] | Return the identifier of the given thread.
idrss [Core_unix.Resource_usage.Fields] |
idrss [Core_unix.Resource_usage] |
if_indextoname [Core_unix] |
ignore [Signal] | `ignore t` is `set t `Ignore`.
ignore_ok_value [Syscall_result] | Keep only the error.
ill [Signal] | `Dump_core` Invalid hardware instruction
in_ [Linux_ext.Epoll.Flags] |
in_bucket [Limiter] | tokens available to immediately take
in_channel_of_descr [Core_unix] | Create an input channel reading from the given descriptor.
in_channel_realpath [Linux_ext] | `in_channel_realpath ic`
in_flight [Limiter] | tokens that have been taken, but not yet returned
in_hopper [Limiter] | tokens waiting to drop at the `hopper_to_bucket_rate_per_sec`
in_limiter [Limiter] | total number of tokens in the limiter `in_hopper + in_bucket`
in_system [Limiter] | total number of tokens in the entire system `in_hopper + in_bucket + in_flight`
inblock [Core_unix.Resource_usage.Fields] |
inblock [Core_unix.Resource_usage] |
incr [Linux_ext.Priority] |
inet4_addr_of_int32 [Core_unix.Inet_addr] | Some things (like the kernel) report addresses as hex or decimal strings.
inet4_addr_to_int32_exn [Core_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 [Core_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`.
install_printers [Core_install_printers] |
int [Signal] | `Terminate` Interactive interrupt (ctrl-C)
int [Command.Arg_type.Export] |
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_be_trunc [Iobuf_intf.Accessors] |
int64_le [Iobuf_intf.Accessors] |
int64_le_trunc [Iobuf_intf.Accessors] |
int64_t_be [Iobuf_intf.Accessors] |
int64_t_le [Iobuf_intf.Accessors] |
int8 [Iobuf_intf.Accessors] |
interactive [Core_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_ns] | `interruptible_pause span` sleeps for `span` time unless interrupted (e.g.
interruptible_pause [Time] | `interruptible_pause span` sleeps for span time unless interrupted (e.g.
intersect [Interval_intf.Gen] |
interval_timer_of_sexp [Core_unix] | The three kinds of interval timers.
interval_timer_status_of_sexp [Core_unix] | The type describing the status of an interval timer
invalid_range [Time_internal.Helpers] |
invariant [Nano_mutex] |
invariant [Linux_ext.Epoll] |
is_absolute [Core_filename] |
is_business_day [Date0] | Monday through Friday are business days, unless they're a holiday.
is_directory [Core_sys] | Returns ``Yes` if the file exists and is a directory
is_directory_exn [Core_sys] |
is_earlier [Time0.Stable.V1] |
is_earlier [Time] | `is_earlier` and `is_later` are like using `<.`, but easier to read.
is_empty [Iobuf] | `is_empty t` is `length t = 0`.
is_empty [Interval_intf.Gen] |
is_empty_or_singleton [Interval_intf.Gen] |
is_error [Syscall_result_intf.S] |
is_file [Core_sys] | Returns ``Yes` if the file exists and is a regular file
is_file_exn [Core_sys] |
is_implicit [Core_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_later [Time0.Stable.V1] |
is_later [Time] |
is_locked [Lock_file] | `is_locked path` returns true when the file at `path` exists and is locked, false otherwise.
is_none [Time_ns.Option] |
is_none [Time_ns.Span.Option] |
is_ok [Syscall_result_intf.S] |
is_posix_pathname_component [Core_filename] | `is_posix_pathname_component f`
is_relative [Core_filename] | Return `true` if the file name is relative to the current directory, `false` if it is absolute (i.e.
is_some [Time_ns.Option] |
is_some [Time_ns.Span.Option] |
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 [Core_unix] | Return `true` if the given file descriptor refers to a terminal or console window, `false` otherwise.
isrss [Core_unix.Resource_usage.Fields] |
isrss [Core_unix.Resource_usage] |
iter [Linux_ext.Epoll] |
iter [Core_unix.Resource_usage.Fields.Direct] |
iter [Core_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 [Core_unix.Resource_usage.Fields] |
ixrss [Core_unix.Resource_usage] |
J
join [Core_thread] | `join th` suspends the execution of the calling thread until the thread `th` has terminated.
K
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
last_knot [Piecewise_linear_intf.S] |
lbound [Interval_intf.Gen_set] |
lbound [Interval_intf.Gen] |
lbound_exn [Interval_intf.Gen_set] |
lbound_exn [Interval_intf.Gen] |
length [Squeue] | returns the number of elements in the queue.
length [Iobuf] | `length t` returns the size of `t`'s window.
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 [Core_unix.RLimit] |
link [Core_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.Flag] | `listed` flags may be passed zero or more times
listen [Core_unix] | Set up a socket for receiving connection requests.
lo [Iobuf.Expert] |
lo_min [Iobuf.Expert] |
local [Zone] | `local` is the machine's local timezone, as determined from the `TZ` environment variable or the `/etc/localtime` file.
local_now [Time_ns.Ofday] |
localhost [Core_unix.Inet_addr] | Special addresses representing the host machine.
localhost_inet6 [Core_unix.Inet_addr] |
localtime [Core_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 [Core_mutex] | `lock mtx` locks `mtx`, possibly waiting for it to be released first by another thread.
lock_command_of_sexp [Core_unix] | Commands for `Core_unix.lockf`.
lock_exclusive [Core_unix.Flock_command] |
lock_exn [Nano_mutex] |
lock_shared [Core_unix.Flock_command] |
lockf [Core_unix] |
lpop [Squeue] | returns the element popped and the length of the queue after this element was popped.
ls_dir [Core_sys] | Same as `readdir`, but return a list rather than an array.
lseek [Core_unix.Native_file] |
lseek [Core_unix] |
lstat [Core_unix.Native_file] | Same as `UnixLabels.stat`, but in case the file is a symbolic link, return the information for the link itself.
lstat [Core_unix] | Same as `UnixLabels.stat`, but in case the file is a symbolic link, return the information for the link itself.
M
machine [Core_unix.Utsname] |
majflt [Core_unix.Resource_usage.Fields] |
majflt [Core_unix.Resource_usage] |
make_creator [Core_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 [Core_unix.Resource_usage.Fields] |
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 [Core_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_iovecs [Core_unix.IOVec] |
max_value [Time_ns.Span] |
max_value [Time_ns] |
maxrss [Core_unix.Resource_usage.Fields] |
maxrss [Core_unix.Resource_usage] |
maybe [Command.Anons] | `(maybe anons)` indicates that some anonymous arguments are optional
maybe_with_default [Command.Anons] | `(maybe_with_default default anons)` indicates an optional anonymous argument with a default value
mcast_join [Core_unix] | `mcast_join ?ifname sock addr` join a multicast group at `addr` with socket `sock`, from source at `source` if specified, optionally using network interface `ifname`.
mcast_leave [Core_unix] | `mcast_leave ?ifname sock addr` leaves a multicast group at `addr` with socket `sock`, optionally using network interface `ifname`.
mem [Weak_hashtbl] |
message [Core_unix.Error] | Return a string describing the given error code.
microsecond [Time_ns.Span] |
microsecond [Span] |
millisecond [Time_ns.Span] |
millisecond [Span] |
min_value [Time_ns.Span] |
min_value [Time_ns] |
minflt [Core_unix.Resource_usage.Fields] |
minflt [Core_unix.Resource_usage] |
minute [Time_ns.Span] |
minute [Span] |
mkdir [Core_unix] | Create a directory.
mkdir_p [Core_unix] | Create a directory recursively.
mkdtemp [Core_unix] | `mkdtemp prefix` creates a temporary directory with `prefix`, automatically appending a suffix of six random characters to make the name unique.
mkfifo [Core_unix] | Create a named pipe with the given permissions.
mknod [Core_unix] | `mknod ?file_kind ?perm ?major ?minor path` creates a filesystem entry.
mkstemp [Core_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 [Core_unix] | Convert a date and time, specified by the `tm` argument, into a time in seconds, as returned by `UnixLabels.time`.
mlockall [Core_unix.Mman] |
monotonic [Linux_ext.Timerfd.Clock] | Nonsettable clock.
month [Date0] |
msg_flag_of_sexp [Core_unix] | The flags for `UnixLabels.recv`, `UnixLabels.recvfrom`, `UnixLabels.send` and `UnixLabels.sendto`.
msgrcv [Core_unix.Resource_usage.Fields] |
msgrcv [Core_unix.Resource_usage] |
msgsnd [Core_unix.Resource_usage.Fields] |
msgsnd [Core_unix.Resource_usage] |
multicast [Core_unix.Cidr] | IPv4 multicast address can be represented by the CIDR prefix 224.0.0.0/4, (i.e.
munlockall [Core_unix.Mman] |
N
name [Zone] | `name zone` returns the name of the time zone
name_info_of_sexp [Core_unix] | Host and service information returned by `Unix.getnameinfo`.
names [Core_unix.Resource_usage.Fields] |
nanosecond [Time_ns.Span] |
nanosecond [Span] |
nanosleep [Core_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.
narrow_hi [Iobuf] | `narrow_hi t` sets `t`'s upper limit to the end of the current window.
narrow_lo [Iobuf] | `narrow_lo t` sets `t`'s lower limit to the beginning of the current window.
neg [Time_ns.Span] |
neg [Span] | negation
netmask_of_bits [Core_unix.Cidr] | Return the netmask corresponding to the number of network bits in the CIDR.
next_clock_shift [Zone] | Takes a `Time.t` and returns the next `Time.t` strictly after it, if any, that the time zone UTC offset changes, and by how much it does so.
next_multiple [Time0.Stable.V1] |
next_multiple [Time_ns] | See `Core_kernel.Time_ns`
next_multiple [Time] |
nice [Core_unix.Priority] |
nice [Core_unix.RLimit] |
nice [Core_unix] | Change the process priority.
nivcsw [Core_unix.Resource_usage.Fields] |
nivcsw [Core_unix.Resource_usage] |
no_arg [Command.Deprecated.Spec] |
no_arg [Command.Flag] | `no_arg` flags may be passed at most once.
no_arg_abort [Command.Flag] | `no_arg_abort ~exit` is like `no_arg`, but aborts command-line parsing by calling `exit`.
no_arg_register [Command.Flag] | `no_arg_register ~key ~value` is like `no_arg`, but associates `value` with `key` in the in the auto-completion environment
no_seek [Iobuf] |
noctty [Core_unix.Open_flags] |
nodename [Core_unix.Utsname] |
non_empty_sequence [Command.Anons] | `non_empty_sequence anons` is like `sequence anons` except an exception will be raised if there is not at least one anonymous argument given.
nonblock [Linux_ext.Timerfd.Flags] | `TFD_NONBLOCK`
nonblock [Core_unix.Open_flags] |
none [Time_ns.Option] |
none [Time_ns.Span.Option] |
none [Linux_ext.Epoll.Flags] |
now [Time_internal.T] |
now [Time_stamp_counter] |
now [Time_ns] |
now [Time.Ofday] |
now [Time] |
nsignals [Core_unix.Resource_usage.Fields] |
nsignals [Core_unix.Resource_usage] |
nswap [Core_unix.Resource_usage.Fields] |
nswap [Core_unix.Resource_usage] |
num_file_descriptors [Core_unix.RLimit] |
num_threads [Core_thread] | `num_threads ()` attempts to return the number of currently running threads by parsing /proc.
nvcsw [Core_unix.Resource_usage.Fields] |
nvcsw [Core_unix.Resource_usage] |
O
ocaml_version [Core_sys] | `ocaml_version` is the version of Objective Caml.
occurrence [Time0.Stable.V1] |
occurrence [Time_ns] |
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.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 [Core_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 [Core_unix.Exit] |
of_date_ofday [Time0.Stable.V1] |
of_date_ofday [Time_ns] |
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 [Time_ns.Span] |
of_day [Span] |
of_epoch [Time0.Stable.V1] |
of_epoch_internal [Time0.Stable.V1] |
of_errno [Unix_error] |
of_filename_string [Time0.Stable.V1] |
of_filename_string [Time] | `of_filename_string s ~zone` converts `s` that has format YYYY-MM-DD_HH-MM-SS.mmm into time.
of_hr [Time_ns.Span] |
of_hr [Span] |
of_int [Linux_ext.Priority] |
of_int [Core_unix.File_descr] |
of_int63_ns [Time_ns.Span] | Fast, implemented as the identity function.
of_int63_ns_since_epoch [Time_ns] |
of_int_exn [Syscall_result_intf.Arg] |
of_int_ns [Time_ns.Span] |
of_int_ns_since_epoch [Time_ns] |
of_int_sec [Time_ns.Span] |
of_int_sec [Span] |
of_local_time [Time_ns.Ofday] |
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.Arg_type] | an auto-completing Arg_type over a finite set of values
of_min [Time_ns.Span] |
of_min [Span] |
of_ms [Time_ns.Span] |
of_ms [Span] |
of_ns [Time_stamp_counter.Span] |
of_ns [Time_ns.Span] |
of_ns [Span] |
of_ofday [Time_ns.Ofday] |
of_option [Time_ns.Option] |
of_params [Command.Spec] |
of_parts [Time_ns.Span] |
of_parts [Core_filename] | `of_parts parts` joins a list of path components into a path.
of_sec [Time_ns.Span] |
of_sec [Span] |
of_span [Time_ns.Span] |
of_span_since_epoch [Time_ns] |
of_span_since_start_of_day [Ofday] |
of_span_since_start_of_day_exn [Time_ns.Ofday] | `of_span_since_start_of_day_exn` excludes obviously impossible times of day but cannot exclude all invalid times of day due to DST, leap seconds, etc.
of_string [Time0.Stable.V1] |
of_string [Span] |
of_string [Iobuf] | `of_string s` returns a new iobuf whose contents are `s`.
of_string [Core_unix.IOVec] | `of_string ?pos ?len str`
of_string [Core_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_ns] |
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 [Core_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 [Core_unix.Error] |
of_time [Time_ns] |
of_time [Date] |
of_tm [Date0] |
of_unit_of_time [Span] | `of_unit_of_time unit_of_time` produces a `t` representing the corresponding span.
of_unix [Core_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 [Core_unix.Exit_or_signal] | `of_unix` assumes that any signal numbers in the incoming value are O'Caml internal signal numbers.
of_us [Time_ns.Span] |
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] |
ok_exn [Syscall_result_intf.S] |
ok_or_unix_error_exn [Syscall_result_intf.S] |
ok_or_unix_error_with_args_exn [Syscall_result_intf.S] |
one_or_more [Command.Flag] | `one_or_more` flags must be passed one or more times
oneshot [Linux_ext.Epoll.Flags] |
open_connection [Core_unix] | Connect to a server at the given address.
open_flag_of_sexp [Core_unix] |
open_process [Core_unix] | See `UnixLabels.open_process_in`.
open_process_full [Core_unix] |
open_process_in [Core_unix] | High-level pipe and process management.
open_process_out [Core_unix] | See `UnixLabels.open_process_in`.
open_temp_file [Core_filename] | Same as `Core_filename.temp_file`, but returns both the name of a fresh temporary file, and an output channel opened (atomically) on this file.
opendir [Core_unix] | Open a descriptor on a directory
openfile [Core_unix] | Open the named file with the given flags.
openlog [Syslog] | `openlog ~id ~options ~facility ()` opens a connection to the system logger (possibly delayed) using prefixed identifier `id`, `options`, and `facility`.
optional [Command.Flag] | optional flags may be passed at most once
optional_with_default [Command.Flag] | `optional_with_default` flags may be passed at most once, and default to a given value
or_error [Core_unix.Exit_or_signal_or_stop] |
or_error [Core_unix.Exit_or_signal] |
or_error [Core_unix.Exit] |
os_type [Core_sys] | Operating system currently executing the Caml program.
oublock [Core_unix.Resource_usage.Fields] |
oublock [Core_unix.Resource_usage] |
out [Linux_ext.Epoll.Flags] |
out_channel_of_descr [Core_unix] | Create an output channel writing on the given descriptor.
out_channel_realpath [Linux_ext] | `out_channel_realpath oc`
output [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
pair [Command.Spec] | Superceded by `both`, preserved for backwards compatibility
parent_dir_name [Core_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 [Core_filename] | `parts filename` returns a list of path components in order.
path [Command.Param.S] | the subcommand path of the command
pause [Time0.Stable.V1] | Pause and don't allow events to interrupt.
pause [Time_ns] | `pause span` sleeps for `span` time.
pause [Time] | `pause span` sleeps for span time.
pause [Core_unix] | Wait until a non-ignored, non-blocked signal is delivered.
pause_for [Time0.Stable.V1] |
pause_forever [Time0.Stable.V1] |
pause_forever [Time_ns] | `pause_forever` sleeps indefinitely.
pause_forever [Time] | `pause_forever` sleeps indefinitely.
phys_equal [Mutex0] |
pipe [Signal] | `Terminate` Broken pipe
pipe [Core_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`.
precache [Piecewise_linear_intf.S] | `precache t` computes and stores a lookup table in `t` that speeds up subsequent calls to `get t`.
prev_clock_shift [Zone] | As `next_clock_shift`, but strictly *before* the given time.
previous_weekday [Date0] |
pri [Linux_ext.Epoll.Flags] |
printers [Core_install_printers] |
process_times_of_sexp [Core_unix] | The execution times (CPU times) of a process.
prof [Signal] | `Terminate` Profiling interrupt
protect_window_and_bounds [Iobuf] | `protect_window_and_bounds t ~f` applies `f` to `t` and restores `t`'s bounds afterwards.
pselect [Core_unix] | `pselect rfds wfds efds timeout sigmask` like `Core_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 [Core_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 [Core_filename] | Return a quoted version of a file name, suitable for use as one argument in a command line, escaping all meta-characters.
R
random [Time_ns.Span] |
random [Time_ns] |
randomize [Time_ns.Span] |
randomize [Span] | `randomize t ~percent` returns a span +/- percent * original span.
rdonly [Core_unix.Open_flags] | access mode.
rdwr [Core_unix.Open_flags] |
read [Core_unix] | `read fd buff ofs len` reads `len` characters from descriptor `fd`, storing them in string `buff`, starting at position `ofs` in string `buff`.
read [Bigstring] | `read ?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 [Core_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.
read_only [Iobuf] | Generalization
readdir [Core_unix] | Return the next entry in a directory.
readdir [Core_sys] | Return the names of all files present in the given directory.
readdir_ino [Core_unix] | `readdir_ino dh` return the next entry in a directory ((`(filename, inode)`).
readlink [Core_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 [Core_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 [Core_unix] | Receive data from a connected socket.
recvfrom [Core_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] |
reinterpret_error_exn [Syscall_result_intf.S] | This is more efficient than calling `error_exn` and then the `create_error` of the destination type.
release [Core_unix.Utsname] |
remove [Weak_hashtbl] |
remove [Linux_ext.Epoll] |
remove [Core_unix] | Removes the named file or directory
remove [Core_sys] | Remove the given file name from the file system.
rename [Core_unix] | `rename old new` changes the name of a file from `old` to `new`.
rename [Core_sys] | Rename a file.
replace [Weak_hashtbl] |
required [Command.Flag] | 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 [Core_unix.RLimit] |
restore [Iobuf_intf.Bound] |
retry_until_no_eintr [Core_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.
return_to_hopper [Limiter.Expert] | return the given number of tokens to the hopper.
rewind [Iobuf] | `rewind t` sets the lower bound of the window to the lower limit.
rewinddir [Core_unix] | Reposition the descriptor to the beginning of the directory
rmdir [Core_unix] | Remove an empty directory.
robust_comparison_tolerance [Span] |
root [Core_filename] | The path of the root.
rsync [Core_unix.Open_flags] |
run [Command.Deprecated] |
run [Command] | Run a command against `Sys.argv`, or `argv` if it is specified.
S
scale [Time_ns.Span] |
scale [Span] |
scale_int [Time_ns.Span] |
sched_setaffinity [Linux_ext] |
sched_setaffinity_this_thread [Linux_ext] |
sec [Std] |
second [Time_ns.Span] |
second [Span] |
seek_command_of_sexp [Core_unix] | POSITIONING modes for `UnixLabels.lseek`.
segv [Signal] | `Dump_core` Invalid memory reference
select [Core_unix] | Setting restart to true means that we want select to restart automatically on EINTR (instead of propagating the exception)...
self [Core_thread] | Return the thread currently executing.
send [Signal] | `send signal pid_spec` sends `signal` to the processes specified by `pid_spec`.
send [Core_unix] | Send data over a connected socket.
send_exn [Signal] |
send_i [Signal] |
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 [Core_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.Anons] | `sequence anons` specifies a sequence of anonymous arguments.
set [Signal.Expert] | `set t b` is `ignore (signal t b)`
set [Linux_ext.Epoll] |
set [Core_unix.Scheduler] |
set [Core_unix.RLimit] |
set_after [Linux_ext.Timerfd] |
set_all_mutable_fields [Core_unix.Resource_usage.Fields.Direct] |
set_at [Linux_ext.Timerfd] | `set_at t at` and `set_after t span` set `t` to fire once, at `at` or after `span`.
set_bounds_and_buffer [Iobuf] | `set_bounds_and_buffer ~src ~dst` copies bounds metadata (i.e., limits and window) and shallowly copies the buffer (data pointer) 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_shared ?pos ?len src) ~dst`.
set_bucket_size_exn [Limiter.Expert] |
set_close_on_exec [Core_unix] | Set the ``close-on-exec'' flag on the given descriptor.
set_hopper_to_bucket_rate_per_sec_exn [Limiter.Expert] |
set_in_channel_timeout [Core_unix] | Set a timeout for a socket associated with an `in_channel`
set_mcast_ifname [Core_unix] | `set_mcast_ifname sock "eth0"` sets outgoing multicast traffic on IPv4 UDP socket `sock` to go out through interface `eth0`.
set_mcast_loop [Core_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 [Core_unix] | `set_mcast_ttl sock ttl` sets the time-to-live value of outgoing multicast packets for socket `sock` to `ttl`.
set_nonblock [Core_unix] | Set the ``non-blocking'' flag on the given descriptor.
set_out_channel_timeout [Core_unix] | Set a timeout for a socket associated with an `out_channel`
set_repeating [Linux_ext.Timerfd] |
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_sexp_zone [Time0.Stable.V1] |
set_sexp_zone [Time] |
set_time [Linux_ext.Clock] |
set_token_target_level_exn [Limiter.Expert] | sets the target token level for the limiter going forward.
setgid [Core_unix] | Set the real group id and effective group id for the process.
setitimer [Core_unix] | `setitimer t s` sets the interval timer `t` and returns its previous status.
setlogmask [Syslog] | All levels in `allowed_levels` will be allowed, and additionally all ranging from `from_level` to `to_level` (inclusive).
setpriority [Linux_ext] | Set the calling thread's priority in the linux scheduler
setpwent [Core_unix.Passwd.Low_level] |
setsid [Core_unix.Terminal_io] | Put the calling process in a new session and detach it from its controlling terminal.
setsockopt [Core_unix] | Set or clear a boolean-valued option in the given socket.
setsockopt_float [Core_unix] | Same as `UnixLabels.setsockopt` for a socket option whose value is a floating-point number.
setsockopt_int [Core_unix] | Same as `UnixLabels.setsockopt` for an integer-valued socket option.
setsockopt_optint [Core_unix] | Same as `UnixLabels.setsockopt` for a socket option whose value is an `int option`.
settcpopt_bool [Linux_ext] | `settcpopt_bool sock opt v` sets the current value of the boolean TCP socket option `opt` for socket `sock` to value `v`.
setuid [Core_unix] | Sets the real user id and effective user id for the process.
sexp_of_addr_info [Core_unix] |
sexp_of_env [Core_unix] |
sexp_of_error [Unix_error] |
sexp_of_error [Core_unix.Exit_or_signal_or_stop] |
sexp_of_error [Core_unix.Exit_or_signal] |
sexp_of_error [Core_unix.Exit] |
sexp_of_error [Core_unix] | Unknown error
sexp_of_file_kind [Core_unix] | Socket
sexp_of_file_perm [Core_unix] |
sexp_of_flow_action [Core_unix.Terminal_io] |
sexp_of_flush_queue [Core_unix.Terminal_io] |
sexp_of_getaddrinfo_option [Core_unix] |
sexp_of_getnameinfo_option [Core_unix] |
sexp_of_interval_timer [Core_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 [Core_unix] |
sexp_of_limit [Core_unix.RLimit] |
sexp_of_limiter [Limiter] |
sexp_of_lock_command [Core_unix] | Lock a region for reading, or fail if already locked
sexp_of_msg_flag [Core_unix] |
sexp_of_name_info [Core_unix] | Name of service or port number
sexp_of_no_seek [Iobuf_intf] |
sexp_of_no_seek [Iobuf] |
sexp_of_open_flag [Core_unix] |
sexp_of_process_times [Core_unix] |
sexp_of_resource [Core_unix.RLimit] |
sexp_of_seek [Iobuf_intf] |
sexp_of_seek [Iobuf] |
sexp_of_seek_command [Core_unix] | indicates positions relative to the end of the file
sexp_of_select_timeout [Core_unix] |
sexp_of_setattr_when [Core_unix.Terminal_io] |
sexp_of_shutdown_command [Core_unix] | Close both
sexp_of_sockaddr [Core_unix] |
sexp_of_socket_bool_option [Core_unix] | Forbid binding an IPv6 socket to an IPv4 address
sexp_of_socket_domain [Core_unix] |
sexp_of_socket_float_option [Core_unix] | Timeout for output operations
sexp_of_socket_int_option [Core_unix] |
sexp_of_socket_type [Core_unix] |
sexp_of_stats [Core_unix.Native_file] |
sexp_of_stats [Core_unix] |
sexp_of_sys_behavior [Signal] |
sexp_of_sysconf [Core_unix] |
sexp_of_t [Unix_error] |
sexp_of_t [Time0.Stable.With_utc_sexp.V1] |
sexp_of_t [Time0.Stable.V1.C] |
sexp_of_t [Time0.Stable.V1.Epoch_cache] |
sexp_of_t [Time0.Stable.V1] |
sexp_of_t [Syslog.Level] |
sexp_of_t [Syslog.Facility] | LOCAL0-7 reserved for local use
sexp_of_t [Syslog.Open_option] | Print to stderr as well
sexp_of_t [Syscall_result_intf.Arg] |
sexp_of_t [Syscall_result_intf.S] |
sexp_of_t [Weak_hashtbl] |
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_ns.Ofday.Stable.V1] |
sexp_of_t [Time_ns.Option.Stable.V1] |
sexp_of_t [Time_ns.Span.Option.Stable.V1] |
sexp_of_t [Time_ns.Span.Stable.V1] |
sexp_of_t [Time_ns.Span.Parts] |
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 [Uuid.Stable.V1] |
sexp_of_t [Time_ns.Stable.V1] |
sexp_of_t [Time.Stable.With_utc_sexp.V1] |
sexp_of_t [Time.Stable.V1] |
sexp_of_t [Squeue] |
sexp_of_t [Span.Stable.V2] |
sexp_of_t [Span.Stable.V1] |
sexp_of_t [Span.Unit_of_time] |
sexp_of_t [Span.Parts] |
sexp_of_t [Span] |
sexp_of_t [Signal] |
sexp_of_t [Piecewise_linear_intf.S] |
sexp_of_t [Piecewise_linear_intf.Float_like] |
sexp_of_t [Piecewise_linear.Stable.V1.Make_invertible] |
sexp_of_t [Piecewise_linear.Stable.V1.Make] |
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 [Limiter.Infinite_or_finite] |
sexp_of_t [Limiter] |
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 [Date0.Stable.V1] |
sexp_of_t [Date0] |
sexp_of_t [Core_unix.Mman.Mcl_flags] |
sexp_of_t [Core_unix.Scheduler.Policy] |
sexp_of_t [Core_unix.Utsname] |
sexp_of_t [Core_unix.Resource_usage] |
sexp_of_t [Core_unix.RLimit] |
sexp_of_t [Core_unix.IOVec] |
sexp_of_t [Core_unix.Terminal_io] |
sexp_of_t [Core_unix.Service] |
sexp_of_t [Core_unix.Protocol] |
sexp_of_t [Core_unix.Host] |
sexp_of_t [Core_unix.Cidr] |
sexp_of_t [Core_unix.Inet_addr] |
sexp_of_t [Core_unix.Protocol_family] |
sexp_of_t [Core_unix.Group] |
sexp_of_t [Core_unix.Passwd] |
sexp_of_t [Core_unix.Select_fds] |
sexp_of_t [Core_unix.Process_info] |
sexp_of_t [Core_unix.Open_flags] |
sexp_of_t [Core_unix.Thread_id] |
sexp_of_t [Core_unix.Exit_or_signal_or_stop] |
sexp_of_t [Core_unix.Exit_or_signal] |
sexp_of_t [Core_unix.Exit] |
sexp_of_t [Core_unix.Error] | Unknown error
sexp_of_t [Core_unix.File_descr] |
sexp_of_t_abs [Time0.Stable.V1] |
sexp_of_tcp_bool_option [Linux_ext] |
sexp_of_tm [Core_unix] |
sexp_of_wait_on [Core_unix] |
sexp_zone [Time0.Stable.V1] |
shape [Command] | expose the shape of a command
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.
should_print_backtrace [Debug] | `should_print_backtrace` governs whether the `am*` functions print a backtrace.
show_messages [Iobuf_debug.Make] |
shutdown [Core_unix] |
shutdown_command_of_sexp [Core_unix] | The type of commands for `shutdown`.
shutdown_connection [Core_unix] | ``Shut down'' a connection established with `UnixLabels.open_connection`; that is, transmit an end-of-file condition to the server reading on the other side of the connection.
sigmask [Core_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 [Core_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 [Core_unix] | Same as `write` but ensures that all errors are reported and that no character has ever been written when an error is reported.
sleep [Core_unix] | Stop execution for the given number of seconds.
small_diff [Ofday] |
sockaddr_of_sexp [Core_unix] |
socket [Core_unix] | Create a new socket in the given domain, and with the given kind.
socket_bool_option_of_sexp [Core_unix] | The socket options that can be consulted with `UnixLabels.getsockopt` and modified with `UnixLabels.setsockopt`.
socket_domain_of_sexp [Core_unix] |
socket_float_option_of_sexp [Core_unix] | The socket options that can be consulted with `UnixLabels.getsockopt_float` and modified with `UnixLabels.setsockopt_float`.
socket_int_option_of_sexp [Core_unix] | The socket options that can be consulted with `UnixLabels.getsockopt_int` and modified with `UnixLabels.setsockopt_int`.
socket_type_of_sexp [Core_unix] |
socketpair [Core_unix] | Create a pair of unnamed sockets, connected together.
some [Time_ns.Option] |
some [Time_ns.Span.Option] |
split [Core_filename] | `split filename` returns (dirname filename, basename filename)
split_extension [Core_filename] | `split_extension fn` return the portion of the filename before the extension and the (optional) extension.
stack [Core_unix.RLimit] |
start_of_day [Time_ns.Ofday] |
start_of_day [Ofday] | Smallest valid ofday.
stat [Core_unix.Native_file] | Return the information for the named file.
stat [Core_unix] | Return the information for the named file.
stats_of_sexp [Core_unix.Native_file] |
stats_of_sexp [Core_unix] | The informations returned by the `UnixLabels.stat` calls.
stderr [Core_unix] | File descriptor for standard standard error.
stdin [Core_unix] | File descriptor for standard input.
stdout [Core_unix] | File descriptor for standard output.
step [Command.Spec] | combinator for patching up how parameters are obtained or presented
stime [Core_unix.Resource_usage.Fields] |
stime [Core_unix.Resource_usage] |
stop [Signal] | `Stop` Stop
strftime [Core_unix] | Convert a date and time, specified by the `tm` argument, into a formatted string.
string [Iobuf_intf.Accessors] |
string [Command.Arg_type.Export] | Beware that an anonymous argument of type `int` cannot be specified as negative, as it is ambiguous whether -1 is a negative number or a flag.
string_kind [Core_unix.IOVec] |
strptime [Core_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_ns] |
sub [Time] | `sub t s` subtracts the span `s` from time `t` and returns the resulting time.
sub [Ofday] |
sub [Iobuf_intf.Consuming_blit] |
sub [Iobuf.Blit_consume] |
sub [Iobuf.Blit] | Override types of `sub` and `subo` to allow return type to have `seek` as needed.
sub_shared [Iobuf] | `sub_shared t ~pos ~len` returns a new iobuf with limits and window set to the subrange of `t` specified by `pos` and `len`.
subo [Iobuf_intf.Consuming_blit] | `subo` defaults to using `Iobuf.length src`
subo [Iobuf.Blit_consume] |
subo [Iobuf.Blit] |
summary [Command.Deprecated] |
summary [Command] | extract the summary string for a command
symlink [Core_unix] | `symlink source dest` creates the file `dest` as a symbolic link to the file `source`.
sync [Core_unix.Open_flags] |
sync [Core_unix] | Synchronize all filesystem buffers with disk.
synchronize [Mutex0] |
synchronize [Core_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 [Core_unix] |
sysconf_of_sexp [Core_unix] | System configuration
sysinfo [Linux_ext.Sysinfo] |
syslog [Syslog] | `syslog ~facility ~level message` logs `message` using syslog with `facility` at `level`.
syslogf [Syslog] | `syslog_printf` acts like `syslog`, but allows `printf`-style specification of the message.
sysname [Core_unix.Utsname] |
system [Core_unix] | Execute the given command, wait until it terminates, and return its termination status.
T
t2 [Command.Anons] |
t3 [Command.Anons] |
t4 [Command.Anons] |
t_of_sexp [Unix_error] |
t_of_sexp [Time0.Stable.V1.C] |
t_of_sexp [Time0.Stable.V1.Epoch_cache] |
t_of_sexp [Time0.Stable.V1] |
t_of_sexp [Syslog.Level] |
t_of_sexp [Syslog.Facility] |
t_of_sexp [Syslog.Open_option] |
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_ns.Ofday.Stable.V1] |
t_of_sexp [Time_ns.Option.Stable.V1] |
t_of_sexp [Time_ns.Span.Option.Stable.V1] |
t_of_sexp [Time_ns.Span.Stable.V1] |
t_of_sexp [Time_ns.Span.Parts] |
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 [Uuid.Stable.V1] |
t_of_sexp [Time_ns.Stable.V1] |
t_of_sexp [Time.Stable.With_utc_sexp.V1] |
t_of_sexp [Time.Stable.V1] |
t_of_sexp [Span.Stable.V2] |
t_of_sexp [Span.Stable.V1] |
t_of_sexp [Span.Unit_of_time] |
t_of_sexp [Span.Parts] |
t_of_sexp [Span] |
t_of_sexp [Signal] |
t_of_sexp [Piecewise_linear_intf.S] |
t_of_sexp [Piecewise_linear_intf.Float_like] |
t_of_sexp [Piecewise_linear.Stable.V1.Make_invertible] |
t_of_sexp [Piecewise_linear.Stable.V1.Make] |
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 [Limiter.Infinite_or_finite] |
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 [Date0.Stable.V1] |
t_of_sexp [Date0] |
t_of_sexp [Core_unix.Mman.Mcl_flags] |
t_of_sexp [Core_unix.Scheduler.Policy] |
t_of_sexp [Core_unix.Utsname] |
t_of_sexp [Core_unix.Resource_usage] |
t_of_sexp [Core_unix.RLimit] |
t_of_sexp [Core_unix.IOVec] |
t_of_sexp [Core_unix.Service] |
t_of_sexp [Core_unix.Protocol] |
t_of_sexp [Core_unix.Cidr] |
t_of_sexp [Core_unix.Inet_addr] |
t_of_sexp [Core_unix.Protocol_family] |
t_of_sexp [Core_unix.Passwd] |
t_of_sexp [Core_unix.Process_info] |
t_of_sexp [Core_unix.Exit_or_signal_or_stop] |
t_of_sexp [Core_unix.Exit_or_signal] |
t_of_sexp [Core_unix.Exit] |
t_of_sexp [Core_unix.Error] |
t_of_sexp [Core_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] |
tail_padded_fixed_string [Iobuf_intf.Accessors] |
tcdrain [Core_unix.Terminal_io] | Waits until all output written on the given file descriptor has been transmitted.
tcflow [Core_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 [Core_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 [Core_unix.Terminal_io] | Return the status of the terminal referred to by the given file descriptor.
tcp_bool_option_of_sexp [Linux_ext] |
tcsendbreak [Core_unix.Terminal_io] | Send a break condition on the given file descriptor.
tcsetattr [Core_unix.Terminal_io] | Set the status of the terminal referred to by the given file descriptor.
temp_dir [Core_filename] |
temp_dir_name [Core_filename] | The name of the temporary directory:
temp_file [Core_filename] |
term [Signal] | `Terminate` Termination
threads_have_been_created [Core_thread] | `true` iff Thread.create has ever been called, even if there is currently only one running thread.
time [Core_unix] | Return the current time since 00:00:00 GMT, Jan.
time [Command.Arg_type.Export] |
time_ofday [Command.Arg_type.Export] | Use `time_ofday_unzoned` only when time zone is implied somehow.
time_ofday_unzoned [Command.Arg_type.Export] |
time_span [Command.Arg_type.Export] |
timedlock [Core_mutex] | `timedlock mtx timeout` like `lock`, but takes a `timeout` parameter.
timedwait [Core_condition] | `timedwait cond mtx timeout` waits on condition variable `cond` with mutex `mtx` until either the condition is signalled, or until `timeout` expires.
timegm [Core_unix] | Convert a UTC time in a tm record to a time in seconds
times [Core_unix] | Return the execution times of the process.
tm_of_sexp [Core_unix] | The type representing wallclock time and calendar date.
to_caml_int [Signal] |
to_date [Time0.Stable.V1] |
to_date [Time_ns] |
to_date [Time] |
to_date_ofday [Time0.Stable.V1] |
to_date_ofday [Time] |
to_day [Time_ns.Span] |
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_errno [Unix_error] |
to_file_descr [Linux_ext.Timerfd] |
to_filename_string [Time0.Stable.V1] |
to_filename_string [Time] | `to_filename_string t ~zone` converts `t` to string with format YYYY-MM-DD_HH-MM-SS.mmm which is suitable for using in filenames.
to_hr [Time_ns.Span] |
to_hr [Span] |
to_int [Syscall_result_intf.Arg] | `to_int t` must be >= 0, otherwise `create_ok` will raise.
to_int [Linux_ext.Priority] |
to_int [Core_unix.Thread_id] |
to_int [Core_unix.File_descr] |
to_int63 [Time_stamp_counter] | `to_int63 t` returns the TSC value represented by `t` as an `Int63.t`.
to_int63_ns [Time_ns.Span] | Fast, implemented as the identity function.
to_int63_ns_since_epoch [Time_ns] |
to_int_ns [Time_ns.Span] | Will raise on 32-bit platforms with spans corresponding to contemporary `Time_ns.now`.
to_int_ns_since_epoch [Time_ns] | Will raise on 32-bit platforms.
to_int_sec [Time_ns.Span] |
to_knots [Piecewise_linear_intf.S] |
to_knots' [Piecewise_linear_intf.S] |
to_list [Core_unix.Resource_usage.Fields] |
to_millisec_string [Ofday] | with milliseconds
to_millisecond_string [Time_ns.Ofday] |
to_min [Time_ns.Span] |
to_min [Span] |
to_ms [Time_ns.Span] |
to_ms [Span] |
to_ns [Time_stamp_counter.Span] |
to_ns [Time_ns.Span] |
to_ns [Span] |
to_ofday [Time0.Stable.V1] |
to_ofday [Time_ns.Ofday] |
to_ofday [Time] |
to_option [Time_ns.Option] |
to_parts [Time_ns.Span] |
to_parts [Span] |
to_parts [Ofday] |
to_poly [Interval_intf.S.Set] |
to_poly [Interval_intf.S] |
to_result [Syscall_result_intf.S] | This returns a preallocated object for all errors and at least a few `ok_value`s, so can be used in many contexts where avoiding allocation is important.
to_sec [Time_ns.Span] |
to_sec [Span] |
to_sec_string [Time0.Stable.V1] |
to_sec_string [Time] | Same as `to_string_abs`, but without milliseconds
to_sec_string [Ofday] | trailing milliseconds are trimmed
to_sequence [Core_list] |
to_short_string [Time_ns.Span] |
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 [Time_ns.Span] | `Time.t` is precise to approximately 0.24us in 2014.
to_span_since_epoch [Time_ns] |
to_span_since_start_of_day [Time_ns.Ofday] |
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 [Core_unix.Inet_addr] | Return the printable representation of the given Internet address.
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_abs_trimmed [Time0.Stable.V1] |
to_string_abs_trimmed [Time] |
to_string_american [Date0] |
to_string_fix_proto [Time0.Stable.V1] |
to_string_fix_proto [Time_ns] |
to_string_fix_proto [Time] |
to_string_hum [Span] | `to_string_hum t ~delimiter ~decimals ~align_decimal ~unit_of_time` formats `t` using the given unit of time, or the largest appropriate units if none is specified, among "d"=day, "h"=hour, "m"=minute, "s"=second, "ms"=millisecond, "us"=microsecond, or "ns"=nanosecond.
to_string_hum [Iobuf] | `to_string_hum t` produces a readable, multi-line representation of an iobuf.
to_string_hum [Core_unix.Exit_or_signal_or_stop] |
to_string_hum [Core_unix.Exit_or_signal] |
to_string_hum [Core_unix.Exit] |
to_string_iso8601_basic [Date0] |
to_string_trimmed [Time0.Stable.V1] |
to_string_trimmed [Time] | Same as `to_string_abs`, 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_ns] |
to_time [Time.Ofday.Zoned] |
to_time_ns [Time_stamp_counter] | `to_time_ns t` converts a `t` to an integer number of nanos since the epoch.
to_time_span [Time_stamp_counter.Span] |
to_tm [Time_internal] |
to_tm_utc [Time_internal] |
to_unit_of_time [Span] | `to_unit_of_time t` = `Day` if `abs t >= day`, `Hour` if `abs t >= hour`, and so on down to `Microsecond` if `abs t >= microsecond`, and `Nanosecond` otherwise.
to_us [Time_ns.Span] |
to_us [Span] |
today [Date] |
tokens_may_be_available_when [Limiter.Expert] | returns the earliest time when the requested number of tokens could possibly be delivered.
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 [Core_unix.Open_flags] |
truncate [Core_unix.Native_file] |
truncate [Core_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 [Core_mutex] | `try_lock` is like `lock`, but always returns immediately.
try_lock_exn [Nano_mutex] |
try_start_job [Limiter.Throttled_rate_limiter] |
try_start_job [Limiter.Throttle] |
try_take [Limiter.Expert] | attempts to take the given number of tokens from the bucket.
try_take [Limiter.Token_bucket] |
tstp [Signal] | `Stop` Interactive stop
ttin [Signal] | `Stop` Terminal read from background process
ttou [Signal] | `Stop` Terminal write from background process
typename_of_t [Time_ns.Ofday] |
typename_of_t [Time_ns.Option] |
typename_of_t [Time_ns.Span.Option] |
typename_of_t [Time_ns.Span] |
typename_of_t [Time_ns] |
typerep_of_t [Time_ns.Ofday] |
typerep_of_t [Time_ns.Option] |
typerep_of_t [Time_ns.Span.Option] |
typerep_of_t [Time_ns.Span] |
typerep_of_t [Time_ns] |
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 [Core_unix] | Set the process creation mask, and return the previous mask.
uname [Core_unix] |
unit [Syscall_result] |
unix_error [Core_unix] |
unlink [Core_unix] | Removes the named file
unlock [Nano_mutex] | `unlock t` unlocks `t`, if the current thread holds it.
unlock [Lock_file.Nfs] |
unlock [Core_unix.Flock_command] |
unlock [Core_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_advance [Iobuf] | `unsafe_advance` is like `advance` but with no bounds checking, so incorrect usage can easily cause segfaults.
unsafe_blit [Iobuf_intf.Consuming_blit] |
unsafe_blit [Iobuf.Blit_consume_and_fill] |
unsafe_blit [Iobuf.Blit_fill] |
unsafe_blit [Iobuf.Blit_consume] |
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_resize [Iobuf] | `unsafe_resize` is like `resize` but with no bounds checking, so incorrect usage can easily cause segfaults.
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 [Core_unix] | `unsetenv name` deletes the variable `name` from the environment.
update_broadcast [Mutex0] |
update_broadcast [Core_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 [Core_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 [Core_unix.Resource_usage.Fields] |
utime [Core_unix.Resource_usage] |
utimes [Core_unix] | Set the last access time (second arg) and last modification time (third arg) for a file.
V
value [Time_ns.Option] |
value [Time_ns.Span.Option] |
value_exn [Time_ns.Option] |
value_exn [Time_ns.Span.Option] |
version [Core_unix.Utsname] |
version [Command.Deprecated] |
virtual_memory [Core_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 [Core_unix] |
wait [Core_condition] |
wait_nohang [Core_unix] |
wait_nohang_untraced [Core_unix] |
wait_not_empty [Squeue] | `wait_not_empty sq` Waits for something to be available.
wait_on_of_sexp [Core_unix] |
wait_read [Core_thread] | See `Thread.wait_write`.
wait_signal [Core_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 [Core_thread] | See `Thread.wait_timed_write`.
wait_timed_write [Core_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_timeout_after [Linux_ext.Epoll] | `wait_timeout_after t span = wait t ~timeout:(`After span)`.
wait_untraced [Core_unix] |
wait_write [Core_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 [Core_unix] | `waitpid pid` waits for child process `pid` to terminate, and returns its exit status.
waitpid_exn [Core_unix] |
week_number [Date0] | Week of the year, from 1 to 53.
weekdays_between [Date0] |
window [Iobuf_intf.Bound] |
with_file [Core_unix] | `with_file file ~mode ~perm ~f` opens `file`, and applies `f` to the resulting file descriptor.
word_size [Core_sys] | Size of one word on the machine currently executing the Caml program, in bits: 32 or 64.
wordexp [Core_unix] |
wrap [Command.Spec] | combinator for defining a class of commands with common behavior
write [Core_unix] | `write fd buff ofs len` writes `len` characters to descriptor `fd`, taking them from string `buff`, starting at position `ofs` in string `buff`.
write [Bigstring] | `write 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 [Core_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 [Core_unix] | `writev fd ?count iovecs` like `Core_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 [Core_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 [Core_unix.Open_flags] |
Y
year [Date0] |
yield [Core_thread] | Re-schedule the calling thread without suspending it.
Z
zero [Time_ns.Span] |
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] |