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