| ( * ) [Int_intf.S] | |
| ( * ) [Float_intf.S] | |
| ( * ) [Byte_units.Infix] | |
| (!) [Ref] | |
| (!=) [Common] | |
| (%) [Int.Infix] | 
mod and div operators that have the right behavior on negative numbers,
      that is,  x % yalways returns a value between 0 and y-1. | 
| (%:) [Command.Spec] | (name %: typ)specifies a required anonymous argument of typetyp. | 
| (&) [Common] | |
| (+) [Span] | 
Basic operations on spans
 | 
| (+) [Linux_ext.Epoll.Flags] | |
| (+) [Int_intf.S] | |
| (+) [Float_intf.S] | |
| (+) [Commutative_group.S] | |
| (+) [Byte_units.Infix] | |
| (+) [Bucket.Contents] | |
| (++) [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] | |
| (-) [Linux_ext.Epoll.Flags] | |
| (-) [Int_intf.S] | |
| (-) [Float_intf.S] | |
| (-) [Commutative_group.S] | |
| (-) [Byte_units.Infix] | |
| (-) [Bucket.Contents] | |
| (/%) [Int.Infix] | |
| (/) [Span] | |
| (/) [Int_intf.S] | |
| (/) [Float_intf.S] | |
| (/) [Byte_units.Infix] | |
| (//) [Span] | |
| (//) [Int.Infix] | 
float division of integers
 | 
| (:=) [Ref] | |
| (<) [Polymorphic_compare] | |
| (<) [No_polymorphic_compare] | |
| (<) [Polymorphic_compare_intf.Infix] | |
| (<) [Comparable.Make_common.Replace_polymorphic_compare] | |
| (<.) [Robustly_comparable.S] | |
| (</>) [String.Infix] | |
| (<=) [Polymorphic_compare] | |
| (<=) [No_polymorphic_compare] | |
| (<=) [Polymorphic_compare_intf.Infix] | |
| (<=) [Comparable.Make_common.Replace_polymorphic_compare] | |
| (<=.) [Robustly_comparable.S] | |
| (<>) [Polymorphic_compare] | |
| (<>) [No_polymorphic_compare] | |
| (<>) [Polymorphic_compare_intf.Infix] | |
| (<>) [Comparable.Make_common.Replace_polymorphic_compare] | |
| (<>.) [Robustly_comparable.S] | |
| (<|>) [Array.Infix] | |
| (=) [Polymorphic_compare] | |
| (=) [No_polymorphic_compare] | |
| (=) [Polymorphic_compare_intf.Infix] | |
| (=) [Comparable.Make_common.Replace_polymorphic_compare] | |
| (=.) [Robustly_comparable.S] | |
| (==) [Common] | |
| (==>) [Common] | |
| (>) [Polymorphic_compare] | |
| (>) [No_polymorphic_compare] | |
| (>) [Polymorphic_compare_intf.Infix] | |
| (>) [Comparable.Make_common.Replace_polymorphic_compare] | |
| (>.) [Robustly_comparable.S] | |
| (>=) [Polymorphic_compare] | |
| (>=) [No_polymorphic_compare] | |
| (>=) [Polymorphic_compare_intf.Infix] | |
| (>=) [Comparable.Make_common.Replace_polymorphic_compare] | |
| (>=.) [Robustly_comparable.S] | |
| (>>=) [Monad.Infix2] | |
| (>>=) [Monad.Infix] | t >>= freturns a computation that sequences the computations represented by two
      monad elements. | 
| (>>|) [Monad.Infix2] | |
| (>>|) [Monad.Infix] | t >>| fist >>= (fun a -> return (f a)). | 
| (@) [List.Infix] | |
| (^/) [Common] | 
same as  Filename.concat | 
| (|!) [Fn] | 
A 'pipe' operator.
 | 
| (|!) [Common] | 
Functions from function.ml
 | 
| __Pa_ounit_b11b1370174a4540cf9e67839ea5dff5_test_list_1 [Stable.Unit_tests] | |
| __Pa_ounit_b11b1370174a4540cf9e67839ea5dff5_test_list_2 [Stable] | |
| _squelch_unused_module_warning_ [Std] | |
| _squelch_unused_module_warning_ [No_polymorphic_compare] | |
| A | |
| abbreviation [Zone] | abbreviation zone treturns t abbreviation name such as EDT, EST, JST of givenzoneat the timet. | 
| abort [Unix] | |
| abrt [Signal] | 
| Dump_core | Abnormal termination                          |
 | 
| abs [Span] | 
absolute value
 | 
| abs [Int_intf.S] | |
| abs [Float_intf.S] | |
| abs_diff [Time_internal.T] | |
| abs_diff [Time] | abs_diff t1 t2returns the absolute span of timet1minus timet2. | 
| abs_float [Common] | |
| 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 [Time_internal.T] | |
| add [Time] | add t sadds the spansto timetand returns the resulting time. | 
| add [Univ_map.Multi] | |
| add [Univ_map.With_fold] | |
| add [Univ_map] | |
| add [Timer] | add timer handler ?randomize ?interval span | 
| add [Ofday] | add t sshifts the time of daytby the spans. | 
| add [Int_set] | add t iaddito the set | 
| add [Hash_set_intf.Accessors] | |
| add [Float_intf.S] | |
| add [Unix.Resource_usage] | add ru1 ru2adds two rusage structures (e.g. | 
| add [Core_set_intf.Accessors] | |
| add [Core_map_intf.Accessors] | 
returns a new map with the specified new binding;
      if the key was already bound, its previous binding disappears.
 | 
| add [List.Assoc] | |
| add [Core_hashtbl_intf.Accessors] | |
| add [Bounded_int_table] | |
| add [Bag] | add t vaddsvto the bagt, returning an element that can
    later be removed from the bag. | 
| add [Avltree] | 
adds the specified key and data to the tree destructively (previous t's are no longer
    valid) using the specified comparison function.
 | 
| add_abs [Timer] | add_abs timer handler ?randomize ?interval timesame asTimer.add, but
    takes an absolute timetimefor scheduling the event rather than
    a span. | 
| add_buffer [Bigbuffer] | add_buffer b1 b2appends the current contents of bufferb2at the end of bufferb1. | 
| add_business_days [Date] | add_business_days t ~is_holiday nreturns a business day even whenn=0. | 
| add_channel [Bigbuffer] | add_channel b ic nreads exactlyncharacter from the
   input channelicand stores them at the end of bufferb. | 
| add_char [Bigbuffer] | add_char b cappends the charactercat the end of the bufferb. | 
| add_days [Date] | |
| add_exn [Univ_map] | |
| add_exn [Core_hashtbl_intf.Accessors] | |
| add_exn [Bounded_int_table] | |
| add_finalizer [Gc] | add_finalizer b fensures thatfruns afterbbecomes unreachable. | 
| add_finalizer_exn [Gc] | |
| add_months [Date] | add_months t nreturns date with max days for the month if the date would be
    invalid. | 
| add_multi [Core_map_intf.Accessors] | 
if key is not present then add a singleton list, otherwise, cons data
      on the head of the existing list.
 | 
| add_multi [Core_hashtbl_intf.Accessors] | add_multi t ~key ~dataifkeyis present in the table then consdataon the list, otherwise addkeywith a single element list. | 
| add_range [Int_set] | add_range t i jadd all the numbers betweeniandj(inclusive) to the set. | 
| add_string [Bigbuffer] | add_string b sappends the stringsat the end of the bufferb. | 
| add_substitute [Bigbuffer] | add_substitute b f sappends the string patternsat the end
   of the bufferbwith substitution. | 
| add_substring [Bigbuffer] | add_substring b s ofs lentakeslencharacters from offsetofsin stringsand appends them at the end of the bufferb. | 
| add_weekdays [Date] | add_weekdays t 0returns the next weekday iftis a weekend andtotherwise. | 
| addr_info_of_sexp [Unix] | 
Address information returned by  Unix.getaddrinfo. | 
| alarm [Unix] | 
Schedule a  SIGALRMsignal after the given number of seconds. | 
| align [Arg] | 
Align the documentation strings by inserting spaces at the first
    space, according to the length of the keyword.
 | 
| all [Pretty_printer] | |
| all [Month] | |
| all [Monad.S2] | |
| all [Monad.Make2] | |
| all [Monad.Make] | |
| all [Monad.S] | |
| all_ignore [Monad.S2] | |
| all_ignore [Monad.Make2] | |
| all_ignore [Monad.Make] | |
| all_ignore [Monad.S] | |
| allocated_bytes [Gc] | 
Return the total number of bytes allocated since the program was
   started.
 | 
| allocation_policy [Gc.Control.Fields] | |
| allocation_policy [Gc.Control] | |
| alrm [Signal] | 
| Terminate | Timeout                                       |
 | 
| always [Quickcheck] | 
generator that always returns given value
 | 
| am_holding_mutex [Mutex0] | |
| am_holding_mutex [Mutex] | |
| and_ [Blang] | |
| anon [Command.Spec] | anon specspecifies a command that, among other things, takes
      the anonymous arguments specified byspec. | 
| append [List] | 
E.g.
 | 
| append [Array] | Array.append v1 v2returns a fresh array containing the
   concatenation of the arraysv1andv2. | 
| apply [Result] | |
| apply [Option] | apply x frun optional function on argument and return an option | 
| apply_n_times [Fn] | apply_n_times ~n f xis then-fold application offtox. | 
| are_disjoint [Linux_ext.Epoll.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.
 | 
| array_of_sexp [Std_internal] | |
| ascending [Comparable.S_common] | |
| ascending [Comparable.Make_common] | |
| ascending [Comparable.Poly] | |
| ascending [Common] | 
A comparator that returns results in ascending order.
 | 
| B | |
| back_index [Dequeue] | |
| backtrace [Exn] | Printexc.get_backtrace | 
| backtrace_status [Printexc] | |
| base [Substring_intf.S] | |
| base [Make_substring.F] | |
| base [Blang] | |
| basename [Filename] | 
Respects the posix semantic.
 | 
| basic [Command] | basic ~summary ?readme spec mainis a basic command that executes a functionmainwhich is passed parameters parsed from the command line according tospec. | 
| between [Comparable.S_common] | |
| between [Comparable.Make_common] | |
| between [Comparable.Poly] | |
| big_contents [Bigbuffer] | 
Return a copy of the current contents of the buffer as a bigstring.
 | 
| bigstring_bigstring [Make_substring.Blit] | |
| bigstring_kind [Unix.IOVec] | |
| bigstring_string [Make_substring.Blit] | |
| bin_decimal [Common] | |
| bin_immutable [Common] | |
| bin_no_raise [Sexp] | |
| bin_outer [Float_intf.S] | |
| bin_read_decimal [Common] | |
| bin_read_decimal_ [Common] | |
| bin_read_decimal__ [Common] | |
| bin_read_immutable [Common] | |
| bin_read_immutable_ [Common] | |
| bin_read_immutable__ [Common] | |
| bin_read_no_raise [Sexp] | |
| bin_read_no_raise_ [Sexp] | |
| bin_read_no_raise__ [Sexp] | |
| bin_read_only [Common] | |
| bin_read_outer [Float_intf.S] | |
| bin_read_outer_ [Float_intf.S] | |
| bin_read_outer__ [Float_intf.S] | |
| bin_read_read_only [Common] | |
| bin_read_read_only_ [Common] | |
| bin_read_read_only__ [Common] | |
| bin_read_read_write [Common] | |
| bin_read_read_write_ [Common] | |
| bin_read_read_write__ [Common] | |
| bin_read_sexp_array [Std_internal] | |
| bin_read_sexp_array_ [Std_internal] | |
| bin_read_sexp_array__ [Std_internal] | |
| bin_read_sexp_list [Std_internal] | |
| bin_read_sexp_list_ [Std_internal] | |
| bin_read_sexp_list__ [Std_internal] | |
| bin_read_sexp_opaque [Std_internal] | |
| bin_read_sexp_opaque_ [Std_internal] | |
| bin_read_sexp_opaque__ [Std_internal] | |
| bin_read_sexp_option [Std_internal] | |
| bin_read_sexp_option [Stable_internal] | |
| bin_read_sexp_option_ [Std_internal] | |
| bin_read_sexp_option_ [Stable_internal] | |
| bin_read_sexp_option__ [Std_internal] | |
| bin_read_sexp_option__ [Stable_internal] | |
| 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 [Weekday] | |
| bin_read_t [Unique_id_intf.Id] | |
| bin_read_t [Zone] | |
| bin_read_t [Stable_internal.Sexp] | |
| bin_read_t [Stable_containers.Map.V1] | |
| bin_read_t [Stable_containers.Hash_set.V1] | |
| bin_read_t [Stable_containers.Hashtbl.V1] | |
| bin_read_t [Stable_containers.Set.V1] | |
| bin_read_t [Zone.Stable.V1] | |
| bin_read_t [Weekday.Stable.V1] | |
| bin_read_t [Time.Stable.V1] | |
| bin_read_t [String_id.Stable.V1] | |
| bin_read_t [Span.Stable.V1] | |
| bin_read_t [Span] | |
| bin_read_t [Source_code_position0] | |
| bin_read_t [Source_code_position] | |
| bin_read_t [Signal] | |
| bin_read_t [Stable_unit_test_intf.Arg] | |
| bin_read_t [Result.Stable.V1] | |
| bin_read_t [Result] | |
| bin_read_t [Ref] | |
| bin_read_t [Piecewise_linear.Key] | |
| bin_read_t [Piecewise_linear.S] | |
| bin_read_t [Pid] | |
| bin_read_t [Or_error] | |
| bin_read_t [Ordering] | |
| bin_read_t [Ofday.Stable.V1] | |
| bin_read_t [Ofday] | |
| bin_read_t [Month.Stable.V1] | |
| bin_read_t [Month] | |
| bin_read_t [Linux_ext.Sysinfo] | |
| bin_read_t [Int_intf.S] | |
| 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 [Info] | |
| bin_read_t [Identifiable.S] | |
| bin_read_t [T.T_bin] | |
| bin_read_t [Fqueue] | |
| bin_read_t [Float_intf.S.Terse] | |
| bin_read_t [Float_intf.S.Class] | |
| bin_read_t [Dequeue] | |
| bin_read_t [Date.Stable.V1] | |
| bin_read_t [Date] | |
| bin_read_t [Unix.Inet_addr] | |
| bin_read_t [Unix.Protocol_family] | |
| bin_read_t [Unix.File_descr] | |
| bin_read_t [String] | |
| bin_read_t [Stack] | |
| bin_read_t [Sexp.Sexp_maybe] | |
| bin_read_t [Sexp.Sexp_opaque] | |
| bin_read_t [Sexp.Sexp_array] | |
| bin_read_t [Sexp.Sexp_list] | |
| bin_read_t [Sexp.Sexp_option] | |
| bin_read_t [Sexp] | |
| bin_read_t [Set.Poly] | |
| bin_read_t [Queue] | |
| bin_read_t [Map.Poly] | |
| bin_read_t [List] | |
| bin_read_t [Lazy] | |
| bin_read_t [Core_hashtbl_intf.Key_binable] | |
| bin_read_t [Hashtbl.Poly] | |
| bin_read_t [Gc.Control] | |
| bin_read_t [Gc.Stat] | |
| bin_read_t [Char] | |
| bin_read_t [Array] | |
| bin_read_t [Constrained_float.S] | |
| bin_read_t [Comparator.Pre_binable] | |
| bin_read_t [Byte_units.Measure] | |
| bin_read_t [Byte_units] | |
| bin_read_t [Bucket.S] | |
| bin_read_t [Bucket.Contents] | |
| bin_read_t [Bucket.Make] | |
| bin_read_t [Bounded_int_table.With_key] | |
| bin_read_t [Bool] | |
| bin_read_t [Blang.Stable.V1] | |
| bin_read_t [Blang] | |
| bin_read_t [Bigstring] | |
| bin_read_t_ [Time] | |
| bin_read_t_ [Weekday] | |
| bin_read_t_ [Unique_id_intf.Id] | |
| bin_read_t_ [Zone] | |
| bin_read_t_ [Stable_internal.Sexp] | |
| bin_read_t_ [Stable_containers.Map.V1] | |
| bin_read_t_ [Stable_containers.Hash_set.V1] | |
| bin_read_t_ [Stable_containers.Hashtbl.V1] | |
| bin_read_t_ [Stable_containers.Set.V1] | |
| bin_read_t_ [Zone.Stable.V1] | |
| bin_read_t_ [Weekday.Stable.V1] | |
| bin_read_t_ [Time.Stable.V1] | |
| bin_read_t_ [String_id.Stable.V1] | |
| bin_read_t_ [Span.Stable.V1] | |
| bin_read_t_ [Span] | |
| bin_read_t_ [Source_code_position0] | |
| bin_read_t_ [Source_code_position] | |
| bin_read_t_ [Signal] | |
| bin_read_t_ [Stable_unit_test_intf.Arg] | |
| bin_read_t_ [Result.Stable.V1] | |
| bin_read_t_ [Result] | |
| bin_read_t_ [Ref] | |
| bin_read_t_ [Piecewise_linear.Key] | |
| bin_read_t_ [Piecewise_linear.S] | |
| bin_read_t_ [Pid] | |
| bin_read_t_ [Or_error] | |
| bin_read_t_ [Ordering] | |
| bin_read_t_ [Ofday.Stable.V1] | |
| bin_read_t_ [Ofday] | |
| bin_read_t_ [Month.Stable.V1] | |
| bin_read_t_ [Month] | |
| bin_read_t_ [Linux_ext.Sysinfo] | |
| bin_read_t_ [Int_intf.S] | |
| 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_ [Info] | |
| bin_read_t_ [Identifiable.S] | |
| bin_read_t_ [T.T_bin] | |
| bin_read_t_ [Fqueue] | |
| bin_read_t_ [Float_intf.S.Terse] | |
| bin_read_t_ [Float_intf.S.Class] | |
| bin_read_t_ [Dequeue] | |
| bin_read_t_ [Date.Stable.V1] | |
| bin_read_t_ [Date] | |
| bin_read_t_ [Unix.Inet_addr] | |
| bin_read_t_ [Unix.Protocol_family] | |
| bin_read_t_ [Unix.File_descr] | |
| bin_read_t_ [String] | |
| bin_read_t_ [Stack] | |
| bin_read_t_ [Sexp.Sexp_maybe] | |
| bin_read_t_ [Sexp.Sexp_opaque] | |
| bin_read_t_ [Sexp.Sexp_array] | |
| bin_read_t_ [Sexp.Sexp_list] | |
| bin_read_t_ [Sexp.Sexp_option] | |
| bin_read_t_ [Sexp] | |
| bin_read_t_ [Set.Poly] | |
| bin_read_t_ [Queue] | |
| bin_read_t_ [Map.Poly] | |
| bin_read_t_ [List] | |
| bin_read_t_ [Lazy] | |
| bin_read_t_ [Core_hashtbl_intf.Key_binable] | |
| bin_read_t_ [Hashtbl.Poly] | |
| bin_read_t_ [Gc.Control] | |
| bin_read_t_ [Gc.Stat] | |
| bin_read_t_ [Char] | |
| bin_read_t_ [Array] | |
| bin_read_t_ [Constrained_float.S] | |
| bin_read_t_ [Comparator.Pre_binable] | |
| bin_read_t_ [Byte_units.Measure] | |
| bin_read_t_ [Byte_units] | |
| bin_read_t_ [Bucket.S] | |
| bin_read_t_ [Bucket.Contents] | |
| bin_read_t_ [Bucket.Make] | |
| bin_read_t_ [Bounded_int_table.With_key] | |
| bin_read_t_ [Bool] | |
| bin_read_t_ [Blang.Stable.V1] | |
| bin_read_t_ [Blang] | |
| bin_read_t_ [Bigstring] | |
| bin_read_t__ [Time] | |
| bin_read_t__ [Weekday] | |
| bin_read_t__ [Unique_id_intf.Id] | |
| bin_read_t__ [Zone] | |
| bin_read_t__ [Stable_internal.Sexp] | |
| bin_read_t__ [Stable_containers.Map.V1] | |
| bin_read_t__ [Stable_containers.Hash_set.V1] | |
| bin_read_t__ [Stable_containers.Hashtbl.V1] | |
| bin_read_t__ [Stable_containers.Set.V1] | |
| bin_read_t__ [Zone.Stable.V1] | |
| bin_read_t__ [Weekday.Stable.V1] | |
| bin_read_t__ [Time.Stable.V1] | |
| bin_read_t__ [String_id.Stable.V1] | |
| bin_read_t__ [Span.Stable.V1] | |
| bin_read_t__ [Span] | |
| bin_read_t__ [Source_code_position0] | |
| bin_read_t__ [Source_code_position] | |
| bin_read_t__ [Signal] | |
| bin_read_t__ [Stable_unit_test_intf.Arg] | |
| bin_read_t__ [Result.Stable.V1] | |
| bin_read_t__ [Result] | |
| bin_read_t__ [Ref] | |
| bin_read_t__ [Piecewise_linear.Key] | |
| bin_read_t__ [Piecewise_linear.S] | |
| bin_read_t__ [Pid] | |
| bin_read_t__ [Or_error] | |
| bin_read_t__ [Ordering] | |
| bin_read_t__ [Ofday.Stable.V1] | |
| bin_read_t__ [Ofday] | |
| bin_read_t__ [Month.Stable.V1] | |
| bin_read_t__ [Month] | |
| bin_read_t__ [Linux_ext.Sysinfo] | |
| bin_read_t__ [Int_intf.S] | |
| 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__ [Info] | |
| bin_read_t__ [Identifiable.S] | |
| bin_read_t__ [T.T_bin] | |
| bin_read_t__ [Fqueue] | |
| bin_read_t__ [Float_intf.S.Terse] | |
| bin_read_t__ [Float_intf.S.Class] | |
| bin_read_t__ [Dequeue] | |
| bin_read_t__ [Date.Stable.V1] | |
| bin_read_t__ [Date] | |
| bin_read_t__ [Unix.Inet_addr] | |
| bin_read_t__ [Unix.Protocol_family] | |
| bin_read_t__ [Unix.File_descr] | |
| bin_read_t__ [String] | |
| bin_read_t__ [Stack] | |
| bin_read_t__ [Sexp.Sexp_maybe] | |
| bin_read_t__ [Sexp.Sexp_opaque] | |
| bin_read_t__ [Sexp.Sexp_array] | |
| bin_read_t__ [Sexp.Sexp_list] | |
| bin_read_t__ [Sexp.Sexp_option] | |
| bin_read_t__ [Sexp] | |
| bin_read_t__ [Set.Poly] | |
| bin_read_t__ [Queue] | |
| bin_read_t__ [Map.Poly] | |
| bin_read_t__ [List] | |
| bin_read_t__ [Lazy] | |
| bin_read_t__ [Core_hashtbl_intf.Key_binable] | |
| bin_read_t__ [Hashtbl.Poly] | |
| bin_read_t__ [Gc.Control] | |
| bin_read_t__ [Gc.Stat] | |
| bin_read_t__ [Char] | |
| bin_read_t__ [Array] | |
| bin_read_t__ [Constrained_float.S] | |
| bin_read_t__ [Comparator.Pre_binable] | |
| bin_read_t__ [Byte_units.Measure] | |
| bin_read_t__ [Byte_units] | |
| bin_read_t__ [Bucket.S] | |
| bin_read_t__ [Bucket.Contents] | |
| bin_read_t__ [Bucket.Make] | |
| bin_read_t__ [Bounded_int_table.With_key] | |
| bin_read_t__ [Bool] | |
| bin_read_t__ [Blang.Stable.V1] | |
| bin_read_t__ [Blang] | |
| bin_read_t__ [Bigstring] | |
| bin_read_tcp_bool_option [Linux_ext] | |
| bin_read_tcp_bool_option_ [Linux_ext] | |
| bin_read_tcp_bool_option__ [Linux_ext] | |
| bin_read_write [Common] | |
| bin_reader_decimal [Common] | |
| bin_reader_immutable [Common] | |
| bin_reader_no_raise [Sexp] | |
| bin_reader_outer [Float_intf.S] | |
| bin_reader_read_only [Common] | |
| bin_reader_read_write [Common] | |
| bin_reader_sexp_array [Std_internal] | |
| bin_reader_sexp_list [Std_internal] | |
| bin_reader_sexp_opaque [Std_internal] | |
| bin_reader_sexp_option [Std_internal] | |
| bin_reader_sexp_option [Stable_internal] | |
| bin_reader_sockaddr [Unix] | |
| bin_reader_socket_domain [Unix] | |
| bin_reader_socket_type [Unix] | |
| bin_reader_t [Time] | |
| bin_reader_t [Weekday] | |
| bin_reader_t [Unique_id_intf.Id] | |
| bin_reader_t [Zone] | |
| bin_reader_t [Stable_internal.Sexp] | |
| bin_reader_t [Stable_containers.Map.V1] | |
| bin_reader_t [Stable_containers.Hash_set.V1] | |
| bin_reader_t [Stable_containers.Hashtbl.V1] | |
| bin_reader_t [Stable_containers.Set.V1] | |
| bin_reader_t [Zone.Stable.V1] | |
| bin_reader_t [Weekday.Stable.V1] | |
| bin_reader_t [Time.Stable.V1] | |
| bin_reader_t [String_id.Stable.V1] | |
| bin_reader_t [Span.Stable.V1] | |
| bin_reader_t [Span] | |
| bin_reader_t [Source_code_position0] | |
| bin_reader_t [Source_code_position] | |
| bin_reader_t [Signal] | |
| bin_reader_t [Stable_unit_test_intf.Arg] | |
| bin_reader_t [Result.Stable.V1] | |
| bin_reader_t [Result] | |
| bin_reader_t [Ref] | |
| bin_reader_t [Piecewise_linear.Key] | |
| bin_reader_t [Piecewise_linear.S] | |
| bin_reader_t [Pid] | |
| bin_reader_t [Or_error] | |
| bin_reader_t [Ordering] | |
| bin_reader_t [Ofday.Stable.V1] | |
| bin_reader_t [Ofday] | |
| bin_reader_t [Month.Stable.V1] | |
| bin_reader_t [Month] | |
| bin_reader_t [Linux_ext.Sysinfo] | |
| bin_reader_t [Int_intf.S] | |
| 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 [Info] | |
| bin_reader_t [Identifiable.S] | |
| bin_reader_t [T.T_bin] | |
| bin_reader_t [Fqueue] | |
| bin_reader_t [Float_intf.S.Terse] | |
| bin_reader_t [Float_intf.S.Class] | |
| bin_reader_t [Dequeue] | |
| bin_reader_t [Date.Stable.V1] | |
| bin_reader_t [Date] | |
| bin_reader_t [Unix.Inet_addr] | |
| bin_reader_t [Unix.Protocol_family] | |
| bin_reader_t [Unix.File_descr] | |
| bin_reader_t [String] | |
| bin_reader_t [Stack] | |
| bin_reader_t [Sexp.Sexp_maybe] | |
| bin_reader_t [Sexp.Sexp_opaque] | |
| bin_reader_t [Sexp.Sexp_array] | |
| bin_reader_t [Sexp.Sexp_list] | |
| bin_reader_t [Sexp.Sexp_option] | |
| bin_reader_t [Sexp] | |
| bin_reader_t [Set.Poly] | |
| bin_reader_t [Queue] | |
| bin_reader_t [Map.Poly] | |
| bin_reader_t [List] | |
| bin_reader_t [Lazy] | |
| bin_reader_t [Core_hashtbl_intf.Key_binable] | |
| bin_reader_t [Hashtbl.Poly] | |
| bin_reader_t [Gc.Control] | |
| bin_reader_t [Gc.Stat] | |
| bin_reader_t [Char] | |
| bin_reader_t [Array] | |
| bin_reader_t [Constrained_float.S] | |
| bin_reader_t [Comparator.Pre_binable] | |
| bin_reader_t [Byte_units.Measure] | |
| bin_reader_t [Byte_units] | |
| bin_reader_t [Bucket.S] | |
| bin_reader_t [Bucket.Contents] | |
| bin_reader_t [Bucket.Make] | |
| bin_reader_t [Bounded_int_table.With_key] | |
| bin_reader_t [Bool] | |
| bin_reader_t [Blang.Stable.V1] | |
| bin_reader_t [Blang] | |
| bin_reader_t [Bigstring] | |
| bin_reader_tcp_bool_option [Linux_ext] | |
| bin_sexp_array [Std_internal] | |
| bin_sexp_list [Std_internal] | |
| bin_sexp_opaque [Std_internal] | |
| bin_sexp_option [Std_internal] | |
| bin_sexp_option [Stable_internal] | |
| bin_size_decimal [Common] | |
| bin_size_immutable [Common] | |
| bin_size_no_raise [Sexp] | |
| bin_size_outer [Float_intf.S] | |
| bin_size_read_only [Common] | |
| bin_size_read_write [Common] | |
| bin_size_sexp_array [Std_internal] | |
| bin_size_sexp_list [Std_internal] | |
| bin_size_sexp_opaque [Std_internal] | |
| bin_size_sexp_option [Std_internal] | |
| bin_size_sexp_option [Stable_internal] | |
| bin_size_sockaddr [Unix] | |
| bin_size_socket_domain [Unix] | |
| bin_size_socket_type [Unix] | |
| bin_size_t [Time] | |
| bin_size_t [Weekday] | |
| bin_size_t [Unique_id_intf.Id] | |
| bin_size_t [Zone] | |
| bin_size_t [Stable_internal.Sexp] | |
| bin_size_t [Stable_containers.Map.V1] | |
| bin_size_t [Stable_containers.Hash_set.V1] | |
| bin_size_t [Stable_containers.Hashtbl.V1] | |
| bin_size_t [Stable_containers.Set.V1] | |
| bin_size_t [Zone.Stable.V1] | |
| bin_size_t [Weekday.Stable.V1] | |
| bin_size_t [Time.Stable.V1] | |
| bin_size_t [String_id.Stable.V1] | |
| bin_size_t [Span.Stable.V1] | |
| bin_size_t [Span] | |
| bin_size_t [Source_code_position0] | |
| bin_size_t [Source_code_position] | |
| bin_size_t [Signal] | |
| bin_size_t [Stable_unit_test_intf.Arg] | |
| bin_size_t [Result.Stable.V1] | |
| bin_size_t [Result] | |
| bin_size_t [Ref] | |
| bin_size_t [Piecewise_linear.Key] | |
| bin_size_t [Piecewise_linear.S] | |
| bin_size_t [Pid] | |
| bin_size_t [Or_error] | |
| bin_size_t [Ordering] | |
| bin_size_t [Ofday.Stable.V1] | |
| bin_size_t [Ofday] | |
| bin_size_t [Month.Stable.V1] | |
| bin_size_t [Month] | |
| bin_size_t [Linux_ext.Sysinfo] | |
| bin_size_t [Int_intf.S] | |
| 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 [Info] | |
| bin_size_t [Identifiable.S] | |
| bin_size_t [T.T_bin] | |
| bin_size_t [Fqueue] | |
| bin_size_t [Float_intf.S.Terse] | |
| bin_size_t [Float_intf.S.Class] | |
| bin_size_t [Dequeue] | |
| bin_size_t [Date.Stable.V1] | |
| bin_size_t [Date] | |
| bin_size_t [Unix.Inet_addr] | |
| bin_size_t [Unix.Protocol_family] | |
| bin_size_t [Unix.File_descr] | |
| bin_size_t [String] | |
| bin_size_t [Stack] | |
| bin_size_t [Sexp.Sexp_maybe] | |
| bin_size_t [Sexp.Sexp_opaque] | |
| bin_size_t [Sexp.Sexp_array] | |
| bin_size_t [Sexp.Sexp_list] | |
| bin_size_t [Sexp.Sexp_option] | |
| bin_size_t [Sexp] | |
| bin_size_t [Set.Poly] | |
| bin_size_t [Queue] | |
| bin_size_t [Map.Poly] | |
| bin_size_t [List] | |
| bin_size_t [Lazy] | |
| bin_size_t [Core_hashtbl_intf.Key_binable] | |
| bin_size_t [Hashtbl.Poly] | |
| bin_size_t [Gc.Control] | |
| bin_size_t [Gc.Stat] | |
| bin_size_t [Char] | |
| bin_size_t [Array] | |
| bin_size_t [Constrained_float.S] | |
| bin_size_t [Comparator.Pre_binable] | |
| bin_size_t [Byte_units.Measure] | |
| bin_size_t [Byte_units] | |
| bin_size_t [Bucket.S] | |
| bin_size_t [Bucket.Contents] | |
| bin_size_t [Bucket.Make] | |
| bin_size_t [Bounded_int_table.With_key] | |
| bin_size_t [Bool] | |
| bin_size_t [Blang.Stable.V1] | |
| bin_size_t [Blang] | |
| bin_size_t [Bigstring] | |
| 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 [Weekday] | |
| bin_t [Unique_id_intf.Id] | |
| bin_t [Zone] | |
| bin_t [Stable_internal.Sexp] | |
| bin_t [Stable_containers.Map.V1] | |
| bin_t [Stable_containers.Hash_set.V1] | |
| bin_t [Stable_containers.Hashtbl.V1] | |
| bin_t [Stable_containers.Set.V1] | |
| bin_t [Zone.Stable.V1] | |
| bin_t [Weekday.Stable.V1] | |
| bin_t [Time.Stable.V1] | |
| bin_t [String_id.Stable.V1] | |
| bin_t [Span.Stable.V1] | |
| bin_t [Span] | |
| bin_t [Source_code_position0] | |
| bin_t [Source_code_position] | |
| bin_t [Signal] | |
| bin_t [Stable_unit_test_intf.Arg] | |
| bin_t [Result.Stable.V1] | |
| bin_t [Result] | |
| bin_t [Ref] | |
| bin_t [Piecewise_linear.Key] | |
| bin_t [Piecewise_linear.S] | |
| bin_t [Pid] | |
| bin_t [Or_error] | |
| bin_t [Ordering] | |
| bin_t [Ofday.Stable.V1] | |
| bin_t [Ofday] | |
| bin_t [Month.Stable.V1] | |
| bin_t [Month] | |
| bin_t [Linux_ext.Sysinfo] | |
| bin_t [Int_intf.S] | |
| 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 [Info] | |
| bin_t [Identifiable.S] | |
| bin_t [T.T_bin] | |
| bin_t [Fqueue] | |
| bin_t [Float_intf.S.Terse] | |
| bin_t [Float_intf.S.Class] | |
| bin_t [Dequeue] | |
| bin_t [Date.Stable.V1] | |
| bin_t [Date] | |
| bin_t [Unix.Inet_addr] | |
| bin_t [Unix.Protocol_family] | |
| bin_t [Unix.File_descr] | |
| bin_t [String] | |
| bin_t [Stack] | |
| bin_t [Sexp.Sexp_maybe] | |
| bin_t [Sexp.Sexp_opaque] | |
| bin_t [Sexp.Sexp_array] | |
| bin_t [Sexp.Sexp_list] | |
| bin_t [Sexp.Sexp_option] | |
| bin_t [Sexp] | |
| bin_t [Set.Poly] | |
| bin_t [Queue] | |
| bin_t [Map.Poly] | |
| bin_t [List] | |
| bin_t [Lazy] | |
| bin_t [Core_hashtbl_intf.Key_binable] | |
| bin_t [Hashtbl.Poly] | |
| bin_t [Gc.Control] | |
| bin_t [Gc.Stat] | |
| bin_t [Char] | |
| bin_t [Array] | |
| bin_t [Constrained_float.S] | |
| bin_t [Comparator.Pre_binable] | |
| bin_t [Byte_units.Measure] | |
| bin_t [Byte_units] | |
| bin_t [Bucket.S] | |
| bin_t [Bucket.Contents] | |
| bin_t [Bucket.Make] | |
| bin_t [Bounded_int_table.With_key] | |
| bin_t [Bool] | |
| bin_t [Blang.Stable.V1] | |
| bin_t [Blang] | |
| bin_t [Bigstring] | |
| bin_tcp_bool_option [Linux_ext] | |
| bin_write_decimal [Common] | |
| bin_write_decimal_ [Common] | |
| bin_write_immutable [Common] | |
| bin_write_immutable_ [Common] | |
| bin_write_no_raise [Sexp] | |
| bin_write_no_raise_ [Sexp] | |
| bin_write_outer [Float_intf.S] | |
| bin_write_outer_ [Float_intf.S] | |
| bin_write_read_only [Common] | |
| bin_write_read_only_ [Common] | |
| bin_write_read_write [Common] | |
| bin_write_read_write_ [Common] | |
| bin_write_sexp_array [Std_internal] | |
| bin_write_sexp_array_ [Std_internal] | |
| bin_write_sexp_list [Std_internal] | |
| bin_write_sexp_list_ [Std_internal] | |
| bin_write_sexp_opaque [Std_internal] | |
| bin_write_sexp_opaque_ [Std_internal] | |
| bin_write_sexp_option [Std_internal] | |
| bin_write_sexp_option [Stable_internal] | |
| bin_write_sexp_option_ [Std_internal] | |
| bin_write_sexp_option_ [Stable_internal] | |
| 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 [Weekday] | |
| bin_write_t [Unique_id_intf.Id] | |
| bin_write_t [Zone] | |
| bin_write_t [Stable_internal.Sexp] | |
| bin_write_t [Stable_containers.Map.V1] | |
| bin_write_t [Stable_containers.Hash_set.V1] | |
| bin_write_t [Stable_containers.Hashtbl.V1] | |
| bin_write_t [Stable_containers.Set.V1] | |
| bin_write_t [Zone.Stable.V1] | |
| bin_write_t [Weekday.Stable.V1] | |
| bin_write_t [Time.Stable.V1] | |
| bin_write_t [String_id.Stable.V1] | |
| bin_write_t [Span.Stable.V1] | |
| bin_write_t [Span] | |
| bin_write_t [Source_code_position0] | |
| bin_write_t [Source_code_position] | |
| bin_write_t [Signal] | |
| bin_write_t [Stable_unit_test_intf.Arg] | |
| bin_write_t [Result.Stable.V1] | |
| bin_write_t [Result] | |
| bin_write_t [Ref] | |
| bin_write_t [Piecewise_linear.Key] | |
| bin_write_t [Piecewise_linear.S] | |
| bin_write_t [Pid] | |
| bin_write_t [Or_error] | |
| bin_write_t [Ordering] | |
| bin_write_t [Ofday.Stable.V1] | |
| bin_write_t [Ofday] | |
| bin_write_t [Month.Stable.V1] | |
| bin_write_t [Month] | |
| bin_write_t [Linux_ext.Sysinfo] | |
| bin_write_t [Int_intf.S] | |
| 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 [Info] | |
| bin_write_t [Identifiable.S] | |
| bin_write_t [T.T_bin] | |
| bin_write_t [Fqueue] | |
| bin_write_t [Float_intf.S.Terse] | |
| bin_write_t [Float_intf.S.Class] | |
| bin_write_t [Dequeue] | |
| bin_write_t [Date.Stable.V1] | |
| bin_write_t [Date] | |
| bin_write_t [Unix.Inet_addr] | |
| bin_write_t [Unix.Protocol_family] | |
| bin_write_t [Unix.File_descr] | |
| bin_write_t [String] | |
| bin_write_t [Stack] | |
| bin_write_t [Sexp.Sexp_maybe] | |
| bin_write_t [Sexp.Sexp_opaque] | |
| bin_write_t [Sexp.Sexp_array] | |
| bin_write_t [Sexp.Sexp_list] | |
| bin_write_t [Sexp.Sexp_option] | |
| bin_write_t [Sexp] | |
| bin_write_t [Set.Poly] | |
| bin_write_t [Queue] | |
| bin_write_t [Map.Poly] | |
| bin_write_t [List] | |
| bin_write_t [Lazy] | |
| bin_write_t [Core_hashtbl_intf.Key_binable] | |
| bin_write_t [Hashtbl.Poly] | |
| bin_write_t [Gc.Control] | |
| bin_write_t [Gc.Stat] | |
| bin_write_t [Char] | |
| bin_write_t [Array] | |
| bin_write_t [Constrained_float.S] | |
| bin_write_t [Comparator.Pre_binable] | |
| bin_write_t [Byte_units.Measure] | |
| bin_write_t [Byte_units] | |
| bin_write_t [Bucket.S] | |
| bin_write_t [Bucket.Contents] | |
| bin_write_t [Bucket.Make] | |
| bin_write_t [Bounded_int_table.With_key] | |
| bin_write_t [Bool] | |
| bin_write_t [Blang.Stable.V1] | |
| bin_write_t [Blang] | |
| bin_write_t [Bigstring] | |
| bin_write_t_ [Time] | |
| bin_write_t_ [Weekday] | |
| bin_write_t_ [Unique_id_intf.Id] | |
| bin_write_t_ [Zone] | |
| bin_write_t_ [Stable_internal.Sexp] | |
| bin_write_t_ [Stable_containers.Map.V1] | |
| bin_write_t_ [Stable_containers.Hash_set.V1] | |
| bin_write_t_ [Stable_containers.Hashtbl.V1] | |
| bin_write_t_ [Stable_containers.Set.V1] | |
| bin_write_t_ [Zone.Stable.V1] | |
| bin_write_t_ [Weekday.Stable.V1] | |
| bin_write_t_ [Time.Stable.V1] | |
| bin_write_t_ [String_id.Stable.V1] | |
| bin_write_t_ [Span.Stable.V1] | |
| bin_write_t_ [Span] | |
| bin_write_t_ [Source_code_position0] | |
| bin_write_t_ [Source_code_position] | |
| bin_write_t_ [Signal] | |
| bin_write_t_ [Stable_unit_test_intf.Arg] | |
| bin_write_t_ [Result.Stable.V1] | |
| bin_write_t_ [Result] | |
| bin_write_t_ [Ref] | |
| bin_write_t_ [Piecewise_linear.Key] | |
| bin_write_t_ [Piecewise_linear.S] | |
| bin_write_t_ [Pid] | |
| bin_write_t_ [Or_error] | |
| bin_write_t_ [Ordering] | |
| bin_write_t_ [Ofday.Stable.V1] | |
| bin_write_t_ [Ofday] | |
| bin_write_t_ [Month.Stable.V1] | |
| bin_write_t_ [Month] | |
| bin_write_t_ [Linux_ext.Sysinfo] | |
| bin_write_t_ [Int_intf.S] | |
| 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_ [Info] | |
| bin_write_t_ [Identifiable.S] | |
| bin_write_t_ [T.T_bin] | |
| bin_write_t_ [Fqueue] | |
| bin_write_t_ [Float_intf.S.Terse] | |
| bin_write_t_ [Float_intf.S.Class] | |
| bin_write_t_ [Dequeue] | |
| bin_write_t_ [Date.Stable.V1] | |
| bin_write_t_ [Date] | |
| bin_write_t_ [Unix.Inet_addr] | |
| bin_write_t_ [Unix.Protocol_family] | |
| bin_write_t_ [Unix.File_descr] | |
| bin_write_t_ [String] | |
| bin_write_t_ [Stack] | |
| bin_write_t_ [Sexp.Sexp_maybe] | |
| bin_write_t_ [Sexp.Sexp_opaque] | |
| bin_write_t_ [Sexp.Sexp_array] | |
| bin_write_t_ [Sexp.Sexp_list] | |
| bin_write_t_ [Sexp.Sexp_option] | |
| bin_write_t_ [Sexp] | |
| bin_write_t_ [Set.Poly] | |
| bin_write_t_ [Queue] | |
| bin_write_t_ [Map.Poly] | |
| bin_write_t_ [List] | |
| bin_write_t_ [Lazy] | |
| bin_write_t_ [Core_hashtbl_intf.Key_binable] | |
| bin_write_t_ [Hashtbl.Poly] | |
| bin_write_t_ [Gc.Control] | |
| bin_write_t_ [Gc.Stat] | |
| bin_write_t_ [Char] | |
| bin_write_t_ [Array] | |
| bin_write_t_ [Constrained_float.S] | |
| bin_write_t_ [Comparator.Pre_binable] | |
| bin_write_t_ [Byte_units.Measure] | |
| bin_write_t_ [Byte_units] | |
| bin_write_t_ [Bucket.S] | |
| bin_write_t_ [Bucket.Contents] | |
| bin_write_t_ [Bucket.Make] | |
| bin_write_t_ [Bounded_int_table.With_key] | |
| bin_write_t_ [Bool] | |
| bin_write_t_ [Blang.Stable.V1] | |
| bin_write_t_ [Blang] | |
| bin_write_t_ [Bigstring] | |
| bin_write_tcp_bool_option [Linux_ext] | |
| bin_write_tcp_bool_option_ [Linux_ext] | |
| bin_writer_decimal [Common] | |
| bin_writer_immutable [Common] | |
| bin_writer_no_raise [Sexp] | |
| bin_writer_outer [Float_intf.S] | |
| bin_writer_read_only [Common] | |
| bin_writer_read_write [Common] | |
| bin_writer_sexp_array [Std_internal] | |
| bin_writer_sexp_list [Std_internal] | |
| bin_writer_sexp_opaque [Std_internal] | |
| bin_writer_sexp_option [Std_internal] | |
| bin_writer_sexp_option [Stable_internal] | |
| bin_writer_sockaddr [Unix] | |
| bin_writer_socket_domain [Unix] | |
| bin_writer_socket_type [Unix] | |
| bin_writer_t [Time] | |
| bin_writer_t [Weekday] | |
| bin_writer_t [Unique_id_intf.Id] | |
| bin_writer_t [Zone] | |
| bin_writer_t [Stable_internal.Sexp] | |
| bin_writer_t [Stable_containers.Map.V1] | |
| bin_writer_t [Stable_containers.Hash_set.V1] | |
| bin_writer_t [Stable_containers.Hashtbl.V1] | |
| bin_writer_t [Stable_containers.Set.V1] | |
| bin_writer_t [Zone.Stable.V1] | |
| bin_writer_t [Weekday.Stable.V1] | |
| bin_writer_t [Time.Stable.V1] | |
| bin_writer_t [String_id.Stable.V1] | |
| bin_writer_t [Span.Stable.V1] | |
| bin_writer_t [Span] | |
| bin_writer_t [Source_code_position0] | |
| bin_writer_t [Source_code_position] | |
| bin_writer_t [Signal] | |
| bin_writer_t [Stable_unit_test_intf.Arg] | |
| bin_writer_t [Result.Stable.V1] | |
| bin_writer_t [Result] | |
| bin_writer_t [Ref] | |
| bin_writer_t [Piecewise_linear.Key] | |
| bin_writer_t [Piecewise_linear.S] | |
| bin_writer_t [Pid] | |
| bin_writer_t [Or_error] | |
| bin_writer_t [Ordering] | |
| bin_writer_t [Ofday.Stable.V1] | |
| bin_writer_t [Ofday] | |
| bin_writer_t [Month.Stable.V1] | |
| bin_writer_t [Month] | |
| bin_writer_t [Linux_ext.Sysinfo] | |
| bin_writer_t [Int_intf.S] | |
| 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 [Info] | |
| bin_writer_t [Identifiable.S] | |
| bin_writer_t [T.T_bin] | |
| bin_writer_t [Fqueue] | |
| bin_writer_t [Float_intf.S.Terse] | |
| bin_writer_t [Float_intf.S.Class] | |
| bin_writer_t [Dequeue] | |
| bin_writer_t [Date.Stable.V1] | |
| bin_writer_t [Date] | |
| bin_writer_t [Unix.Inet_addr] | |
| bin_writer_t [Unix.Protocol_family] | |
| bin_writer_t [Unix.File_descr] | |
| bin_writer_t [String] | |
| bin_writer_t [Stack] | |
| bin_writer_t [Sexp.Sexp_maybe] | |
| bin_writer_t [Sexp.Sexp_opaque] | |
| bin_writer_t [Sexp.Sexp_array] | |
| bin_writer_t [Sexp.Sexp_list] | |
| bin_writer_t [Sexp.Sexp_option] | |
| bin_writer_t [Sexp] | |
| bin_writer_t [Set.Poly] | |
| bin_writer_t [Queue] | |
| bin_writer_t [Map.Poly] | |
| bin_writer_t [List] | |
| bin_writer_t [Lazy] | |
| bin_writer_t [Core_hashtbl_intf.Key_binable] | |
| bin_writer_t [Hashtbl.Poly] | |
| bin_writer_t [Gc.Control] | |
| bin_writer_t [Gc.Stat] | |
| bin_writer_t [Char] | |
| bin_writer_t [Array] | |
| bin_writer_t [Constrained_float.S] | |
| bin_writer_t [Comparator.Pre_binable] | |
| bin_writer_t [Byte_units.Measure] | |
| bin_writer_t [Byte_units] | |
| bin_writer_t [Bucket.S] | |
| bin_writer_t [Bucket.Contents] | |
| bin_writer_t [Bucket.Make] | |
| bin_writer_t [Bounded_int_table.With_key] | |
| bin_writer_t [Bool] | |
| bin_writer_t [Blang.Stable.V1] | |
| bin_writer_t [Blang] | |
| bin_writer_t [Bigstring] | |
| bin_writer_tcp_bool_option [Linux_ext] | |
| bind [Monad.S2] | |
| bind [Monad.Basic2] | |
| bind [Monad.Basic] | |
| bind [Monad.Make2] | |
| bind [Monad.Make] | |
| bind [Monad.S] | bind t f=t >>= f | 
| 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] | |
| bit_and [Int_intf.S] | |
| bit_not [Int_intf.S] | |
| bit_or [Int_intf.S] | |
| bit_xor [Int_intf.S] | |
| bits [Random.State] | 
These functions are the same as the basic functions, except that they use (and
      update) the given PRNG state instead of the default one.
 | 
| bits [Random] | 
Return 30 random bits in a nonnegative integer.
 | 
| bits_of_float [Int64] | |
| bits_of_float [Int32] | |
| blit [Make_substring.Base] | |
| blit [String] | |
| blit [Array] | Array.blit v1 o1 v2 o2 lencopieslenelements
   from arrayv1, starting at element numbero1, to arrayv2,
   starting at element numbero2. | 
| blit [Bigstring] | |
| blit [Bigbuffer] | |
| blit_bigstring_string [Bigstring] | |
| blit_from_bigstring [Substring_intf.S] | |
| blit_from_bigstring [Make_substring.Base] | |
| blit_from_bigstring [Make_substring.F] | |
| blit_from_string [Substring_intf.S] | |
| blit_from_string [Make_substring.Base] | |
| blit_from_string [Make_substring.F] | |
| blit_string_bigstring [Bigstring] | |
| 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] | |
| blit_to_bigstring [Substring_intf.S] | |
| blit_to_bigstring [Make_substring.Base] | |
| blit_to_bigstring [Make_substring.F] | |
| blit_to_string [Substring_intf.S] | |
| blit_to_string [Make_substring.Base] | |
| blit_to_string [Make_substring.F] | |
| block_forever [Thread] | block_forever ()will block the calling thread forever. | 
| blocking_create [Lock_file.Nfs] | blocking_create ?message pathlike create, but sleeps for 1 second between lock
      attempts and does not return until it succeeds | 
| blocking_create [Lock_file] | blocking_create ttries to create the lock. | 
| bool [Command.Spec] | |
| bool [Random.State] | |
| bool [Random] | Random.bool ()returnstrueorfalsewith probability 0.5 each. | 
| bool_of_sexp [Std_internal] | |
| bot [Fqueue] | 
like  bot_exn, but returns result optionally, without exception. | 
| bot_exn [Fqueue] | 
returns the bottom (most-recently enqueued element).
 | 
| both [Option] | |
| bound [Interval_intf.Gen] | bound t xreturnsNoneiffis_empty t. | 
| bounds [Interval_intf.Gen] | |
| bounds_exn [Interval_intf.Gen] | |
| bprintf [Printf] | |
| bprintf [Bigbuffer.Printf] | |
| bprintf [Bigbuffer.Format] | |
| broadcast [Condition] | |
| build_info [Command.Deprecated] | |
| business_dates_between [Date] | |
| bytes [Heap_block] | bytes treturns the number of bytes on the heap taken by heap blockt, including
    the header. | 
| bytes [Byte_units] | |
| C | |
| c_int_size [Sys] | c_int_sizereturns the number of bits in a Cint. | 
| call [Result] | |
| call [Option] | call x frun optional function on argument | 
| capitalize [String] | |
| cartesian_product [List] | |
| cartesian_product [Array] | |
| catch [Printexc] | |
| catch_break [Sys] | 
Warning: this function clobbers the Signal.int (SIGINT) handler.
 | 
| ceil [Common] | |
| cg [Quickcheck] | 
character generator
 | 
| change [Univ_map.Multi] | |
| change [Univ_map.With_fold] | |
| change [Univ_map.With_default] | |
| change [Univ_map] | |
| change [Core_map_intf.Accessors] | change map key fupdates the given map by changing the value stored
      underkeyaccording tof. | 
| change [Core_hashtbl_intf.Accessors] | change t key fupdates the given table by changing the value stored underkeyaccording tof, just likeMap.change(see that for example). | 
| change_exn [Univ_map] | |
| char_of_sexp [Std_internal] | |
| chdir [Unix] | 
Change the process working directory.
 | 
| chdir [Sys] | 
Change the current working directory of the process.
 | 
| check_args [Bigstring] | check_args ~loc ~pos ~len bstrchecks the position and length
    argumentsposandlenfor bigstringsbstr. | 
| check_heap_property [Heap] | check_heap_property hasserts thathhas the heap property: that all
    nodes are less than their children byh's comparison function. | 
| check_suffix [Filename] | check_suffix name suffreturnstrueif the filenamenameends with the suffixsuff. | 
| chld [Signal] | 
| Ignore    | Child process terminated                      |
 | 
| chmod [Unix] | 
Change the permissions of the named file.
 | 
| choose [Core_set_intf.Accessors] | |
| choose [Bag] | choose treturns some element in the bag. | 
| choose_exn [Core_set_intf.Accessors] | |
| chop_extension [Filename] | 
Return the given file name without its extension.
 | 
| chop_prefix [String] | |
| chop_prefix_exn [String] | chop_prefix s ~prefreturns a copyswithout the leadingpref | 
| chop_suffix [String] | |
| chop_suffix [Filename] | chop_suffix name suffremoves the suffixsufffrom
   the filenamename. | 
| chop_suffix_exn [String] | chop_suffix s ~sufreturns a copyswithout the trailingsuff | 
| chown [Unix] | 
Change the owner uid and owner gid of the named file.
 | 
| chroot [Unix] | 
Change the process root directory.
 | 
| classify [Float_intf.S] | |
| classify_float [Common] | |
| clear [Squeue] | 
clears the queue
 | 
| clear [Hash_set_intf.Accessors] | |
| clear [Hash_queue.S] | 
clear the queue
 | 
| clear [Hash_queue.Make] | |
| clear [Doubly_linked] | clear tremoves all elements from the list in constant time. | 
| clear [Dequeue] | clear tremoves all elements fromt. | 
| clear [Stack] | clear tdiscards all elements fromt. | 
| clear [Queue] | clear tdiscards all elements fromt. | 
| clear [Core_hashtbl_intf.Accessors] | |
| clear [Bigbuffer] | 
Empty the buffer.
 | 
| clear [Bag] | clear tremoves all elements from the bag. | 
| 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.
 | 
| close [Out_channel] | |
| close [In_channel] | |
| close [Unix] | 
Close a file descriptor.
 | 
| close_in [Common] | 
we have our own version of these two, the INRIA version doesn't release the runtime
    lock.
 | 
| close_out [Common] | |
| 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] | |
| combine [Result] | |
| combine [Array] | combine arcombines two arrays to an array of pairs. | 
| combine_errors [Or_error] | combine_errors tsreturnsOkif every element intsisOk, else it returnsErrorwith all the errors ints. | 
| combine_errors_unit [Or_error] | combine_errors_unitreturnsOkif every element intsisOk (), else it
    returnsErrorwith all the errors ints, likecombine_errors. | 
| command [Sys] | 
Execute the given shell command and return its exit code.
 | 
| command_exn [Sys] | |
| compact [Gc] | 
Perform a full major collection and compact the heap.
 | 
| compactions [Gc.Stat.Fields] | |
| compactions [Gc.Stat] | |
| comparator [Set] | |
| comparator [Map] | |
| comparator [Comparator.S1] | |
| comparator [Comparator.S_binable] | |
| comparator [Comparator.S] | |
| comparator [Comparable.S_common] | |
| compare [Tuple.T3] | |
| compare [Tuple.T2] | |
| compare [Stable_internal.Sexp] | |
| compare [Weekday.Stable.V1] | |
| compare [Time.Stable.V1] | |
| compare [Span.Stable.V1] | |
| compare [Source_code_position0] | |
| compare [Result.Stable.V1] | |
| compare [Result] | |
| compare [Polymorphic_compare] | |
| compare [Ordering] | |
| compare [Option] | |
| compare [No_polymorphic_compare] | |
| compare [Month.Stable.V1] | |
| compare [Hashable.S] | |
| compare [Fqueue] | |
| compare [Date.Stable.V1] | |
| compare [Sexp.Sexp_maybe] | |
| compare [Sexp.Sexp_opaque] | |
| compare [Sexp.Sexp_array] | |
| compare [Sexp.Sexp_list] | |
| compare [Sexp.Sexp_option] | |
| compare [Core_set_intf.S.Tree] | |
| compare [Core_set_intf.S] | |
| compare [Set.Poly] | |
| compare [Set] | |
| compare [Core_map_intf.S] | |
| compare [Map.Poly] | |
| compare [List] | 
lexicographic
 | 
| compare [Core_hashtbl_intf.Key] | |
| compare [Comparator.Pre_binable] | |
| compare [Comparator.Pre] | |
| compare [Polymorphic_compare_intf.S] | |
| compare [Comparable.Make_common.Replace_polymorphic_compare] | |
| compare [Blang.Stable.V1] | |
| compare [Blang] | |
| compare_direct [Core_set_intf.Accessors] | |
| compare_direct [Core_map_intf.Accessors] | 
Total ordering between maps.
 | 
| compare_immutable [Common] | |
| compare_read_only [Common] | 
Handy types for marking things read-only and read-write.
 | 
| compare_read_write [Common] | |
| compare_sexp_array [Std_internal] | |
| compare_sexp_list [Std_internal] | |
| compare_sexp_opaque [Std_internal] | |
| compare_sexp_option [Std_internal] | |
| compare_sexp_option [Stable_internal] | |
| compare_t [Stable_internal.Sexp] | |
| compare_t [Source_code_position0] | |
| compare_value [Interval_intf.Gen] | |
| compose [Fn] | compose f g xisf (g x) | 
| concat [Substring_intf.S] | |
| concat [Make_substring.F] | |
| concat [String] | 
concatanate all strings in the list using separator  sep(default sep "") | 
| concat [List] | 
Concatenate a list of lists.
 | 
| concat [Filename] | concat p1 p2returns a path equivalent top1 ^ "/" ^ p2. | 
| concat [Array] | 
Same as  Array.append, but concatenates a list of arrays. | 
| concat_array [String] | concat_array sep arlikeString.concat, but operates on arrays | 
| concat_bigstring [Substring_intf.S] | |
| concat_bigstring [Make_substring.F] | |
| concat_map [String] | 
Like  map, but allows replacement of a single character with zero or two or more
    characters. | 
| concat_map [Queue] | |
| concat_map [List] | concat_map t ~fisconcat (map t ~f), except that there is no guarantee about the
    order in whichfis applied to the elements oft. | 
| concat_map [Array] | |
| concat_mapi [List] | concat_mapi t ~fis like concat_map, but passes the index as an argument | 
| concat_no_order [List] | 
Same as  concatbut faster and without preserving any ordering (ie for lists that are
    essentially viewed as multi-sets. | 
| concat_string [Substring_intf.S] | |
| concat_string [Make_substring.F] | |
| cond_pop [Heap] | cond_pop heap cond | 
| cond_pop [Hash_heap.S] | |
| cond_pop [Hash_heap.Make] | |
| cond_pop_heap_el [Heap] | cond_pop_heap_el heap cond | 
| cond_pop_with_key [Hash_heap.S] | |
| cond_pop_with_key [Hash_heap.Make] | |
| connect [Unix] | 
Connect a socket to an address.
 | 
| cons [List] | |
| const [Fn] | 
produces a function that just returns its first argument
 | 
| const [Common] | |
| const [Command.Spec] | 
a hard-coded parameter
 | 
| constant [Blang] | |
| constant_value [Blang] | |
| constr_name [Univ] | |
| cont [Signal] | 
| Continue  | Continue                                      |
 | 
| contains [Interval_intf.Gen_set] | |
| contains [Interval_intf.Gen] | |
| contains [String] | |
| contains_dup [List] | contains_dupTrue if there are any two elements in the list which are the same. | 
| contains_set [Interval_intf.Gen_set] | |
| contents [Bigbuffer] | 
Return a copy of the current contents of the buffer.
 | 
| convert [Time] | |
| copy [Heap] | copy heap | 
| copy [Hash_set_intf.Accessors] | |
| copy [Hash_heap.S] | |
| copy [Hash_heap.Make] | |
| copy [Doubly_linked] | copy treturns a copy oft. | 
| copy [String] | |
| copy [Stack] | copy treturns a copy oft. | 
| copy [Queue] | copy treturns a copy oft. | 
| copy [Core_hashtbl_intf.Accessors] | |
| copy [Array] | Array.copy areturns a copy ofa, that is, a fresh array
   containing the same elements asa. | 
| copy [Random.State] | |
| core_file_size [Unix.RLimit] | |
| cores [Linux_ext] | cores () | 
| count [Hash_queue.Make] | |
| count [List] | count f lis the number of elements inlthat satisfy the
    predicatef. | 
| count [Container.Generic_phantom] | |
| count [Container.Generic] | |
| count [Container.S1_phantom] | |
| count [Container.S1] | |
| count [Container.S0_phantom] | |
| count [Container.S0] | |
| count [Container.Make] | |
| counters [Gc] | 
Return  (minor_words, promoted_words, major_words). | 
| cpu_seconds [Unix.RLimit] | |
| crc32 [Crc] | 
Compute the 32-bit crc
 | 
| crc32hex [Crc] | 
String version of the crc, encoded in hex.
 | 
| create [Weekday] | |
| create [Unpack_buffer] | |
| create [Univ_map.Multi.Key] | |
| create [Univ_map.With_fold.Key] | |
| create [Univ_map.With_default.Key] | |
| create [Univ_map.Key] | |
| create [Univ.Constr] | create name to_sexpif the type'adoesn't support sexp conversion, then a good practice
      is to usesexp_of_opaqueas the converter. | 
| create [Univ] | create var argcreates a newtfrom a constr and the argument to the constr. | 
| create [Unique_id_intf.Id] | |
| create [Union_find] | create vreturns a new object in its own equivalence class that has valuev. | 
| create [Tuple.T3] | |
| create [Tuple.T2] | |
| create [Timer] | create ?min_size ()creates a new timer. | 
| create [Thread_safe_queue] | |
| create [Squeue] | create maxsizereturns a synchronized queue bounded to have no more thanmaxsizeelements. | 
| create [Span] | |
| create [Space_safe_tuple.T3] | |
| create [Space_safe_tuple.T2] | |
| create [Set_once] | |
| create [Ref] | |
| create [Piecewise_linear.S] | |
| create [Out_channel] | |
| create [Ofday] | |
| create [Nano_mutex] | create ()returns a new, unlocked mutex. | 
| create [Mutex0] | |
| create [Substring_intf.S] | create ?pos ?len basecreates a substring of the base sequence of
   * lengthlenstarting at positionpos, i.e. | 
| create [Make_substring.Base] | |
| create [Make_substring.F] | |
| create [Lock_file.Nfs] | lock ?message pathtries to create and lock the file atpathby creating a hard
      link topath.nfs_lock. | 
| create [Lock_file] | create ?close_on_exec ?message pathtries to create a file atpathcontaining the
    textmessage, which defaults to the pid of the locking process. | 
| create [Linux_ext.Epoll] | create ~num_file_descrscreates a new epoll set able to watch file descriptors in
      [0, num_file_descrs). | 
| create [Interval_intf.S] | |
| create [Interval_intf.Gen_set] | |
| create [Interval_intf.Gen] | create l ureturns the interval with lower boundland upper boundu, unlessl > u, in which casecreatereturns the empty interval. | 
| create [Info] | 
For  create msg z sexp_of_z, be careful to use only immutable values for z, or be
    aware thatzwill be lazily converted to a sexp at a later point in time, which will
    pick up the then-current state ofz. | 
| create [In_channel] | |
| create [Host_and_port] | |
| create [Heap_block] | create vreturnsSome tifvis a heap block, wheretis physically equal
    tov | 
| create [Heap] | create ?min_size cmp | 
| create [Hash_set_intf.Creators] | |
| create [Hash_heap.S] | |
| create [Hash_queue.S] | create ()returns an empty queue. | 
| create [Hash_heap.Make] | |
| create [Hash_queue.Make] | |
| create [Force_once] | create fcreates a new force_once | 
| create [Doubly_linked] | 
creating doubly-linked lists
 | 
| create [Dequeue] | |
| create [Weak] | |
| create [Unix.Resource_usage.Fields] | |
| create [Thread] | Thread.create funct argcreates a new thread of control,
   in which the function applicationfunct argis executed concurrently with the other threads of the program. | 
| create [String] | |
| create [Stack] | create ()returns an empty stack. | 
| create [Queue] | create ()returns an empty queue. | 
| create [Mutex] | |
| create [Core_hashtbl_intf.Creators] | |
| create [Gc.Control.Fields] | |
| create [Gc.Stat.Fields] | |
| create [Condition] | |
| create [Array] | create ~len xcreates an array of lengthlenwith the valuexpopulated in each
    element | 
| 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 [Byte_units] | |
| create [Bucket.S] | |
| create [Bucket.Make] | |
| create [Bounded_int_table.With_key] | |
| create [Bounded_int_table] | create ~num_keys ~key_to_intreturns a table where the keys can map to 0
    .. | 
| create [Bigstring] | create length | 
| create [Bigbuffer] | create nreturns a fresh buffer, initially empty. | 
| create [Bag] | create ()returns an empty bag. | 
| create' [Thread_safe_queue] | |
| create_alarm [Gc] | create_alarm fwill arrange forfto be called at the end of each
   major GC cycle, starting with the current cycle or the next one. | 
| create_bigstring [Binable0] | |
| create_bin_prot [Unpack_buffer.Unpack_one] | create_bin_prot readerreturns an unpacker that reads the "size-prefixed" bin_prot
      encoding, in which a value is encoded by first writing the length of the bin_prot
      data as a 64-bit int, and then writing the data itself. | 
| create_bin_prot [Unpack_buffer] | create_bin_prot readerreturns an unpack buffer that unpacks the "size-prefixed"
    bin_prot encoding, in which a value is encoded by first writing the length of the
    bin_prot data as a 64-bit int, and then writing the bin_prot data itself. | 
| create_ending_after [Interval.Time] | create_ending_after ?zone (od1, od2) ~nowreturns the smallest interval(t1 t2)with minimumt2such thatt2 >= now,to_ofday t1 = od1, andto_ofday t2 =
      od2. | 
| create_ending_before [Interval.Time] | create_ending_before ?zone (od1, od2) ~uboundreturns the smallest interval(t1
      t2)with maximumt2such thatt2 <= ubound,to_ofday t1 = od1, andto_ofday
      t2 = od2. | 
| create_exn [Lock_file.Nfs] | create_exn ?message pathlike create, but throws an exception when it fails to
      obtain the lock | 
| create_exn [Lock_file] | create_exn ?message pathis likecreateexcept that it throws an exception on
    failure instead of returning a boolean value | 
| create_exn [Heap_block] | |
| create_exn [Date] | create_exn ~y ~m ~dcreates the date specified in the arguments. | 
| create_from_intervals [Interval_intf.Gen_set] | |
| create_mapped [Core_hashtbl_intf.Creators] | |
| create_process [Unix] | create_process ~prog ~argsforks a new process that
    executes the programprogwith argumentsargs. | 
| create_process_env [Unix] | create_process_env ~prog ~args ~envas create process, but takes an additional
    parameter that extends, or replaces the current environment. | 
| create_with_key [Core_hashtbl_intf.Creators] | |
| create_with_key_exn [Core_hashtbl_intf.Creators] | |
| critical_section [Nano_mutex] | |
| critical_section [Mutex0] | |
| critical_section [Lock_file.Nfs] | critical_section ?message path ~fwrap functionf(including exceptions escaping
      it) by first locking (usingLock_file.Nfs.create_exn) and then unlocking the given lock
      file. | 
| critical_section [Mutex] | |
| current [Arg] | 
Position (in  Sys.argv) of the argument being processed. | 
| current_dir_name [Filename] | 
The conventional name for the current directory (e.g.
 | 
| current_string_and_sexp_format [Time] | |
| current_thread_has_lock [Nano_mutex] | current_thread_has_lock treturnstrueiff the current thread hastlocked. | 
| curry [Tuple.T3] | |
| curry [Tuple.T2] | |
| D | |
| daemonize [Daemon] | daemonizemakes the executing process a daemon. | 
| daemonize_wait [Daemon] | daemonize_waitmakes the executing process a daemon, but delays full detachment
    from the calling shell/process until the returned "release" closure is called. | 
| data [Core_map_intf.Accessors] | 
returns list of data in map
 | 
| data [Core_hashtbl_intf.Accessors] | filter_inplace t ~fremoves all the elements fromtthat don't satisfyf. | 
| data [Bounded_int_table] | |
| data_segment [Unix.RLimit] | |
| date [Command.Spec] | |
| dates_between [Date] | |
| day [Span] | |
| day [Date] | |
| day_of_week [Date] | |
| deactivate [Timer] | deactivate timerdeactives a timer. | 
| debug [Unpack_buffer] | debugcontrols whether invariants are checked at each call. | 
| debug [Bounded_int_table] | 
set  debug := trueto turn on debugging, including potentially slow invariant
    checking. | 
| decimal_of_sexp [Common] | |
| decr [Linux_ext.Priority] | |
| decr [Int_intf.S] | |
| dedup [List] | dedup(de-duplicate). | 
| default [Random.State] | |
| default_sys_behavior [Signal] | default_sys_behavior tQuery the default system behavior for a signal. | 
| default_utc_offset_deprecated [Zone] | default_utc_offsetreturns the UTC offset of default regime for timezonetin 
    seconds. | 
| delay [Thread] | delay dsuspends the execution of the calling thread fordseconds. | 
| delete_alarm [Gc] | delete_alarm awill stop the calls to the function associated
   toa. | 
| dequeue [Thread_safe_queue] | |
| dequeue [Hash_queue.S] | dequeue treturns the front element of the queue. | 
| dequeue [Hash_queue.Make] | |
| dequeue [Fqueue] | 
Like  dequeue_exn, but returns result optionally, without exception. | 
| dequeue [Queue] | dequeue treturnsNoneiftis empty, otherwise it removes and returns
    the front oft | 
| dequeue_all [Hash_queue.S] | dequeue_all t ~fdequeues every element of the queue and applies f to each
       one. | 
| dequeue_all [Hash_queue.Make] | |
| dequeue_exn [Hash_queue.S] | |
| dequeue_exn [Hash_queue.Make] | |
| dequeue_exn [Fqueue] | dequeue_exn tremoves and returns the front oft, raisingEmptyiftis empty. | 
| dequeue_exn [Queue] | |
| dequeue_until_empty [Thread_safe_queue] | |
| dequeue_with_key [Hash_queue.S] | dequeue_with_key treturns the front element of the queue and its key | 
| dequeue_with_key [Hash_queue.Make] | |
| dequeue_with_key_exn [Hash_queue.S] | |
| dequeue_with_key_exn [Hash_queue.Make] | |
| descending [Comparable.S_common] | |
| descending [Comparable.Make_common] | |
| descending [Comparable.Poly] | |
| descending [Common] | |
| 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 t2returns timet1minus timet2. | 
| diff [Ofday] | diff t1 t2returns the difference in time between two ofdays, as if they occurred on
    the same day | 
| diff [Hash_set_intf.Accessors] | |
| diff [Date] | diff t1 t2returns datet1minus datet2in days. | 
| diff [Core_set_intf.Accessors] | |
| digest [Zone] | digest treturn 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. | 
| discard_exn [Fqueue] | 
Returns version of queue with top element removed.
 | 
| do_intersect [Linux_ext.Epoll.Flags] | 
The handling of sets of bit flags here is indeed a departure from the typical
        convention of lists of variants, but has some advantages and is likely to
        be used in the future.
 | 
| domain_of_sockaddr [Unix] | 
Return the socket domain adequate for the given socket address.
 | 
| drop [Unix.IOVec] | drop iovec ndropsncharacters fromiovec. | 
| drop [List] | |
| drop_back_exn [Dequeue] | |
| drop_front_exn [Dequeue] | |
| drop_indices_greater_than_exn [Dequeue] | |
| drop_indices_less_than_exn [Dequeue] | |
| drop_prefix [Substring_intf.S] | |
| drop_prefix [Make_substring.F] | |
| drop_prefix [String] | drop_prefix s ndrops the longest prefix ofsof length less than or equal ton | 
| drop_suffix [Substring_intf.S] | |
| drop_suffix [Make_substring.F] | |
| drop_suffix [String] | drop_suffix s ndrops the longest suffix ofsof length less than or equal ton | 
| drop_while [List] | drop_while l ~fdrops the longest prefix oflfor whichfistrue. | 
| dup [Unix] | 
Return a new file descriptor referencing the same file as
   the given descriptor.
 | 
| dup2 [Unix] | dup2 fd1 fd2duplicatesfd1tofd2, closingfd2if already
   opened. | 
| E | |
| elements [Core_set_intf.Accessors] | |
| empty [Univ_map] | |
| empty [Int_set] | |
| empty [Interval_intf.Gen] | |
| empty [Fqueue] | 
The empty queue
 | 
| empty [Unix.IOVec] | emptythe empty I/O-vector. | 
| empty [Unix.Select_fds] | |
| empty [Core_set_intf.S] | |
| empty [Core_set_intf.Creators] | |
| empty [Set.Poly] | |
| empty [Core_map_intf.Creators] | 
the empty map
 | 
| empty [Map.Poly] | |
| empty [Array] | empty ()creates an empty array | 
| empty [Command.Spec] | 
the empty command-line spec
 | 
| empty [Avltree] | |
| end_of_day [Ofday] | |
| endpwent [Unix.Passwd.Low_level] | |
| enqueue [Thread_safe_queue] | |
| enqueue [Hash_queue.S] | enqueue t k vadds the key-value pair (k, v) to the end of the queue,
       returning `Ok if the pair was added, or `Key_already_present
       if there is already a (k, v') in the queue. | 
| enqueue [Hash_queue.Make] | |
| enqueue [Fqueue] | enqueue t xreturns a queue with addsxto the end oft. | 
| enqueue [Queue] | enqueue t xaddsxto the end oft. | 
| enqueue_exn [Hash_queue.S] | |
| enqueue_exn [Hash_queue.Make] | |
| enqueue_top [Fqueue] | 
enqueue a single element on the *top* of the queue.
 | 
| environment [Unix] | 
Return the process environment, as an array of strings
    with the format ``variable=value''.
 | 
| epoch [Time] | |
| eprintf [Printf] | |
| epsilon [Span] | |
| epsilon [Float_robust_compare.S] | |
| epsilon [Float_intf.S] | |
| epsilon_float [Float_intf.S] | |
| epsilon_float [Common] | |
| equal [Tuple.T3] | |
| equal [Tuple.T2] | |
| equal [Signal] | |
| equal [Stable_unit_test_intf.Arg] | |
| equal [Polymorphic_compare] | |
| equal [Option] | |
| equal [No_polymorphic_compare] | |
| equal [Nano_mutex] | equalisphys_equal | 
| equal [Mutex0] | |
| equal [Linux_ext.Epoll.Flags] | |
| equal [Linux_ext.Priority] | |
| equal [Hash_set_intf.Accessors] | |
| equal [Equal.S3] | |
| equal [Equal.S2] | |
| equal [Equal.S1] | |
| equal [Equal.S] | |
| equal [Doubly_linked.Elt] | |
| equal [Doubly_linked] | 
predicates
 | 
| equal [String] | 
fast equality function on strings, doesn't use compare_val
 | 
| equal [Core_set_intf.Accessors] | subset t1 t2returns true ifft1is a subset oft2. | 
| equal [Mutex] | |
| equal [Core_map_intf.Accessors] | equal cmp m1 m2tests whether the mapsm1andm2are equal, that is, contain
      equal keys and associate them with equal data. | 
| equal [List] | |
| equal [Core_hashtbl_intf.Accessors] | |
| equal [Condition] | |
| equal [Array] | |
| equal [Polymorphic_compare_intf.S] | |
| equal [Comparable.Make_common.Replace_polymorphic_compare] | |
| equal [Common] | 
toplevel binding for polymorphic equality (=).
 | 
| equal [Bag.Elt] | |
| err [Linux_ext.Epoll.Flags] | |
| error [Result] | |
| error [Or_error] | error message value sexp_of_valueconstructs anError.tand returns it as aResult.Error. | 
| 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] | |
| error_of_sexp__ [Unix.Exit_or_signal_or_stop] | |
| error_of_sexp__ [Unix.Exit_or_signal] | |
| error_of_sexp__ [Unix.Exit] | |
| error_string [Or_error] | error_string messageisError (Error.of_string message) | 
| escape [String.Escaping] | escape ~escapeworthy ~escape_char sis. | 
| escape [Command.Deprecated.Spec] | |
| escape [Command.Spec] | escapeflags may be passed at most once. | 
| escape_gen [String.Escaping] | |
| escape_gen_exn [String.Escaping] | escape_gen_exn escapeworthy_map escape_charreturns a function that will escape a
      stringsas follows: if(c1,c2)is inescapeworthy_map, then all occurences ofc1are replaced byescape_charconcatenated toc2. | 
| escaped [String] | 
Warning: Only returns a copy if changes are necessary!  Special characters are
    represented by escape sequences, following the lexical conventions of Objective
    Caml.
 | 
| escaped [Char] | 
Return a string representing the given character, with special characters escaped
    following the lexical conventions of Objective Caml.
 | 
| establish_server [Unix] | 
Establish a server on the given address.
 | 
| et [Linux_ext.Epoll.Flags] | |
| eval [Blang] | eval t fevaluates the propositiontrelative to an environmentfthat assigns truth values to base propositions. | 
| exec [Unix] | exec ~prog ~args ?search_path ?envexecsprogwithargs. | 
| executable_name [Sys] | 
The name of the file containing the executable currently running.
 | 
| execution_mode [Sys] | execution_modetests whether the code being executed was compiled natively
    or to bytecode. | 
| exists [Hash_queue.Make] | |
| exists [Unix.Resource_usage.Fields] | |
| exists [Core_map_intf.Accessors] | |
| exists [Core_hashtbl_intf.Accessors] | |
| exists [Gc.Control.Fields] | |
| exists [Gc.Stat.Fields] | |
| exists [Container.Generic_phantom] | |
| exists [Container.Generic] | |
| exists [Container.S1_phantom] | |
| exists [Container.S1] | |
| exists [Container.S0_phantom] | |
| exists [Container.S0] | |
| exists [Container.Make] | |
| exists [Bounded_int_table] | |
| exists2_exn [List] | 
Same as  List.exists, but for a two-argument predicate. | 
| existsi [Core_hashtbl_intf.Accessors] | |
| existsi [Bounded_int_table] | |
| exit [Thread] | 
Terminate prematurely the currently executing thread.
 | 
| exit_immediately [Unix] | exit_immediately exit_codeimmediately calls theexitsystem call with the given
    exit code without performing any other actions (unlike Pervasives.exit). | 
| exitf [Printf] | 
print to stderr; exit 1
 | 
| exn_if_dup [List] | exn_if_dup ?compare ?context t ~to_sexpwill runfind_a_dupont, and raiseDuplicate_foundif a duplicate is found. | 
| F | |
| fail [Result] | |
| failf [Result] | 
e.g.
 | 
| failwithf [Printf] | 
raises Failure
 | 
| failwithf [Common] | |
| failwiths [Error] | failwiths message value sexp_of_valueraises an exception with the suppliedmessageandvalue, by constructing anError.tand usingError.raise. | 
| failwiths [Common] | |
| false_ [Blang] | |
| fchmod [Unix] | 
Change the permissions of an opened file.
 | 
| fchown [Unix] | 
Change the owner uid and owner gid of an opened file.
 | 
| fdatasync [Unix] | 
Synchronize the kernel buffers of a given file descriptor with disk,
    but do not necessarily write file attributes.
 | 
| feed [Unpack_buffer] | feed t buf ?pos ?lenadds the specified substring ofbuftot's buffer. | 
| feed_string [Unpack_buffer] | |
| fg [Quickcheck] | 
float generator (no nan, inf, etc.)
 | 
| 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_existsbut 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 [String] | |
| fill [Array] | Array.fill a ofs len xmodifies the arrayain place,
   storingxin elements numberofstoofs + len - 1. | 
| fill [Bucket.S] | |
| fill [Bucket.Make] | |
| filter [Option] | |
| filter [Hash_set_intf.Accessors] | |
| filter [String] | filter s ~f:predicatediscards characters not satisfyingpredicate | 
| filter [Core_set_intf.Accessors] | 
if  res = partition_tf set ~fthenfst resare the elements on whichfproducedtrue, andsnd resare the elements on whichfproducesfalse | 
| filter [Core_map_intf.Accessors] | |
| filter [List] | filter p lreturns all the elements of the listlthat satisfy the predicatep. | 
| filter [Core_hashtbl_intf.Accessors] | |
| filter [Array] | filter ~f arrayremoves the elements for whichfreturns false. | 
| filter_inplace [Hash_set_intf.Accessors] | |
| filter_inplace [Doubly_linked] | filter_inplace t ~fremoves all elements oftthat don't satisfyf. | 
| filter_inplace [Queue] | filter_inplace t ~fremoves all elements oftthat don't satisfyf. | 
| filter_inplace [Core_hashtbl_intf.Accessors] | |
| filter_map [Core_set_intf.Creators] | |
| filter_map [Queue] | |
| filter_map [Core_map_intf.Accessors] | 
returns new map with bound values filtered by f applied to the bound values
 | 
| filter_map [List] | filter_map f lis the sublist oflcontaining only elements
    for whichfreturnsSome e. | 
| filter_map [Core_hashtbl_intf.Accessors] | 
returns new map with bound values filtered by f applied to the bound
      values
 | 
| filter_map [Array] | filter_map ~f arraymapsfoverarrayand filtersNoneout of the results. | 
| filter_map [Bounded_int_table] | |
| filter_mapi [Core_map_intf.Accessors] | 
like  filter_map, but function takes both key and data as arguments | 
| filter_mapi [List] | 
filter_mapi is just like filter_map, but it also passes in the index of each
    element as the first argument to the mapped function.
 | 
| filter_mapi [Core_hashtbl_intf.Accessors] | 
like  filter_map, but function takes both key and data as arguments | 
| filter_mapi [Array] | 
Same as  filter_mapbut usesArray.mapi. | 
| filter_mapi [Bounded_int_table] | |
| filter_opt [List] | filter_opt lis the sublist oflcontaining only elements
    which areSome e. | 
| filter_opt [Array] | filter_opt arrayreturns a new array whereNoneentries are omitted andSome xentries are replaced withx. | 
| filteri [List] | |
| filteri [Core_hashtbl_intf.Accessors] | |
| filteri [Array] | 
Like  filterexceptfalso receives the index. | 
| filteri_inplace [Core_hashtbl_intf.Accessors] | |
| finalise_release [Gc] | 
A finalisation function may call  finalise_releaseto tell the
    GC that it can launch the next finalisation function without waiting
    for the current one to return. | 
| find [Univ_map.Multi] | |
| find [Univ_map.With_fold] | |
| find [Univ_map.With_default] | |
| find [Univ_map] | |
| find [Zone] | find namelooks up atby its name and returns it. | 
| find [Linux_ext.Epoll] | 
map operations
 | 
| find [Hash_heap.S] | |
| find [Hash_heap.Make] | |
| find [Hash_queue.Make] | |
| find [Core_map_intf.Accessors] | 
returns the value bound to the given key, raising  Not_foundif none
      such exists | 
| find [List.Assoc] | |
| find [Core_hashtbl_intf.Accessors] | find t kreturns Some (the current binding) of k in t, or None if no
      such binding exists | 
| find [Container.Generic_phantom] | |
| find [Container.Generic] | |
| find [Container.S1_phantom] | |
| find [Container.S1] | |
| find [Container.S0_phantom] | |
| find [Container.S0] | |
| find [Container.Make] | |
| find [Bounded_int_table] | |
| find [Bigstring] | find ?pos ?len char treturnsSome ifor the smallesti >= possuch thatt.{i} = char, orNoneif there is no suchi. | 
| find [Avltree] | 
if the specified key exists in the tree, return the corresponding value.
 | 
| find_a_dup [List] | find_a_dupreturns a duplicate from the list (no guarantees about which
    duplicate you get), or None if there are no dups. | 
| find_elt [Doubly_linked] | find_elt t ~ffinds the first element intthat satisfiesf, by testing each of
    element oftin turn untilfsucceeds. | 
| find_elt [Bag] | find_elt t ~flooks at elements in the bag one-by-one until it finds oneeltsuch thatf (Elt.value elt), in which case it returnsSome elt. | 
| find_exn [Univ_map] | |
| find_exn [Zone] | |
| find_exn [Linux_ext.Epoll] | |
| find_exn [Hash_heap.S] | |
| find_exn [Hash_heap.Make] | |
| find_exn [Core_set_intf.Accessors] | find_index t ireturns theith smallest element oftin O(log n) time. | 
| find_exn [Core_map_intf.Accessors] | |
| find_exn [List.Assoc] | |
| find_exn [List] | find_exn t ~freturns the first element oftthat satisfiesf. | 
| find_exn [Core_hashtbl_intf.Accessors] | find_exn t kreturns the current binding of k in t, or raises Not_found
      if no such binding exists. | 
| find_exn [Array] | find_exn f treturns the firstaintfor whichf t.(i)is true. | 
| find_exn [Bounded_int_table] | |
| find_heap_el_exn [Heap] | find_heap_el_exn heap el | 
| find_index [Core_set_intf.Accessors] | |
| find_map [Hash_queue.Make] | |
| find_map [Container.Generic_phantom] | |
| find_map [Container.Generic] | |
| find_map [Container.S1_phantom] | |
| find_map [Container.S1] | |
| find_map [Container.S0_phantom] | |
| find_map [Container.S0] | |
| find_map [Container.Make] | |
| find_office [Zone] | find_office officea more type-safe interface for pulling timezones related to
    existing Jane Street offices/locations. | 
| find_or_add [Core_hashtbl_intf.Accessors] | find_or_add t k ~defaultreturns the data associated with key k if it
      is in the table t, otherwise it lets d = default() and adds it to the
      table. | 
| find_or_add [Bounded_int_table] | |
| find_pop [Hash_heap.S] | |
| find_pop [Hash_heap.Make] | |
| find_pop_exn [Hash_heap.S] | |
| find_pop_exn [Hash_heap.Make] | |
| findi [List] | |
| findi [Array] | findi t freturns the first indexioftfor whichf i t.(i)is true | 
| findi_exn [Array] | findi_exn t freturns the first indexioftfor whichf i t.(i)is
    true. | 
| first [Hash_queue.S] | first treturns the front element of the queue, without removing it. | 
| first [Hash_queue.Make] | |
| first [Doubly_linked] | |
| first [Avltree] | |
| first_elt [Doubly_linked] | 
constant-time extraction of first and last elements.
 | 
| first_some [Option] | |
| flag [Command.Spec] | flag name spec ~docspecifies a command that, among other things, takes a flag
      namednameon its command line. | 
| flag_and [Linux_ext.Epoll.Flags] | |
| flag_not [Linux_ext.Epoll.Flags] | |
| flip [Fn] | 
reverse the order of arguments for a binary function
 | 
| float [Command.Spec] | |
| float [Random.State] | |
| float [Random] | Random.float boundreturns a random floating-point number between 0 (inclusive) andbound(exclusive). | 
| float_of_bits [Int64] | |
| float_of_bits [Int32] | |
| float_of_hh_mm_ss [Time_internal] | |
| float_of_int [Common] | |
| float_of_sexp [Std_internal] | |
| float_of_string [Common] | |
| flock [Unix] | flock fd cmdplaces or releases a lock on the fd as per the flock C call of the same
    name. | 
| floor [Common] | |
| flow_action_of_sexp [Unix.Terminal_io] | |
| flush [Out_channel] | |
| flush_queue_of_sexp [Unix.Terminal_io] | |
| fnmatch [Unix] | |
| fold [Hash_queue.Make] | |
| fold [Dequeue] | |
| fold [Unix.Resource_usage.Fields.Direct] | |
| fold [Unix.Resource_usage.Fields] | |
| fold [Queue] | |
| fold [Core_map_intf.Accessors] | 
folds over keys and data in map in increasing order of key.
 | 
| fold [Core_hashtbl_intf.Accessors] | |
| fold [Gc.Control.Fields.Direct] | |
| fold [Gc.Control.Fields] | |
| fold [Gc.Stat.Fields.Direct] | |
| fold [Gc.Stat.Fields] | |
| fold [Container.Generic_phantom] | |
| fold [Container.Generic] | |
| fold [Container.S1_phantom] | |
| fold [Container.S1] | |
| fold [Container.S0_phantom] | |
| fold [Container.S0] | |
| fold [Container.T] | |
| fold [Container.Make] | |
| fold [Bounded_int_table] | |
| fold [Avltree] | 
fold over the tree
 | 
| fold2_exn [List] | List.fold2_exn f a [b1; ...; bn] [c1; ...; cn]isf (... (f (f a b1 c1) b2 c2) ...) bn cn. | 
| fold2_exn [Array] | |
| fold_count [Container] | |
| fold_dir [Sys] | |
| fold_elt [Doubly_linked] | fold_elt t ~init ~fis the same as fold, exceptfis called with the'a Elt.t's
    from the list instead of the contained'avalues. | 
| fold_elt [Bag] | fold_elt t ~init ~fis the same as fold, exceptfis called with the'a Elt.t's from the bag instead of the contained'avalues. | 
| fold_left [List] | |
| fold_lines [In_channel] | fold_lines ?fix_win_eol t ~init ~ffolds over the lines read fromtusinginput_line. | 
| fold_range_inclusive [Core_map_intf.Accessors] | fold_range_inclusive t ~min ~max ~init ~ffolds f (with initial value ~init) over all keys (and their associated values)
      that are in the rangemin, max(inclusive). | 
| fold_ready [Linux_ext.Epoll] | |
| fold_right [Doubly_linked] | |
| fold_right [Core_set_intf.Accessors] | |
| fold_right [Core_map_intf.Accessors] | 
folds over keys and data in map in decreasing order of key.
 | 
| fold_right [List] | List.fold_right f [a1; ...; an] bisf a1 (f a2 (... (f an b) ...)). | 
| fold_right [Array] | Array.fold_right f a ~initcomputesf a.(0) (f a.(1) ( ... (f a.(n-1) init) ...)),
   wherenis the length of the arraya. | 
| fold_until [Core_set_intf.Accessors] | |
| foldi [Hash_queue.S] | |
| foldi [Hash_queue.Make] | |
| foldi [Dequeue] | |
| foldi [String] | foldiworks similarly tofold, but also pass in index of each character tof | 
| foldi [List] | 
foldi is just like fold, but it also passes in the index of each
    element as the first argument to the folded function.
 | 
| foldi [Array] | |
| following_weekday [Date] | |
| for_all [Hash_queue.Make] | |
| for_all [Unix.Resource_usage.Fields] | |
| for_all [Core_map_intf.Accessors] | 
same semantics as similar functions in List
 | 
| for_all [Gc.Control.Fields] | |
| for_all [Gc.Stat.Fields] | |
| for_all [Container.Generic_phantom] | |
| for_all [Container.Generic] | |
| for_all [Container.S1_phantom] | |
| for_all [Container.S1] | |
| for_all [Container.S0_phantom] | |
| for_all [Container.S0] | |
| for_all [Container.Make] | |
| for_all [Bounded_int_table] | |
| for_all2_exn [List] | 
Same as  List.for_all, but for a two-argument predicate. | 
| for_all2_exn [Array] | for_all2 t1 t2 ~ffails iflength t1 <> length t2. | 
| for_alli [Bounded_int_table] | |
| forbid_new_string_and_sexp_formats [Time] | 
If this is called it asserts that use_new_string_and_sexp_formats has not been called,
    and will cause use_new_string_and_sexp_formats to throw an exception if it is called
    later
 | 
| force [Only_in_test] | |
| force [Force_once] | force truns the thunk if it hadn't already been forced, else it raises an
    exception. | 
| force [Lazy] | force xforces the suspensionxand returns its result. | 
| force [Common] | |
| force_val [Lazy] | 
Like  forceexcept that if the computation ofxraises an exception, it is
    unspecified whetherforce_val xraises the same exception orUndefined. | 
| forever [Fn] | forever frunsf ()until it throws an exception and returns the
    exception. | 
| fork [Unix] | fork ()forks a new process. | 
| fork_exec [Unix] | fork_exec ~prog ~args ?use_path ?env ()forks and execsprogwithargsin the
    child process, returning the child pid to the parent. | 
| format [Time] | format t fmtformats the given time according to fmt, which follows the formatting
    rules given in 'man strftime'. | 
| format [Time.Date] | |
| formatter_of_buffer [Bigbuffer.Format] | |
| fpe [Signal] | 
| Dump_core | Arithmetic exception                          |
 | 
| fprintf [Printf] | |
| fractional [Float_intf.S.Parts] | |
| fragments [Gc.Stat.Fields] | |
| fragments [Gc.Stat] | |
| free_blocks [Gc.Stat.Fields] | |
| free_blocks [Gc.Stat] | |
| free_words [Gc.Stat.Fields] | |
| free_words [Gc.Stat] | |
| frexp [Float_intf.S] | |
| frexp [Common] | |
| fri [Weekday] | |
| front_index [Dequeue] | |
| fst3 [Common] | 
triple handling 
 | 
| 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.
 | 
| full_init [Random] | 
Same as  Random.initbut takes more data as seed. | 
| full_major [Gc] | 
Do a minor collection, finish the current major collection cycle,
   and perform a complete new cycle.
 | 
| G | |
| gather_conjuncts [Blang] | gather_conjuncts tgathers up all toplevel conjuncts int. | 
| gather_disjuncts [Blang] | gather_disjuncts tgathers up all toplevel disjuncts int. | 
| general [Memo] | 
Returns memoized version of any function with a single argument.
 | 
| get [Weekday] | |
| get [Union_find] | get treturns the value of the class oft. | 
| get [Set_once] | |
| get [Piecewise_linear.S] | |
| get [Linux_ext.Clock] | |
| get [Weak] | |
| get [Unix.Resource_usage] | |
| get [Unix.RLimit] | |
| get [String] | |
| get [Gc] | 
Return the current values of the GC parameters in a  controlrecord. | 
| get [Array] | Array.get a nreturns the element numbernof arraya. | 
| get [Bigstring] | get t posreturns the character atpos | 
| get [Backtrace] | |
| get1 [Tuple.T3] | |
| get1 [Tuple.T2] | |
| get1 [Space_safe_tuple.T3] | |
| get1 [Space_safe_tuple.T2] | |
| get2 [Tuple.T3] | |
| get2 [Tuple.T2] | |
| get2 [Space_safe_tuple.T3] | |
| get2 [Space_safe_tuple.T2] | |
| get3 [Tuple.T3] | |
| get3 [Space_safe_tuple.T3] | |
| get_back [Dequeue] | |
| get_back_exn [Dequeue] | |
| get_backtrace [Printexc] | |
| get_cmp [Heap] | get_cmp heap | 
| get_digit [Char] | 
Return  Some iifis_digit candNoneotherwise. | 
| get_digit_exn [Char] | 
Return  iifis_digit c. | 
| get_event_interval [Timer] | get_event_interval event | 
| get_event_time [Timer] | get_event_time event | 
| get_exn [Set_once] | |
| get_exn [Dequeue] | |
| get_flag_names [Command.Deprecated] | |
| get_front [Dequeue] | |
| get_front_exn [Dequeue] | |
| get_hostname_and_pid [Lock_file.Nfs] | get_hostname_and_pid pathreads the lock file atpathand returns the hostname
      and path in the file if it can be parsed. | 
| get_ipv4_address_for_interface [Linux_ext] | |
| get_opt_len [Bigstring] | get_opt_len bstr ~pos opt_len | 
| get_pos_len [Ordered_collection_common] | |
| get_pos_len_exn [Ordered_collection_common] | get_pos_lenandget_pos_len_exnare intended to be used by functions
 *  that take a sequence (array, string, bigstring, ...) and an optionalpos*  andlenspecifying a subrange of the sequence. | 
| get_process_clock [Linux_ext.Clock] | get_process_clockthe 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_state [Random] | 
OCaml's  Random.get_statemakes a copy of the default state, which is almost
    certainly not what you want. | 
| get_terminal_size [Linux_ext] | get_terminal_size () | 
| get_thread_clock [Linux_ext.Clock] | get_thread_clockthe clock measuring the CPU-time of the current thread. | 
| get_time [Linux_ext.Clock] | |
| get_timer [Timer] | get_timer event | 
| getaddrinfo [Unix] | getaddrinfo host service optsreturns a list ofUnix.addr_inforecords 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  hostswith the given address. | 
| getbyaddr_exn [Unix.Host] | |
| getbygid [Unix.Group] | |
| getbygid_exn [Unix.Group] | |
| getbyname [Unix.Service] | 
Find an entry in  serviceswith the given name. | 
| getbyname [Unix.Protocol] | 
Find an entry in  protocolswith the given name. | 
| getbyname [Unix.Host] | 
Find an entry in  hostswith 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  protocolswith the given protocol number. | 
| getbynumber_exn [Unix.Protocol] | |
| getbyport [Unix.Service] | 
Find an entry in  serviceswith 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 groupreturns the list of groups to whichuserbelongs. | 
| 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 optsreturns the host name and service name
    corresponding to the socket addressaddr. | 
| 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] | getpwentsis 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.getsockoptfor a socket option whose value is a floating-point
    number. | 
| getsockopt_int [Unix] | 
Same as  UnixLabels.getsockoptfor an integer-valued socket option. | 
| getsockopt_optint [Unix] | 
Same as  UnixLabels.getsockoptfor a socket option whose value is anint option. | 
| gettcpopt_bool [Linux_ext] | gettcpopt_bool sock opt | 
| gettid [Linux_ext] | |
| gettimeofday [Unix] | 
Same as  Unix.timeabove, but with resolution better than 1 second. | 
| getuid [Unix] | 
Return the user id of the user executing the process.
 | 
| gigabytes [Byte_units] | |
| gmtime [Unix] | 
Convert a time in seconds, as returned by  UnixLabels.time, into a date and
   a time. | 
| group [List] | group l ~breakreturns a list of lists (i.e., groups) whose concatenation is
    equal to the original list. | 
| group [Core_hashtbl_intf.Creators] | |
| group [Command] | group ~summary subcommand_alistis a compound command with named
    subcommands, as found insubcommand_alist. | 
| group_by [Core_set_intf.Accessors] | 
if  equivis an equivalence predicate, thengroup_by set ~equivproduces a list
      of equivalence classes (i.e., a set-theoretic quotient). | 
| groupi [List] | 
This is just like group, except that you get the index in the original list of the
    current element along with the two elements.
 | 
| H | |
| half_open_intervals_are_a_partition [Interval_intf.Gen] | |
| handle [Signal] | handle t fisset t (`Handle f). | 
| handle_default [Signal] | handle_default tisset t `Default. | 
| handle_uncaught [Exn] | handle_uncaught ~exit fcatches an exception escapingfand prints an error
    message to stderr. | 
| handle_uncaught_and_exit [Exn] | 
behaves as  handle_uncaught ~exit:trueand also has a more precise
    type in this case | 
| handle_unix_error [Unix] | handle_unix_error frunsf ()and returns the result. | 
| hash [Hashable.S_binable] | |
| hash [Hashable.S] | |
| hash [String] | 
slightly faster hash function on strings
 | 
| hash [Core_hashtbl_intf.Key] | 
Values returned by  hashmust be non-negative. | 
| hash [Core_hashtbl_intf.Hashable] | |
| hash [Hashtbl] | |
| hash_param [Core_hashtbl_intf.Hashable] | |
| hash_param [Hashtbl] | |
| hashable [Hashable.S_binable] | |
| hashable [Hashable.S] | |
| hashable [Hashable.Make_binable] | |
| hashable [Hashable.Make] | |
| hashable [Core_hashtbl_intf.S] | |
| hashable [Hashtbl.Poly] | |
| have_address_in_common [Unix.Host] | |
| hd [List] | |
| hd_exn [List] | 
Return the first element of the given list.
 | 
| heap_chunks [Gc.Stat.Fields] | |
| heap_chunks [Gc.Stat] | |
| heap_el_get_el [Heap] | heap_el_get_el heap_el | 
| heap_el_get_heap_exn [Heap] | heap_el_get_heap_exn heap_el | 
| heap_el_is_valid [Heap] | heap_el_is_valid heap_el | 
| heap_el_mem [Heap] | heap_el_mem heap heap_el | 
| heap_words [Gc.Stat.Fields] | |
| heap_words [Gc.Stat] | |
| help [Command.Spec] | 
the help text for the command
 | 
| help_recursive [Command.Deprecated] | |
| host [Host_and_port] | |
| hour [Span] | |
| hup [Signal] | 
| Terminate | Hangup on controlling terminal                |
 | 
| hup [Linux_ext.Epoll.Flags] | |
| I | |
| id [Fn] | 
The identity function
 | 
| id [Thread] | 
Return the identifier of the given thread.
 | 
| ident [Common] | |
| idrss [Unix.Resource_usage.Fields] | |
| idrss [Unix.Resource_usage] | |
| if_ [Blang] | |
| if_indextoname [Unix] | |
| ifprintf [Printf] | |
| ignore [Signal] | ignore tisset t `Ignore. | 
| ignore [Monad.S2] | |
| ignore [Monad.Make2] | |
| ignore [Monad.Make] | |
| ignore [Monad.S] | ignore t= map t ~f:(fun _ -> ()). | 
| ignore [Force_once] | ignore ()= create (fun () -> ()) | 
| ignore [Fn] | 
*  ignoreis the same asPervasives.ignore. | 
| ill [Signal] | 
| Dump_core | Invalid hardware instruction                  |
 | 
| immutable_of_sexp [Common] | |
| in_ [Linux_ext.Epoll.Flags] | |
| in_channel_length [Common] | |
| 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] | |
| incr [Int_intf.S] | |
| incr [Core_hashtbl_intf.Accessors] | |
| index [String.Escaping] | index s ~escape_char charfind the first literal (not escaped) instance of
      char in s starting from 0. | 
| index [String] | |
| index_exn [String.Escaping] | |
| index_exn [String] | |
| index_from [String.Escaping] | index_from s ~escape_char pos charfind the first literal (not escaped)
      instance of char in s starting from pos and proceeding towards the end of s. | 
| index_from [String] | |
| index_from_exn [String.Escaping] | |
| index_from_exn [String] | |
| infinity [Float_intf.S] | |
| infinity [Common] | |
| init [Zone] | init ()pre-load all available time zones from disk, this function has no effect if
    it is called multiple times. | 
| init [Pid] | |
| init [String] | |
| init [List] | init f nis[(f 0); (f 1); ...; (f (n-1))]. | 
| init [Array] | init n ~fcreates an array of lengthnwhere theith element is initialized withf i(starting at zero) | 
| init [Bigstring] | init n ~fcreates a bigstringtof lengthn, witht.{i} = f i | 
| init [Random] | 
Initialize the generator, using the argument as a seed.
 | 
| initgroups [Unix] | |
| initialized_zones [Zone] | initialized_zones ()returns a sorted list of time zone names that have been loaded
    from disk thus far. | 
| input [In_channel] | |
| input [Bigstring] | input ?min_len ic ?pos ?len bstrtries to readlenbytes
    (guarantees to read at leastmin_lenbytes (must be greater than
    or equal to zero and smaller or equal tolen), if possible, before
    returning) from input channelic, and writes them to bigstringbstrstarting at positionpos. | 
| input_all [In_channel] | |
| input_binary_int [In_channel] | |
| input_byte [In_channel] | |
| input_char [In_channel] | |
| input_line [In_channel] | input_line ?fix_win_eol treads a line fromtand returns it, without
    the newline ("\n") character at the end, and, iffix_win_eolthe trailing
    "\r\n" is dropped. | 
| input_lines [In_channel] | 
Completely reads an input channel and returns the results as a list of
    strings.
 | 
| insert_after [Doubly_linked] | |
| insert_before [Doubly_linked] | 
constant-time insertion of a new element.
 | 
| insert_delimiter [Int_conversions] | |
| insert_first [Doubly_linked] | |
| insert_last [Doubly_linked] | |
| insert_underscores [Int_conversions] | |
| int [Signal] | 
| Terminate | Interactive interrupt (ctrl-C)                |
 | 
| int [Command.Spec] | |
| int [Random.State] | |
| int [Random] | Random.int boundreturns a random integer between 0 (inclusive) andbound(exclusive). | 
| int32 [Random.State] | |
| int32 [Random] | Random.int32 boundreturns a random integer between 0 (inclusive) andbound(exclusive). | 
| int32_of_sexp [Std_internal] | |
| int32_to_int [Int_conversions] | |
| int32_to_int64 [Int_conversions] | |
| int32_to_int_exn [Int_conversions] | |
| int32_to_nativeint [Int_conversions] | |
| int64 [Random.State] | |
| int64 [Random] | Random.int64 boundreturns a random integer between 0 (inclusive) andbound(exclusive). | 
| int64_of_sexp [Std_internal] | |
| int64_to_int [Int_conversions] | |
| int64_to_int32 [Int_conversions] | |
| int64_to_int32_exn [Int_conversions] | |
| int64_to_int_exn [Int_conversions] | |
| int64_to_nativeint [Int_conversions] | |
| int64_to_nativeint_exn [Int_conversions] | |
| int_of_float [Common] | |
| int_of_sexp [Std_internal] | |
| int_to_int32 [Int_conversions] | |
| int_to_int32_exn [Int_conversions] | |
| int_to_int64 [Int_conversions] | |
| int_to_nativeint [Int_conversions] | |
| integral [Float_intf.S.Parts] | |
| inter [Core_set_intf.Accessors] | |
| interactive [Sys] | 
This reference is initially set to  falsein standalone programs and totrueif the code is being executed under the interactive toplevel systemocaml. | 
| interruptible_pause [Time] | interruptible_pause spansleeps for span time unless interrupted (e.g. | 
| intersect [Interval_intf.Gen] | |
| 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
 | 
| invalid_argf [Printf] | 
raises Invalid_arg
 | 
| invalid_argf [Common] | |
| invariant [Weekday] | |
| invariant [Unpack_buffer] | |
| invariant [Nano_mutex] | |
| invariant [Linux_ext.Epoll] | |
| invariant [Invariant.S3] | |
| invariant [Invariant.S2] | |
| invariant [Invariant.S1] | |
| invariant [Invariant.S] | |
| invariant [Hash_queue.S] | invariant tchecks the invariants of the queue. | 
| invariant [Hash_queue.Make] | |
| invariant [Doubly_linked] | |
| invariant [Dequeue] | |
| invariant [Stack] | |
| invariant [Core_hashtbl_intf.Accessors] | |
| invariant [Bounded_int_table] | |
| invariant [Blang] | |
| invariant [Bag] | |
| invariant [Avltree] | 
check invariants, raise an exception if any invariants fail
 | 
| invariants [Core_set_intf.Accessors] | 
Test if invariants of internal AVL search tree hold.
 | 
| invariants [Core_map_intf.Accessors] | 
Test if invariants of internal AVL search tree hold.
 | 
| inverse [List.Assoc] | |
| iround [Float_intf.S] | |
| iround_exn [Float_intf.S] | |
| is_absolute [Filename] | |
| is_activated [Timer] | is_activated timer | 
| is_alpha [Char] | 
'a' - 'z' or 'A' - 'Z'
 | 
| is_alphanum [Char] | 
'a' - 'z' or 'A' - 'Z' or '0' - '9'
 | 
| is_business_day [Date] | |
| is_char_escaped [String.Escaping] | is_char_escaped s ~escape_char posreturn true if the char atposis escaped,
      false otherwise. | 
| is_char_escaping [String.Escaping] | 
Any char in an escaped string is either escaping, escaped or literal.
 | 
| is_char_literal [String.Escaping] | is_literal s ~escape_char posreturn true if the char atposis not escaped or
      escaping. | 
| is_digit [Char] | 
'0' - '9'
 | 
| is_directory [Sys] | 
Returns  `Yesif the file exists and is a directory | 
| is_directory_exn [Sys] | |
| is_empty [Unpack_buffer] | is_empty treturnstrueifthas no unconsumed bytes, andfalseif it does. | 
| is_empty [Univ_map] | |
| is_empty [Interval_intf.Gen] | |
| is_empty [Heap] | is_empty heap | 
| is_empty [Hash_queue.Make] | |
| is_empty [Fqueue] | |
| is_empty [Dequeue] | |
| is_empty [String] | is_empty sreturnstrueiffsis empty (i.e. | 
| is_empty [Core_map_intf.Accessors] | 
Test whether a map is empty or not.
 | 
| is_empty [Core_hashtbl_intf.Accessors] | |
| is_empty [Container.Generic_phantom] | |
| is_empty [Container.Generic] | |
| is_empty [Container.S1_phantom] | |
| is_empty [Container.S1] | |
| is_empty [Container.S0_phantom] | |
| is_empty [Container.S0] | |
| is_empty [Container.Make] | |
| is_empty_or_singleton [Interval_intf.Gen] | |
| is_error [Result] | |
| is_file [Sys] | 
Returns  `Yesif the file exists and is a regular file | 
| is_file_exn [Sys] | |
| is_finite [Float_intf.S] | |
| is_first [Doubly_linked] | |
| is_implicit [Filename] | 
Return  trueif the file name is relative and does not start
   with an explicit reference to the current directory (./or../in Unix),falseif it starts with an explicit reference
   to the root directory or the current directory. | 
| is_inf [Float_intf.S] | 
includes positive and negative Float.infinity
 | 
| is_last [Doubly_linked] | |
| is_locked [Lock_file] | is_locked pathreturns true when the file atpathexists and is locked, false
    otherwise. | 
| is_lowercase [Char] | 
'a' - 'z'
 | 
| is_mmapped [Bigstring] | is_mmapped bstr | 
| is_nan [Float_intf.S] | |
| is_none [Option] | is_none treturns true iff t = None. | 
| is_none [Common] | |
| is_ok [Result] | |
| is_posix_pathname_component [Filename] | is_posix_pathname_component f | 
| is_prefix [String] | is_prefix s ~prefixreturnstrueifsstarts withprefix. | 
| is_print [Char] | 
' ' - '~'
 | 
| is_relative [Filename] | 
Return  trueif the file name is relative to the current
   directory,falseif it is absolute (i.e. | 
| is_some [Option] | is_some treturns true iff t = Some x. | 
| is_some [Common] | |
| is_sorted [List] | |
| is_sorted [Array] | |
| is_subset [Interval_intf.Gen] | |
| is_suffix [String] | is_suffix s ~suffixreturnstrueifsends withsuffix. | 
| is_sun_or_sat [Weekday] | is_sun_or_satreturns true if t is Sunday or Saturday | 
| is_superset [Interval_intf.Gen] | is_superset i1 of_:i2is whether i1 contains i2. | 
| is_uppercase [Char] | 
'A' - 'Z'
 | 
| is_weekday [Date] | |
| is_weekend [Date] | |
| is_whitespace [Char] | 
' ' or '\t' or '\r' or '\n'
 | 
| isatty [Unix] | 
Return  trueif the given file descriptor refers to a terminal or
   console window,falseotherwise. | 
| isrss [Unix.Resource_usage.Fields] | |
| isrss [Unix.Resource_usage] | |
| iter [Result] | |
| iter [Linux_ext.Epoll] | |
| iter [Heap] | |
| iter [Hash_heap.S] | |
| iter [Hash_heap.Make] | |
| iter [Hash_queue.Make] | |
| iter [Dequeue] | |
| iter [Unix.Resource_usage.Fields.Direct] | |
| iter [Unix.Resource_usage.Fields] | |
| iter [Core_map_intf.Accessors] | 
iterator for map
 | 
| iter [Core_hashtbl_intf.Accessors] | |
| iter [Gc.Control.Fields.Direct] | |
| iter [Gc.Control.Fields] | |
| iter [Gc.Stat.Fields.Direct] | |
| iter [Gc.Stat.Fields] | |
| iter [Container.Generic_phantom] | |
| iter [Container.Generic] | |
| iter [Container.S1_phantom] | |
| iter [Container.S1] | |
| iter [Container.S0_phantom] | |
| iter [Container.S0] | |
| iter [Container.Make] | |
| iter [Bounded_int_table] | |
| iter [Avltree] | 
iterate over the tree
 | 
| iter2 [Core_set_intf.Accessors] | |
| iter2 [Core_map_intf.Accessors] | 
Iterate two maps side by side.
 | 
| iter2_exn [List] | List.iter2_exn f [a1; ...; an] [b1; ...; bn]calls in turnf a1 b1; ...; f an bn. | 
| iter2_exn [Array] | |
| iter_el [Heap] | iter heap ~fiterate overheapwith functionf. | 
| iter_elt [Doubly_linked] | |
| iter_elt [Bag] | |
| iter_error [Result] | |
| iter_lines [In_channel] | iter_lines ?fix_win_eol t ~fappliesfto each line read fromtusinginput_line. | 
| iter_ready [Linux_ext.Epoll] | iter_readyandfold_readyiterate over the ready set computed by the last
      call towait. | 
| iter_vals [Hash_heap.S] | |
| iter_vals [Hash_heap.Make] | |
| iter_vals [Core_hashtbl_intf.Accessors] | iter_vals t ~fis like iter, except it only supplies the value to f,
      not the key. | 
| iter_vals [Bounded_int_table] | |
| iteri [Hash_queue.S] | iter t ~fapplies f to each key and element of the queue. | 
| iteri [Hash_queue.Make] | |
| iteri [Dequeue] | |
| iteri [List] | 
iteri is just like iter, but it also passes in the index of each
    element as the first argument to the iter'd function.
 | 
| iteri [Array] | 
Same as  Array.iter, but the
   function is applied to the index of the element as first argument,
   and the element itself as second argument. | 
| ixrss [Unix.Resource_usage.Fields] | |
| ixrss [Unix.Resource_usage] | |
| J | |
| join [Monad.S2] | |
| join [Monad.Make2] | |
| join [Monad.Make] | |
| join [Monad.S] | join tist >>= (fun t' -> t'). | 
| join [Thread] | join thsuspends the execution of the calling thread
   until the threadthhas terminated. | 
| K | |
| kbprintf [Printf] | |
| keys [Hash_queue.S] | keys treturns the keys in the order of the queue. | 
| keys [Hash_queue.Make] | |
| keys [Core_map_intf.Accessors] | 
returns list of keys in map
 | 
| keys [Core_hashtbl_intf.Accessors] | 
Returns the list of all keys for given hashtable.
 | 
| keys [Bounded_int_table] | 
Standard hashtbl functions.
 | 
| kfprintf [Printf] | |
| kill [Signal] | 
| Terminate | Termination (cannot be ignored)               |
 | 
| kilobytes [Byte_units] | |
| ksprintf [Printf] | |
| L | |
| largest_free [Gc.Stat.Fields] | |
| largest_free [Gc.Stat] | |
| last [Doubly_linked] | |
| last [List] | 
The final element of a list.
 | 
| last [Array] | |
| last [Avltree] | |
| last_elt [Doubly_linked] | |
| last_exn [List] | |
| laws [Quickcheck] | laws iter gen funcappliesfuncrepeatedly (itertimes) on output
    ofgen, and iffuncever returns false, then the input that caused
    the failure is returned optionally. | 
| laws_exn [Quickcheck] | 
Like laws, but throws an exception instead of returning an option.
 | 
| lazy_from_fun [Lazy] | lazy_from_fun fis the same aslazy (f ())but slightly more
    efficient. | 
| lazy_from_val [Lazy] | lazy_from_val vreturns an already-forced suspension ofvThis is for special purposes only and should not be confused withlazy (v). | 
| lazy_is_val [Lazy] | lazy_is_val xreturnstrueifxhas already been forced and
    did not raise an exception. | 
| lazy_t_of_sexp [Std_internal] | |
| lbound [Interval_intf.Gen_set] | |
| lbound [Interval_intf.Gen] | |
| lbound_exn [Interval_intf.Gen_set] | |
| lbound_exn [Interval_intf.Gen] | |
| ldexp [Float_intf.S] | |
| ldexp [Common] | |
| length [Thread_safe_queue] | |
| length [Squeue] | 
returns the number of elements in the queue.
 | 
| length [Out_channel] | |
| length [Substring_intf.S] | |
| length [Make_substring.Base] | |
| length [Make_substring.F] | |
| length [In_channel] | |
| length [Heap] | length heap | 
| length [Hash_heap.S] | |
| length [Hash_heap.Make] | |
| length [Hash_queue.Make] | |
| length [Fqueue] | 
complexity: O(1)
 | 
| length [Dequeue] | |
| length [Weak] | |
| length [String] | |
| length [Core_map_intf.Accessors] | length map | 
| length [Core_hashtbl_intf.Accessors] | |
| length [Container.Generic_phantom] | |
| length [Container.Generic] | |
| length [Container.S1_phantom] | |
| length [Container.S1] | |
| length [Container.S0_phantom] | |
| length [Container.S0] | |
| length [Container.Make] | |
| length [Bounded_int_table] | |
| length [Bigstring] | length bstr | 
| length [Bigbuffer] | 
Return the number of characters currently contained in the buffer.
 | 
| level [Bucket.S] | |
| level [Bucket.Make] | |
| lexicographic [Comparable] | |
| lfindi [String] | lfindi ?pos t ~freturns the smallesti >= possuch thatf i t.[i], if there is
    such ani. | 
| lg [Quickcheck] | 
list generator
 | 
| likely_machine_zones [Zone] | likely_machine_zonesis a list of zone names that will be searched first when trying
    to determine the machine zone of a box. | 
| limit_of_sexp [Unix.RLimit] | |
| link [Unix] | link ?force ~target ~link_name ()creates a hard link namedlink_nameto the file namedtarget. | 
| list_intersect [Interval_intf.Gen] | 
Assuming that  ilist1andilist2are lists of (disjoint) intervals,list_intersect ilist1 ilist2returns the list of disjoint intervals that correspond
      to the intersection ofilist1withilist2. | 
| list_of_sexp [Std_internal] | |
| listed [Command.Spec] | listedflags may be passed zero or more times | 
| listen [Unix] | 
Set up a socket for receiving connection requests.
 | 
| live_blocks [Gc.Stat.Fields] | |
| live_blocks [Gc.Stat] | |
| live_words [Gc.Stat.Fields] | |
| live_words [Gc.Stat] | |
| 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 tlocks the mutext, blocking until it can be locked. | 
| lock [Mutex] | lock mtxlocksmtx, 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] | |
| lookup [Hash_queue.S] | lookup t kreturns the value of the key-value pair in the queue with
     key k, if there is one. | 
| lookup [Hash_queue.Make] | |
| lookup_exn [Hash_queue.S] | |
| lookup_exn [Hash_queue.Make] | |
| lowercase [String] | |
| lowercase [Char] | 
Convert the given character to its equivalent lowercase character.
 | 
| lpop [Squeue] | 
returns the element popped and the length of the queue after
    * this element was popped.
 | 
| ls_dir [Sys] | 
Same as readder, but return a list rather than an array.
 | 
| lseek [Unix.Native_file] | |
| lseek [Unix] | |
| lsplit2 [String.Escaping] | |
| lsplit2 [String] | lsplit2 line ~onoptionally returnslinesplit into two strings around the
  * first appearance ofonfrom the left | 
| lsplit2_exn [String.Escaping] | |
| lsplit2_exn [String] | 
If the string  scontains the characteron, thenlsplit2_exn
    s ~onreturns a pair containingssplit around the first
    appearance ofon(from the left). | 
| 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. | 
| lstrip [String] | lstrip ?drop sreturns a string with consecutive chars satisfyingdrop(by default
    white space, e.g. | 
| M | |
| machine [Unix.Utsname] | |
| machine_zone [Zone] | machine_zone ?refresh ()returns the machines zone (t). | 
| majflt [Unix.Resource_usage.Fields] | |
| majflt [Unix.Resource_usage] | |
| major [Gc] | 
Do a minor collection and finish the current major collection cycle.
 | 
| major_collections [Gc.Stat.Fields] | |
| major_collections [Gc.Stat] | |
| major_heap_increment [Gc.Control.Fields] | |
| major_heap_increment [Gc.Control] | |
| major_slice [Gc] | 
Do a minor collection and a slice of major collection.
 | 
| major_words [Gc.Stat.Fields] | |
| major_words [Gc.Stat] | |
| make [String] | |
| make [Random.State] | 
Create a new state and initialize it with the given seed.
 | 
| make_creator [Unix.Resource_usage.Fields] | |
| make_creator [Gc.Control.Fields] | |
| make_creator [Gc.Stat.Fields] | |
| make_matrix [Array] | Array.make_matrix dimx dimy ereturns a two-dimensional array
   (an array of arrays) with first dimensiondimxand
   second dimensiondimy. | 
| make_self_init [Random.State] | 
Create a new state and initialize it with a system-dependent low-entropy seed.
 | 
| map [Unpack_buffer.Unpack_one] | |
| map [Result] | |
| map [Monad.S2] | |
| map [Monad.Make2] | |
| map [Monad.Make] | |
| map [Interval_intf.Gen] | map t ~freturnscreate (f l) (f u)ifbounds t = Some (l, u), andemptyiftis empty. | 
| map [Monad.S] | map t ~fis t >>| f. | 
| map [Unix.Resource_usage.Fields] | |
| map [String] | map f sappliesfto each character ins, and returns the
    resulting string. | 
| map [Core_set_intf.Creators] | |
| map [Queue] | |
| map [Core_map_intf.Accessors] | 
returns new map with bound values replaced by f applied to the bound values
 | 
| map [List.Assoc] | |
| map [List] | List.map f [a1; ...; an]applies functionftoa1, ..., an, and builds the list[f a1; ...; f an]with the results returned byf. | 
| map [Core_hashtbl_intf.Accessors] | map t freturns new table with bound values replaced byfapplied to the bound values | 
| map [Gc.Control.Fields] | |
| map [Gc.Stat.Fields] | |
| map [Array] | Array.map ~f aapplies functionfto all the elements ofa,
   and builds an array with the results returned byf:[| f a.(0); f a.(1); ...; f a.(Array.length a - 1) |]. | 
| map [Command.Spec] | 
parameter transformation
 | 
| map [Bounded_int_table] | |
| map1 [Tuple.T3] | |
| map1 [Tuple.T2] | |
| map2 [Tuple.T3] | |
| map2 [Tuple.T2] | |
| map2 [Option] | map2 o fmap 'a option and 'b option to a 'c option using ~f | 
| map2_exn [List] | List.map2_exn f [a1; ...; an] [b1; ...; bn]is[f a1 b1; ...; f an bn]. | 
| map2_exn [Array] | |
| map3 [Tuple.T3] | |
| map3_exn [List] | |
| map_error [Result] | |
| map_file [Bigstring] | map_file shared fd nmemory-mapsncharacters of the data
    associated with descriptorfdto a bigstring. | 
| map_poly [Unix.Resource_usage.Fields] | |
| map_poly [Gc.Control.Fields] | |
| map_poly [Gc.Stat.Fields] | |
| mapi [String] | mapi f sappliesfto each character insand its index, and returns the
    resulting string. | 
| mapi [Core_map_intf.Accessors] | 
like  map, but function takes both key and data as arguments | 
| mapi [List] | 
mapi is just like map, but it also passes in the index of each
    element as the first argument to the mapped function.
 | 
| mapi [Core_hashtbl_intf.Accessors] | 
like  map, but function takes both key and data as arguments | 
| mapi [Array] | 
Same as  Array.map, but the
   function is applied to the index of the element as first argument,
   and the element itself as second argument. | 
| mapi [Bounded_int_table] | |
| marshal [Bigstring_marshal] | marshal ?flags vmarshals valuevto a bigstring using marshalling
    flagsflags. | 
| marshal_blit [Bigstring_marshal] | marshal_blit ?flags v ?pos ?len bufmarshals valuevto bigstringbufstarting at positionposand at mostlenbytes. | 
| marshal_data_size [Bigstring_marshal] | marshal_data_size ?pos buf | 
| marshal_to_fd [Bigstring_marshal] | marshal_to_fd ?buf fd vmarshals datavto file descriptorfdusing marshalling bufferbuf, and marshalling flagsflags. | 
| marshal_to_sock_no_sigpipe [Bigstring_marshal] | marshal_to_sock_no_sigpipe ?buf sock vsame asBigstring_marshal.marshal_to_fd, but
    writes to sockets only and usesBigstring.really_send_no_sigpipeto avoidSIGPIPEon sockets. | 
| match_ [Univ] | match_ t constrdoes a single constr match on atfor a given constructor. | 
| max [Polymorphic_compare] | |
| max [No_polymorphic_compare] | |
| max [Int_set] | max tthe biggest number in the set (if it exists) | 
| max [Polymorphic_compare_intf.S] | |
| max [Comparable.Make_common.Replace_polymorphic_compare] | |
| max_elt [Core_set_intf.Accessors] | |
| max_elt [Core_map_intf.Accessors] | max_elt map | 
| max_elt_exn [Core_set_intf.Accessors] | |
| max_elt_exn [Core_map_intf.Accessors] | |
| max_finite_value [Float_intf.S] | |
| max_float [Common] | |
| max_inan [Float_intf.S] | |
| max_int [Common] | |
| max_iovecs [Unix.IOVec] | |
| max_length [String] | 
Maximum length of a string.
 | 
| max_length [Array] | 
Maximum length of a normal array.
 | 
| max_overhead [Gc.Control.Fields] | |
| max_overhead [Gc.Control] | |
| max_value [Int_intf.S] | |
| max_value [Float_intf.S] | |
| max_value [Char] | |
| 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 addrjoin a multicast group ataddrwith socketsock, optionally using network interfaceifname. | 
| mcast_leave [Unix] | mcast_leave ?ifname sock addrleaves a multicast group ataddrwith socketsock, optionally using network interfaceifname. | 
| megabytes [Byte_units] | |
| mem [Univ_map] | |
| mem [Int_set] | mem t itest whetheriis a member of the set | 
| mem [Heap] | mem heap el | 
| mem [Hash_set_intf.Accessors] | |
| mem [Hash_heap.S] | |
| mem [Hash_queue.S] | mem q kreturns true iff there is some (k, v) in the queue. | 
| mem [Hash_heap.Make] | |
| mem [Hash_queue.Make] | |
| mem [Core_set_intf.Accessors] | |
| mem [Core_map_intf.Accessors] | mem map keytests whethermapcontains a binding forkey | 
| mem [List.Assoc] | |
| mem [Core_hashtbl_intf.Accessors] | |
| mem [Container.Generic_phantom] | |
| mem [Container.Generic] | |
| mem [Container.S1_phantom] | |
| mem [Container.S1] | |
| mem [Container.S0_phantom] | |
| mem [Container.S0] | |
| mem [Container.Make] | |
| mem [Bounded_int_table] | |
| mem [Avltree] | 
return true if key is present in the tree, otherwise return false.
 | 
| merge [Core_map_intf.Accessors] | 
merges two maps
 | 
| merge [List] | 
Merge two lists: assuming that  l1andl2are sorted according to the comparison
    functioncmp,merge cmp l1 l2will return a sorted list containting all the
    elements ofl1andl2. | 
| merge [Core_hashtbl_intf.Accessors] | 
Merge two hashtables.
 | 
| merge_into [Core_hashtbl_intf.Accessors] | 
Merge one hashtable into another.
 | 
| microsecond [Span] | |
| millisecond [Span] | |
| min [Polymorphic_compare] | |
| min [No_polymorphic_compare] | |
| min [Int_set] | min tthe smallest number in the set (if it exists) | 
| min [Polymorphic_compare_intf.S] | |
| min [Comparable.Make_common.Replace_polymorphic_compare] | |
| min_elt [Core_set_intf.Accessors] | |
| min_elt [Core_map_intf.Accessors] | min_elt map | 
| min_elt_exn [Core_set_intf.Accessors] | |
| min_elt_exn [Core_map_intf.Accessors] | |
| min_float [Common] | |
| min_inan [Float_intf.S] | 
min and max that return the other value if one of the values is a  nan. | 
| min_int [Common] | |
| min_positive_value [Float_intf.S] | |
| min_value [Int_intf.S] | |
| min_value [Float_intf.S] | |
| min_value [Char] | |
| minflt [Unix.Resource_usage.Fields] | |
| minflt [Unix.Resource_usage] | |
| minor [Gc] | 
Trigger a minor collection.
 | 
| minor_collections [Gc.Stat.Fields] | |
| minor_collections [Gc.Stat] | |
| minor_heap_size [Gc.Control.Fields] | |
| minor_heap_size [Gc.Control] | |
| minor_words [Gc.Stat.Fields] | |
| minor_words [Gc.Stat] | |
| minus_one [Int_intf.S] | |
| minute [Span] | |
| mkdir [Unix] | 
Create a directory.
 | 
| mkdir_p [Unix] | 
Create a directory recursively.
 | 
| mkdtemp [Unix] | mkdtemp prefixcreates a temporary directory withprefix,
    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 pathcreates a filesystem
    entry. | 
| mkstemp [Unix] | mkstemp prefixcreates and opens a unique temporary file withprefix, automatically appending a suffix of six random characters
    to make the name unique. | 
| mktime [Unix] | 
Convert a date and time, specified by the  tmargument, into
   a time in seconds, as returned byUnixLabels.time. | 
| mlockall [Unix.Mman] | |
| mod_float [Float_intf.S] | mod_float x yreturns a result with the same sign asx. | 
| mod_float [Common] | |
| modf [Float_intf.S] | |
| modf [Common] | |
| mon [Weekday] | |
| month [Date] | |
| msg_flag_of_sexp [Unix] | 
The flags for  UnixLabels.recv,UnixLabels.recvfrom,UnixLabels.sendandUnixLabels.sendto. | 
| msgrcv [Unix.Resource_usage.Fields] | |
| msgrcv [Unix.Resource_usage] | |
| msgsnd [Unix.Resource_usage.Fields] | |
| msgsnd [Unix.Resource_usage] | |
| munlockall [Unix.Mman] | |
| N | |
| name [Univ.Constr] | |
| name [Zone] | name zonereturns the name of the time zone | 
| name_info_of_sexp [Unix] | 
Host and service information returned by  Unix.getnameinfo. | 
| names [Unix.Resource_usage.Fields] | |
| names [Gc.Control.Fields] | |
| names [Gc.Stat.Fields] | |
| nan [Float_intf.S] | |
| nan [Common] | |
| nanosecond [Span] | |
| nanosleep [Unix] | nanosleep fdelays execution of the program for at leastfseconds. | 
| nativeint [Random.State] | |
| nativeint [Random] | Random.nativeint boundreturns a random integer between 0 (inclusive) andbound(exclusive). | 
| nativeint_of_sexp [Std_internal] | |
| nativeint_to_int [Int_conversions] | |
| nativeint_to_int32 [Int_conversions] | |
| nativeint_to_int32_exn [Int_conversions] | |
| nativeint_to_int64 [Int_conversions] | |
| nativeint_to_int_exn [Int_conversions] | |
| neg [Span] | 
negation
 | 
| neg [Int_intf.S] | |
| neg [Float_intf.S] | |
| neg_infinity [Float_intf.S] | |
| neg_infinity [Common] | |
| never_returns [Never_returns] | |
| never_returns [Common] | |
| newline [Out_channel] | |
| next [Doubly_linked] | 
constant-time move to next or previous element.
 | 
| next_key [Core_map_intf.Accessors] | rank t kif k is in t, returns the number of keys strictly less than k in t,
      otherwise None | 
| next_multiple [Time] | |
| nget [String] | nget s iGets the char at normalized positioniins. | 
| nget [Array] | 
Array access with  normalized index. | 
| nice [Unix.Priority] | |
| nice [Unix.RLimit] | |
| nice [Unix] | 
Change the process priority.
 | 
| nivcsw [Unix.Resource_usage.Fields] | |
| nivcsw [Unix.Resource_usage] | |
| nng [Quickcheck] | 
natural number generator
 | 
| no_arg [Command.Deprecated.Spec] | |
| no_arg [Command.Spec] | no_argflags may be passed at most once. | 
| no_arg_abort [Command.Spec] | no_arg_abort ~exitis likeno_arg, but aborts command-line parsing
      by callingexit. | 
| no_arg_register [Command.Spec] | no_arg_register ~key ~valueis likeno_arg, but associatesvaluewithkeyin the in the auto-completion environment | 
| no_raise_of_sexp [Sexp] | no_raiseis the identity, but by using'a no_raisein a sexpable type, the
    resulting usesexp_of_no_raiseprotects the conversion of'ato a sexp so that if
    it fails, one gets a sexp with an error message about the failure, rather than an
    exception being raised. | 
| nodename [Unix.Utsname] | |
| non [Fn] | 
Negates a function
 | 
| none [Linux_ext.Epoll.Flags] | |
| normalize [Ordered_collection_common] | |
| normalize [Array] | normalize array indexreturns a new index into the array such that if index is less
    than zero, the returned index will "wrap around" -- i.e. | 
| not_ [Blang] | |
| now [Time_internal.T] | |
| now [Time] | |
| now [Time.Ofday] | |
| nset [String] | nset s i cSets the char at normalized positionitoc. | 
| nset [Array] | 
Array modification with  normalized index. | 
| nsignals [Unix.Resource_usage.Fields] | |
| nsignals [Unix.Resource_usage] | |
| nswap [Unix.Resource_usage.Fields] | |
| nswap [Unix.Resource_usage] | |
| nth [List] | |
| nth [Bigbuffer] | 
get the (zero-based) n-th character of the buffer.
 | 
| nth_exn [List] | 
Return the  n-th element of the given list. | 
| num_bits [Word_size] | |
| num_bits [Int_intf.S] | |
| 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_versionis the version of Objective Caml. | 
| occurrence [Time] | occurrence side time ~ofday ~zonereturns aTime.tthat is the occurrence of ofday
    (in the givenzone) that is the latest occurrence (<=)timeor the earliest
    occurrence (>=)time, according toside. | 
| of_alist [Core_map_intf.Creators] | 
creates map from association list with unique keys
 | 
| of_alist [Core_hashtbl_intf.Creators] | |
| of_alist [Bounded_int_table.With_key] | |
| of_alist_exn [Core_map_intf.Creators] | 
creates map from association list with unique keys.
 | 
| of_alist_exn [Core_hashtbl_intf.Creators] | |
| of_alist_exn [Bounded_int_table.With_key] | |
| of_alist_fold [Core_map_intf.Creators] | 
combines an association list into a map, folding together bound values with common
      keys
 | 
| of_alist_multi [Core_map_intf.Creators] | 
creates map from association list with possibly repeated keys.
 | 
| of_alist_multi [Core_hashtbl_intf.Creators] | |
| of_alist_report_all_dups [Core_hashtbl_intf.Creators] | |
| of_array [Heap] | of_array ?min_size cmp ar | 
| of_array [Core_set_intf.Creators] | |
| of_array [Queue] | |
| of_bigstring [Substring_intf.S] | |
| of_bigstring [Make_substring.Base] | |
| of_bigstring [Make_substring.F] | |
| of_bigstring [Unix.IOVec] | of_bigstring ?pos ?len bstr | 
| of_bigstring [Binable0] | |
| of_bigstring [Binable] | |
| of_caml_int [Signal] | of_caml_intconstructs a Signal.t given an O'Caml internal signal number. | 
| of_char [String] | |
| of_char_list [String] | |
| of_code [Unix.Exit] | |
| of_date_ofday [Time] | |
| of_day [Span] | |
| of_exn [Or_error] | of_exn exnisError (Error.of_exn exn). | 
| of_exn [Info] | |
| of_exn_result [Or_error] | of_exn_result (Ok a) = Ok a,of_exn_result (Error exn) = of_exn exn | 
| of_filename_string [Time] | of_filename_string sconvertssthat has format YYYY-MM-DD_HH-MM-SS.mmm into
    time | 
| of_float [Floatable.S] | |
| of_float [Int64] | |
| of_hashtbl_keys [Hash_set_intf.Accessors] | |
| of_hr [Span] | |
| of_int [Weekday] | of_int ireturns i'th weekday ifiis in 0,1,...,6. | 
| of_int [Pid] | |
| of_int [Ordering] | of_int nis | 
| of_int [Month] | of_int ireturns i'th month ifiis in 1,2,...,12. | 
| of_int [Linux_ext.Priority] | |
| of_int [Float_intf.S] | |
| of_int [Unix.File_descr] | |
| of_int [Nativeint] | |
| of_int [Int64] | |
| of_int [Int63] | |
| of_int [Int32] | |
| of_int [Int] | |
| of_int [Char] | 
Return the character with the given ASCII code or  Noneis the argument is outside
    the range 0 to 255. | 
| of_int32 [Nativeint] | |
| of_int32 [Int64] | |
| of_int32 [Int32] | |
| of_int32 [Int] | |
| of_int32_exn [Int_intf.S] | |
| of_int64 [Float_intf.S] | |
| of_int64 [Nativeint] | |
| of_int64 [Int64] | |
| of_int64 [Int32] | |
| of_int64 [Int] | |
| of_int64_exn [Int_intf.S] | |
| of_int64_exn [Int] | |
| of_int_exn [Weekday] | of_int_exn ishould have i in 0,1,...,6 and returns the i'th weekday. | 
| of_int_exn [Month] | |
| of_int_exn [Intable.S] | |
| of_int_exn [Char] | 
Return the character with the given ASCII code.
 | 
| of_int_sec [Span] | |
| of_int_style [Sexp] | |
| of_key [Core_hashtbl_intf.Hashable] | |
| of_lazy [Info] | 
Be careful that the body of the lazy or thunk does not access mutable data, since it
    will only be called at an undetermined later point.
 | 
| of_list [Info] | |
| of_list [Hash_set_intf.Creators] | |
| of_list [Doubly_linked] | of_list lreturns a doubly-linked listtwith the same elements asland in the
    same order (i.e. | 
| of_list [Stack] | of_list lreturns a stack whose top is the first element ofland
 * bottom is the last element ofl. | 
| of_list [Core_set_intf.Creators] | |
| of_list [Queue] | of_list listreturns a queuetwith the elements oflistin the same
    order as the elements oflist(i.e. | 
| of_list [Array] | Array.of_list lreturns a fresh array containing the elements
   ofl. | 
| of_list [Bag] | |
| of_list_map [Array] | of_list_map l ~fis the same asof_list (List.map l ~f) | 
| of_list_rev [Array] | of_list_rev lconverts from list then reverses in place | 
| of_list_rev_map [Array] | of_list_rev_map l ~fis the same asrev_inplace (of_list_map l ~f) | 
| of_local_date_ofday [Time] | |
| of_localized_string [Time] | of_localized_string zone strread in the given string assuming that it represents
  a time in zone and return the appropriate Time.t | 
| of_map [Command.Spec.Arg_type] | |
| of_min [Span] | |
| of_ms [Span] | |
| of_nativeint [Nativeint] | |
| of_nativeint [Int64] | |
| of_nativeint [Int32] | |
| of_nativeint [Int] | |
| of_nativeint_exn [Int_intf.S] | |
| of_ns [Span] | |
| of_option [Result] | |
| of_sec [Span] | |
| of_sorted_array [Core_set_intf.Creators] | 
Create set from sorted array.
 | 
| of_sorted_array [Core_map_intf.Creators] | 
creates map from sorted array of key-data pairs.
 | 
| of_sorted_array_unchecked [Core_set_intf.Creators] | 
Similar to  of_sorted_ararywithout checking the input array. | 
| of_sorted_array_unchecked [Core_map_intf.Creators] | 
Like  of_sorted_arrayexcept behavior is undefined when anErrorwould have been
      returned. | 
| of_span_since_start_of_day [Ofday] | |
| of_string [Span] | |
| of_string [Sexpable.To_stringable] | |
| of_string [Substring_intf.S] | |
| of_string [Make_substring.Base] | |
| of_string [Make_substring.F] | |
| of_string [Stringable.S] | |
| of_string [Info] | |
| 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 [Binable] | |
| of_string [Bigstring] | of_string ?pos ?len str | 
| of_string_abs [Time] | |
| of_string_fix_proto [Time] | |
| of_string_iso8601_basic [Date] | |
| of_string_iso8601_extended [Ofday] | |
| of_string_or_getbyname [Unix.Inet_addr] | 
Call  of_stringand if that fails, useHost.getbyname. | 
| of_system_int [Signal] | of_system_intandto_system_intreturn 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_thunk [Only_in_test] | |
| of_thunk [Info] | |
| of_time [Time.Date] | |
| of_tm [Date] | |
| of_tree [Core_set_intf.Creators] | |
| of_tree [Core_map_intf.Creators] | |
| of_unix [Unix.Exit_or_signal_or_stop] | of_unixassumes that any signal numbers in the incoming value are O'Caml internal
      signal numbers. | 
| of_unix [Unix.Exit_or_signal] | of_unixassumes that any signal numbers in the incoming value are O'Caml internal
      signal numbers. | 
| of_us [Span] | |
| of_utc_offset [Zone] | of_utc_offset offsetreturns a timezone with a static UTC offset (given in
    hours). | 
| ok [Result] | |
| ok_exn [Result] | ok_exn treturnsxift = Ok x, and raisesexnift = Error exn | 
| ok_exn [Or_error] | ok_exn tthrows an exception iftis anError, and otherwise returns the
    contents of theOkconstructor. | 
| ok_fst [Result] | ok_fstis useful withList.partition_map. | 
| ok_if_true [Result] | |
| ok_or_failwith [Result] | |
| ok_unit [Result] | ok_unit = Ok (), used to avoid allocation as a performance hack | 
| one [Int_intf.S] | |
| oneshot [Linux_ext.Epoll.Flags] | |
| open_connection [Unix] | 
Connect to a server at the given address.
 | 
| open_flag_of_sexp [Unix] | |
| open_in_gen [Sys_open_patch] | 
Reimplementation of  Pervasives.open_in_gen | 
| open_out_gen [Sys_open_patch] | 
Reimplementation of  Pervasives.open_out_gen | 
| 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.
 | 
| option_of_sexp [Std_internal] | |
| optional [Command.Spec] | 
optional flags may be passed at most once
 | 
| optional_with_default [Command.Spec] | optional_with_defaultflags may be passed at most once, and
      default to a given value | 
| or_ [Blang] | |
| os_type [Sys] | 
Operating system currently executing the Caml program.
 | 
| oublock [Unix.Resource_usage.Fields] | |
| oublock [Unix.Resource_usage] | |
| ounit_tests [With_return] | |
| ounit_tests [Unique_id_intf] | |
| ounit_tests [Time_internal] | |
| ounit_tests [Time] | |
| ounit_tests [Sys_open_patch] | |
| ounit_tests [Std_internal] | |
| ounit_tests [Word_size] | |
| ounit_tests [Weekday] | |
| ounit_tests [Unpack_buffer] | |
| ounit_tests [Univ_map] | |
| ounit_tests [Univ] | |
| ounit_tests [Unit] | |
| ounit_tests [Unique_id] | |
| ounit_tests [Union_find] | |
| ounit_tests [Tuple] | |
| ounit_tests [Timer] | |
| ounit_tests [Thread_safe_queue] | |
| ounit_tests [Substring_intf] | |
| ounit_tests [Substring] | |
| ounit_tests [String_id] | |
| ounit_tests [Stringable] | |
| ounit_tests [Zone] | |
| ounit_tests [Std] | |
| ounit_tests [Staged] | |
| ounit_tests [Stable_unit_test_intf] | |
| ounit_tests [Stable_unit_test] | |
| ounit_tests [Stable_internal] | |
| ounit_tests [Stable_containers] | |
| ounit_tests [Stable.Unit_tests] | |
| ounit_tests [Stable_unit_test_intf.S] | |
| ounit_tests [Stable] | |
| ounit_tests [Squeue] | |
| ounit_tests [Span] | |
| ounit_tests [Space_safe_tuple] | |
| ounit_tests [Source_code_position0] | |
| ounit_tests [Source_code_position] | |
| ounit_tests [Signal] | |
| ounit_tests [Sexpable] | |
| ounit_tests [Set_once] | |
| ounit_tests [Robustly_comparable] | |
| ounit_tests [Result] | |
| ounit_tests [Ref] | |
| ounit_tests [Quickcheck] | |
| ounit_tests [Pretty_printer] | |
| ounit_tests [Polymorphic_compare_intf] | |
| ounit_tests [Polymorphic_compare] | |
| ounit_tests [Piecewise_linear] | |
| ounit_tests [Pid] | |
| ounit_tests [Out_channel] | |
| ounit_tests [Or_error] | |
| ounit_tests [Ordering] | |
| ounit_tests [Ordered_collection_common] | |
| ounit_tests [Option] | |
| ounit_tests [Only_in_test] | |
| ounit_tests [Ofday] | |
| ounit_tests [No_polymorphic_compare] | |
| ounit_tests [Never_returns] | |
| ounit_tests [Nano_mutex] | |
| ounit_tests [Mutex0] | |
| ounit_tests [Month] | |
| ounit_tests [Monad] | |
| ounit_tests [Memo] | |
| ounit_tests [Make_substring] | |
| ounit_tests [Lock_file] | |
| ounit_tests [Linux_ext] | |
| ounit_tests [Invariant] | |
| ounit_tests [Int_set] | |
| ounit_tests [Int_replace_polymorphic_compare] | |
| ounit_tests [Int_intf] | |
| ounit_tests [Interval_intf] | |
| ounit_tests [Interval] | |
| ounit_tests [Interfaces] | |
| ounit_tests [Int_conversions] | |
| ounit_tests [Intable] | |
| ounit_tests [Inline_tests] | |
| ounit_tests [Info] | |
| ounit_tests [In_channel] | |
| ounit_tests [Identifiable] | |
| ounit_tests [Host_and_port] | |
| ounit_tests [Heap_block] | |
| ounit_tests [Heap] | |
| ounit_tests [Hash_set_intf] | |
| ounit_tests [Hash_set] | |
| ounit_tests [Hash_queue] | |
| ounit_tests [Hash_heap] | |
| ounit_tests [T] | |
| ounit_tests [Hashable] | |
| ounit_tests [Fqueue] | |
| ounit_tests [Force_once] | |
| ounit_tests [Fn] | |
| ounit_tests [Float_robust_compare] | |
| ounit_tests [Float_intf] | |
| ounit_tests [Floatable] | |
| ounit_tests [Float] | |
| ounit_tests [Exn] | |
| ounit_tests [Error] | |
| ounit_tests [Equal] | |
| ounit_tests [Doubly_linked] | |
| ounit_tests [Dequeue] | |
| ounit_tests [Date] | |
| ounit_tests [Daemon] | |
| ounit_tests [Crc] | |
| ounit_tests [Weak] | |
| ounit_tests [Unix] | |
| ounit_tests [Thread] | |
| ounit_tests [Sys] | |
| ounit_tests [String] | |
| ounit_tests [Stack] | |
| ounit_tests [Sexp] | |
| ounit_tests [Core_set_unit_tests] | |
| ounit_tests [Core_set_intf] | |
| ounit_tests [Set] | |
| ounit_tests [Queue] | |
| ounit_tests [Printf] | |
| ounit_tests [Printexc] | |
| ounit_tests [Nativeint] | |
| ounit_tests [Mutex] | |
| ounit_tests [Core_map_unit_tests] | |
| ounit_tests [Core_map_intf] | |
| ounit_tests [Map] | |
| ounit_tests [List] | |
| ounit_tests [Lazy] | |
| ounit_tests [Int64] | |
| ounit_tests [Int63] | |
| ounit_tests [Int32] | |
| ounit_tests [Int] | |
| ounit_tests [Core_hashtbl_intf] | |
| ounit_tests [Hashtbl] | |
| ounit_tests [Gc] | |
| ounit_tests [Filename] | |
| ounit_tests [Field] | |
| ounit_tests [Condition] | |
| ounit_tests [Char] | |
| ounit_tests [Bin_prot] | |
| ounit_tests [Array] | |
| ounit_tests [Arg] | 
Stop interpreting keywords and call the
                                   function with each remaining argument
 | 
| ounit_tests [Container] | |
| ounit_tests [Constrained_float] | |
| ounit_tests [Comparator] | |
| ounit_tests [Comparable] | |
| ounit_tests [Commutative_group] | |
| ounit_tests [Common0] | |
| ounit_tests [Common] | |
| ounit_tests [Command] | |
| ounit_tests [Caml] | |
| ounit_tests [Byte_units] | |
| ounit_tests [Bucket] | |
| ounit_tests [Bounded_int_table] | |
| ounit_tests [Bool] | |
| ounit_tests [Blang] | |
| ounit_tests [Binary_packing] | |
| ounit_tests [Binable0] | |
| ounit_tests [Binable] | |
| ounit_tests [Bigsubstring] | |
| ounit_tests [Bigstring_marshal] | |
| ounit_tests [Bigstring] | |
| ounit_tests [Bigbuffer] | 
The abstract type of buffers.
 | 
| ounit_tests [Bag] | |
| ounit_tests [Backtrace] | |
| ounit_tests [Avltree] | |
| ounit_tests [Random] | |
| ounit_tests [Array_permute] | |
| out [Linux_ext.Epoll.Flags] | |
| out_channel_length [Common] | |
| out_channel_of_descr [Unix] | 
Create an output channel writing on the given descriptor.
 | 
| out_channel_realpath [Linux_ext] | out_channel_realpath oc | 
| outer_of_sexp [Float_intf.S] | |
| output [Out_channel] | |
| output [Bigstring] | output ?min_len oc ?pos ?len bstrtries to outputlenbytes (guarantees to write at leastmin_lenbytes (must be
    equal to or greater than zero), if possible, before returning) from
    bigstringbstrstarting at positionposto output channeloc. | 
| output_binary_int [Out_channel] | |
| output_buffer [Bigbuffer] | output_buffer oc bwrites the current contents of bufferbon the output channeloc. | 
| output_byte [Out_channel] | |
| output_char [Out_channel] | |
| output_lines [Out_channel] | 
Outputs a list of lines, each terminated by a newline character
 | 
| output_string [Out_channel] | |
| output_value [Out_channel] | |
| P | |
| pack_float [Binary_packing] | |
| pack_padded_fixed_string [Binary_packing] | 
Encode and pack the given string as a padded fixed length string having length  len. | 
| pack_signed_16 [Binary_packing] | |
| pack_signed_16_big_endian [Binary_packing] | |
| pack_signed_16_little_endian [Binary_packing] | |
| pack_signed_32 [Binary_packing] | |
| pack_signed_32_int [Binary_packing] | |
| pack_signed_32_int_big_endian [Binary_packing] | |
| pack_signed_32_int_little_endian [Binary_packing] | |
| pack_signed_64 [Binary_packing] | |
| pack_signed_64_big_endian [Binary_packing] | |
| pack_signed_64_int [Binary_packing] | |
| pack_signed_64_little_endian [Binary_packing] | |
| pack_signed_8 [Binary_packing] | |
| pack_unsigned_16 [Binary_packing] | |
| pack_unsigned_16_big_endian [Binary_packing] | |
| pack_unsigned_16_little_endian [Binary_packing] | |
| pack_unsigned_32_int [Binary_packing] | |
| pack_unsigned_32_int_big_endian [Binary_packing] | |
| pack_unsigned_32_int_little_endian [Binary_packing] | |
| pack_unsigned_8 [Binary_packing] | |
| parent_dir_name [Filename] | 
The conventional name for the parent of the current directory
   (e.g.
 | 
| parse [Arg] | Arg.parse speclist anon_fun usage_msgparses the command line. | 
| parse_argv [Arg] | Arg.parse_argv ~current args speclist anon_fun usage_msgparses
  the arrayargsas if it were the command line. | 
| parse_four_digits [Time_internal.Helpers] | |
| parse_two_digits [Time_internal.Helpers] | |
| partial_iter [Queue] | partial_iter t ~fiterates through t until f returns `Stop | 
| partition_map [List] | partition_map t ~fpartitionstaccording tof. | 
| partition_map [Core_hashtbl_intf.Accessors] | 
returns new maps with bound values partitioned by f applied to the bound values
 | 
| partition_mapi [Core_hashtbl_intf.Accessors] | 
like  partition_map, but function takes both key and data as arguments | 
| partition_tf [Core_set_intf.Accessors] | |
| partition_tf [List] | partition_tf p lreturns a pair of lists(l1, l2), wherel1is the list of all the
    elements oflthat satisfy the predicatep, andl2is the list of all the
    elements oflthat do not satisfyp. | 
| partition_tf [Core_hashtbl_intf.Accessors] | |
| partition_tf [Array] | |
| partitioni_tf [Core_hashtbl_intf.Accessors] | |
| partitioni_tf [Array] | |
| parts [Filename] | parts filenamereturns a list of path components in order. | 
| path [Command.Spec] | 
the subcommand path of the command
 | 
| pause [Time] | pause spansleeps for span time. | 
| pause [Unix] | 
Wait until a non-ignored, non-blocked signal is delivered.
 | 
| pause_forever [Time] | pause_foreversleeps indefinitely. | 
| peek [Queue] | peek treturnsNoneiftis empty, otherwise it returnsSome xwherexis the front oft. | 
| peek_exn [Queue] | |
| permute [List] | permute ?random_state treturns a permutation oft. | 
| permute [Array] | permute ?random_state trandomly permutestin place. | 
| permute [Array_permute] | 
randomly permute an array.
 | 
| pg [Quickcheck] | 
pair generator
 | 
| phys_equal [Mutex0] | |
| phys_equal [Common] | |
| pipe [Signal] | 
| Terminate | Broken pipe                                   |
 | 
| pipe [Unix] | 
Create a pipe.
 | 
| poly [Core_hashtbl_intf.Hashable] | |
| pop [Squeue] | 
pops an element off the queue, blocking until something is
 * available
 | 
| pop [Heap] | pop heap | 
| pop [Hash_heap.S] | |
| pop [Hash_heap.Make] | |
| pop [Stack] | pop treturnsNoneiftis empty, otherwise it returnsSome xwherexis the top oftand removesxfrom the top oft. | 
| pop_exn [Heap] | pop_exn heap | 
| pop_exn [Hash_heap.S] | |
| pop_exn [Hash_heap.Make] | |
| pop_exn [Stack] | pop_exn tremoves and returns the top element oft, raisingEmptyiftis empty. | 
| pop_heap_el [Heap] | pop_heap_el heap | 
| pop_heap_el_exn [Heap] | pop_heap_el_exn heap | 
| pop_with_key [Hash_heap.S] | |
| pop_with_key [Hash_heap.Make] | |
| pop_with_key_exn [Hash_heap.S] | |
| pop_with_key_exn [Hash_heap.Make] | |
| port [Host_and_port] | |
| pos [Out_channel] | |
| pos [Substring_intf.S] | |
| pos [Make_substring.F] | |
| pos [In_channel] | |
| pos_in [Common] | |
| pos_out [Common] | |
| pp [Time] | |
| pp [Zone] | |
| pp [Span] | |
| pp [Ofday] | |
| pp [Identifiable.S] | |
| pp [Exn] | |
| pp [Date] | |
| pp [String] | 
This has to be public for interactive top-levels.
 | 
| 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 namesets the name of the executing thread toname. | 
| pr_set_pdeathsig [Linux_ext] | pr_set_pdeathsig ssets the signalsto be sent to the executing
    process when its parent dies. | 
| pred [Int_intf.S] | |
| prefix [Substring_intf.S] | |
| prefix [Make_substring.F] | |
| prefix [String] | prefix s nreturns the longest prefix ofsof length less than or equal ton | 
| prev [Doubly_linked] | |
| prev_key [Core_map_intf.Accessors] | prev_key t kreturns the largest (key, value) pair in t with key less than k | 
| previous_weekday [Date] | |
| pri [Linux_ext.Epoll.Flags] | |
| print [Printexc] | |
| print_backtrace [Printexc] | |
| print_stat [Gc] | 
Print the current values of the memory management counters (in
   human-readable form) into the channel argument.
 | 
| printf [Printf] | |
| process_times_of_sexp [Unix] | 
The execution times (CPU times) of a process.
 | 
| prof [Signal] | 
| Terminate | Profiling interrupt                           |
 | 
| promoted_words [Gc.Stat.Fields] | |
| promoted_words [Gc.Stat] | |
| protect [Exn] | |
| protect [Common] | 
See exn.mli
 | 
| protectx [Exn] | 
Executes  fand afterwards executesfinally, whetherfthrows an exception or
    not. | 
| protectx [Common] | |
| pselect [Unix] | pselect rfds wfds efds timeout sigmasklikeUnix.selectbut
    also allows one to wait for the arrival of signals. | 
| push [Squeue] | 
Blocks until there's room on the queue, then pushes.
 | 
| push [Heap] | push heap elpushes elementelonheap. | 
| push [Hash_heap.S] | |
| push [Hash_heap.Make] | |
| push [Stack] | push t xaddsxto the top of stackt. | 
| push_back [Dequeue] | |
| push_exn [Hash_heap.S] | |
| push_exn [Hash_heap.Make] | |
| push_front [Dequeue] | |
| push_heap_el [Heap] | push_heap_el heap heap_elpushesheap_elonheap. | 
| 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 ~datasets the value associated to a
   variable in the process environment. | 
| Q | |
| quick_stat [Gc] | 
Same as  statexcept thatlive_words,live_blocks,free_words,free_blocks,largest_free, andfragmentsare set to 0. | 
| 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 | |
| raise [Error] | |
| randomize [Span] | randomize t ~percentreturns a span +/- percent * original span. | 
| range [List] | range ?stride ?start ?stop start_i stop_iis the list of integers fromstart_itostop_i, stepping bystride. | 
| range_to_alist [Core_map_intf.Accessors] | range_to_alist t ~min ~maxreturns an associative list of the elements whose
      keys lie inmin, max(inclusive), with the smallest key being at the head of the
      list. | 
| ranges [Int_set] | ranges treturn a list of all ranges that make up the set | 
| rank [Core_map_intf.Accessors] | |
| read [Unix] | read fd buff ofs lenreadslencharacters from descriptorfd, storing them in stringbuff, starting at positionofsin stringbuff. | 
| read [Bigstring] | read ?min_len fd ?pos ?len bstrreads at leastmin_len(must be
    greater than or equal zero) and at mostlen(must be greater than
    or equal tomin_len) bytes from file descriptorfd, and writes
    them to bigstringbstrstarting at positionpos. | 
| read_all [In_channel] | read_all filenameOpens filename, reads all input, and closes the file. | 
| read_assume_fd_is_nonblocking [Unix] | read_assume_fd_is_nonblocking fd ?pos ?len bufcalls the system callreadASSUMING THAT IT IS NOT GOING TO BLOCK. | 
| read_assume_fd_is_nonblocking [Bigstring] | read_assume_fd_is_nonblocking fd ?pos ?len bstrreads up tolenbytes into bigstringbstrstarting at positionposfrom
    file descriptorfdwithout yielding to other OCaml-threads. | 
| read_lines [In_channel] | read_lines filenameOpens filename, reads all lines, and closes the file. | 
| read_only_of_sexp [Common] | |
| read_write_of_sexp [Common] | |
| 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 dhreturn the next entry in a directory (((filename,
    inode)). | 
| readlink [Unix] | 
Read the contents of a link.
 | 
| really_input [In_channel] | |
| really_input [Bigstring] | really_input ic ?pos ?len bstrreads exactlylenbytes from
    input channelic, and writes them to bigstringbstrstarting at
    positionpos. | 
| really_output [Bigstring] | really_output oc ?pos ?len bstroutputs exactlylenbytes from bigstringbstrstarting at positionposto output
    channeloc. | 
| really_read [Bigstring] | really_read fd ?pos ?len bstrreadslenbytes from file descriptorfd, and writes them to bigstringbstrstarting at positionpos. | 
| really_recv [Bigstring] | really_recv sock ?pos ?len bstrreceiveslenbytes from socketsock, and writes them to bigstringbstrstarting at positionpos. | 
| really_send_no_sigpipe [Bigstring] | really_send_no_sigpipe sock ?pos ?len bstrsendslenbytes in
    bigstringbstrstarting at positionposto socketsockwithout
    blocking and ignoringSIGPIPE. | 
| really_write [Bigstring] | really_write fd ?pos ?len bstrwriteslenbytes in bigstringbstrstarting at positionposto file descriptorfd. | 
| realpath [Filename] | realpath path | 
| record_backtrace [Printexc] | |
| recv [Unix] | 
Receive data from an unconnected socket.
 | 
| recvfrom [Unix] | 
Receive data from an unconnected socket.
 | 
| recvfrom_assume_fd_is_nonblocking [Bigstring] | recvfrom_assume_fd_is_nonblocking sock ?pos ?len bstrreads up tolenbytes into bigstringbstrstarting at positionposfrom
    socketsockwithout yielding to other OCaml-threads. | 
| reduce [List] | |
| reduce [Array] | reduce f [a1; ...; an]isSome (f (... (f (f a1 a2) a3) ...) an). | 
| reduce_exn [List] | reduce f [a1; ...; an]isf (... (f (f a1 a2) a3) ...) an. | 
| reduce_exn [Array] | |
| register [Pretty_printer] | |
| release [Unix.Utsname] | |
| rem [Int_intf.S] | |
| remove [Timer] | remove eventremoveseventfrom its associated timer. | 
| remove [Linux_ext.Epoll] | |
| remove [Heap] | remove heap_elremovesheap_elfrom its associated heap. | 
| remove [Hash_set_intf.Accessors] | |
| remove [Hash_heap.S] | |
| remove [Hash_queue.S] | |
| remove [Hash_heap.Make] | |
| remove [Hash_queue.Make] | |
| remove [Doubly_linked] | 
constant-time removal of an element.
 | 
| remove [Sys] | 
Remove the given file name from the file system.
 | 
| remove [Core_set_intf.Accessors] | |
| remove [Core_map_intf.Accessors] | 
returns a new map with any binding for the key in question removed
 | 
| remove [List.Assoc] | |
| remove [Core_hashtbl_intf.Accessors] | |
| remove [Bounded_int_table] | |
| remove [Bag] | remove t eltremoveseltfrom the bagt, raising an exception ifeltis not in the bag. | 
| remove [Avltree] | 
remove key destructively from the tree if it exists, return the new root node.
 | 
| remove_exn [Hash_queue.S] | |
| remove_exn [Hash_queue.Make] | |
| remove_first [Doubly_linked] | |
| remove_index [Core_set_intf.Accessors] | |
| remove_last [Doubly_linked] | |
| remove_multi [Core_hashtbl_intf.Accessors] | remove_multi t keyupdates the table, removing the head of the list bound tokey. | 
| remove_one [Core_hashtbl_intf.Accessors] | |
| remove_one [Bag] | remove_one tremoves some element from the bag, and returns its value. | 
| rename [Unix] | rename old newchanges the name of a file fromoldtonew. | 
| rename [Sys] | 
Rename a file.
 | 
| repeat [Quickcheck] | |
| replace [Ref] | replace t fist := f !t | 
| replace [Hash_heap.S] | |
| replace [Hash_queue.S] | replace q k vchanges the value of key k in the queue to v. | 
| replace [Hash_heap.Make] | |
| replace [Hash_queue.Make] | |
| replace [Core_hashtbl_intf.Accessors] | |
| replace [Array] | replace t i ~f=t.(i) <- f (t.(i)). | 
| replace_all [Array] | 
modifies an array in place --  ar.(i)will be set tof(ar.(i)) | 
| replace_exn [Hash_queue.S] | |
| replace_exn [Hash_queue.Make] | |
| required [Command.Spec] | 
required flags must be passed exactly once
 | 
| reraise [Exn] | |
| reraise_uncaught [Exn] | |
| reraisef [Exn] | |
| reschedule [Timer] | reschedule event ?randomize ?interval spanrescheduleseventto start by time spanspanlater than originally scheduled, and
    change its interval behaviour as described forTimer.add. | 
| reset [Bigbuffer] | 
Empty the buffer and deallocate the internal string holding the
   buffer contents, replacing it with the initial internal string
   of length  nthat was allocated byBigbuffer.createn. | 
| resource_of_sexp [Unix.RLimit] | |
| retry_until_no_eintr [Unix] | retry_until_no_eintr freturnsf ()unlessf ()fails withEINTR; in which
    casef ()is run again until it raises a different error or returns a value. | 
| return [Monad.S2] | |
| return [Monad.Basic2] | |
| return [Monad.Basic] | |
| return [Monad.Make2] | |
| return [Monad.Make] | |
| return [Monad.S] | return vreturns the (trivial) computation that returns v. | 
| rev [List] | 
List reversal.
 | 
| rev_append [List] | List.rev_append l1 l2reversesl1and concatenates it tol2. | 
| rev_filter [List] | 
Like  filter, but reverses the order of the input list | 
| rev_filter_map [List] | rev_filter_map f lis the reversed sublist oflcontaining
    only elements for whichfreturnsSome e. | 
| rev_filter_mapi [List] | 
rev_filter_mapi is just like rev_filter_map, but it also passes in the index of each
    element as the first argument to the mapped function.
 | 
| rev_inplace [Array] | rev_inplace treversestin place | 
| rev_map [List] | List.rev_map f lgives the same result asList.rev (ListLabels.map f l), but is more efficient. | 
| rev_map2_exn [List] | List.rev_map2_exn f l1 l2gives the same result asList.rev (List.map2_exn f l1 l2), but is more efficient. | 
| rev_map3_exn [List] | |
| rev_map_append [List] | rev_map_append ~f l1 l2reversesl1mappingfover each
    element, and appends the result to the front ofl2. | 
| rev_mapi [List] | |
| rewinddir [Unix] | 
Reposition the descriptor to the beginning of the directory
 | 
| rfindi [String] | rfindi ?pos t ~freturns the largesti <= possuch thatf i t.[i], if there is
    such ani. | 
| rindex [String.Escaping] | rindex s ~escape_char charfind the first literal (not escaped) instance of
      char in s starting from the end of s and proceeding towards 0. | 
| rindex [String] | |
| rindex_exn [String.Escaping] | |
| rindex_exn [String] | |
| rindex_from [String.Escaping] | rindex_from s ~escape_char pos charfind the first literal (not escaped)
      instance of char in s starting from pos and towards 0. | 
| rindex_from [String] | |
| rindex_from_exn [String.Escaping] | |
| rindex_from_exn [String] | |
| rmdir [Unix] | 
Remove an empty directory.
 | 
| robustly_compare [Robustly_comparable.S] | |
| root [Filename] | 
The path of the root.
 | 
| round [Std_internal] | |
| round [Float_intf.S] | |
| rsplit2 [String.Escaping] | |
| rsplit2 [String] | rsplit2 line ~onoptionally returnslinesplit into two strings around the
  * first appearance ofonfrom the right | 
| rsplit2_exn [String.Escaping] | |
| rsplit2_exn [String] | 
If the string  scontains the characteron, thenrsplit2_exn
    s ~onreturns a pair containingssplit around the first
    appearance ofon(from the right). | 
| rstrip [String] | rstrip ?drop sreturns a string with consecutive chars satisfyingdrop(by default
    white space, e.g. | 
| run [Inline_tests] | |
| run [Command.Deprecated] | |
| run [Command] | 
run a command against  Sys.argv | 
| S | |
| same_class [Union_find] | same_class t1 t2returns true ifft1andt2are in the same equivalence class. | 
| sat [Weekday] | |
| scale [Span] | |
| scale [Float_intf.S] | |
| sched_setaffinity [Linux_ext] | |
| sched_setaffinity_this_thread [Linux_ext] | |
| sec [Std] | |
| second [Span] | |
| seek [Out_channel] | |
| seek [In_channel] | |
| seek_command_of_sexp [Unix] | 
POSITIONING modes for  UnixLabels.lseek. | 
| seek_in [Common] | |
| seek_out [Common] | |
| 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.
 | 
| self_init [Random] | 
Initialize the generator with a more-or-less random seed chosen in a system-dependent
    way.
 | 
| send [Signal] | send signal pidsendssignalto the process whose process id ispid. | 
| send [Unix] | 
Send data over an unconnected socket.
 | 
| send_exn [Signal] | send_exn signal ~pidsendssignalto the process whose process id is
 *pid. | 
| send_i [Signal] | send_i signal ~pidsendssignalto the process whose process id ispid. | 
| send_no_sigpipe [Linux_ext] | send_no_sigpipe sock ?pos ?len buftries to do a
    blocking send on socketsockgiven bufferbuf, offsetposand lengthlen. | 
| send_nonblocking_no_sigpipe [Linux_ext] | send_nonblocking_no_sigpipe sock ?pos ?len buftries to do a
    nonblocking send on socketsockgiven bufferbuf, offsetposand lengthlen. | 
| send_nonblocking_no_sigpipe [Bigstring] | send_nonblocking_no_sigpipe sock ?pos ?len bstrtries to sendlenbytes in bigstringbstrstarting at positionposto socketsock. | 
| sendfile [Linux_ext] | sendfile ?pos ?len ~fd socksends mmap-able data from file
    descriptorfdto socketsockusing offsetposand lengthlen. | 
| sendmsg_nonblocking_no_sigpipe [Linux_ext] | sendmsg_nonblocking_no_sigpipe sock ?count iovecstries to do
    a nonblocking send on socketsockusingcountI/O-vectorsiovecs. | 
| sendmsg_nonblocking_no_sigpipe [Bigstring] | sendmsg_nonblocking_no_sigpipe sock ?count iovecssendscountiovecsof bigstrings to socketsock. | 
| sendto [Unix] | 
Send data over an unconnected socket.
 | 
| sendto_nonblocking_no_sigpipe [Bigstring] | sendto_nonblocking_no_sigpipe sock ?pos ?len bstr sockaddrtries
    to sendlenbytes in bigstringbstrstarting at positionposto socketsockusing addressaddr. | 
| sequence [Command.Spec] | sequence anonsspecifies a sequence of anonymous arguments. | 
| set [Univ_map.Multi] | |
| set [Univ_map.With_fold] | |
| set [Univ_map.With_default] | |
| set [Univ_map] | |
| set [Union_find] | set t vsets the value of the class ofttov. | 
| set [Signal] | set t bisignore (signal t b) | 
| set [Set_once] | |
| set [Linux_ext.Epoll] | |
| set [Weak] | |
| set [Unix.Scheduler] | |
| set [Unix.RLimit] | |
| set [String] | |
| set [Core_hashtbl_intf.Accessors] | |
| set [Gc] | set rchanges the GC parameters according to thecontrolrecordr. | 
| set [Array] | Array.set a n xmodifies arrayain place, replacing
   element numbernwithx. | 
| set [Bounded_int_table] | |
| set [Bigstring] | set t possets the character atpos | 
| set_allocation_policy [Gc.Control] | |
| set_binary_mode [Out_channel] | |
| set_binary_mode [In_channel] | |
| set_close_on_exec [Unix] | 
Set the ``close-on-exec'' flag on the given descriptor.
 | 
| set_exn [Set_once] | |
| set_exn [Dequeue] | |
| set_in_channel_timeout [Unix] | 
Set a timeout for a socket associated with an  in_channel | 
| set_major_heap_increment [Gc.Control] | |
| set_max_overhead [Gc.Control] | |
| set_minor_heap_size [Gc.Control] | |
| 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_space_overhead [Gc.Control] | |
| set_stack_limit [Gc.Control] | |
| set_state [Random] | 
Set the state of the generator used by the basic functions.
 | 
| set_time [Linux_ext.Clock] | |
| set_verbose [Gc.Control] | |
| setgid [Unix] | 
Set the real group id and effective group id for the process.
 | 
| setitimer [Unix] | setitimer t ssets the interval timertand 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.setsockoptfor a socket option whose value is a floating-point
    number. | 
| setsockopt_int [Unix] | 
Same as  UnixLabels.setsockoptfor an integer-valued socket option. | 
| setsockopt_optint [Unix] | 
Same as  UnixLabels.setsockoptfor a socket option whose value is anint option. | 
| settcpopt_bool [Linux_ext] | settcpopt_bool sock opt vsets the current value of the boolean
    TCP socket optionoptfor socketsockto valuev. | 
| setuid [Unix] | 
Sets the real user id and effective user id for the process.
 | 
| sexp_of___ [Common] | |
| sexp_of_addr_info [Unix] | |
| sexp_of_array [Std_internal] | |
| sexp_of_bool [Std_internal] | |
| sexp_of_char [Std_internal] | |
| sexp_of_decimal [Common] | |
| 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_exn [Std_internal] | |
| sexp_of_file_kind [Unix] | 
Socket
 | 
| sexp_of_file_perm [Unix] | |
| sexp_of_float [Std_internal] | |
| 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_heap_el [Heap] | 
Type of heap elements (they can be efficiently removed)
 | 
| sexp_of_immutable [Common] | |
| sexp_of_int [Std_internal] | |
| sexp_of_int32 [Std_internal] | |
| sexp_of_int64 [Std_internal] | |
| sexp_of_int_style [Int_conversions] | |
| 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  SIGPROFwhen expired. | 
| sexp_of_interval_timer_status [Unix] | |
| sexp_of_key [Core_hashtbl_intf.Accessors] | |
| sexp_of_lazy_t [Std_internal] | |
| sexp_of_limit [Unix.RLimit] | |
| sexp_of_list [Std_internal] | |
| 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_nativeint [Std_internal] | |
| sexp_of_no_raise [Sexp] | |
| sexp_of_open_flag [Unix] | 
Windows only: allow the file to be deleted while still open
 | 
| sexp_of_option [Std_internal] | |
| sexp_of_outer [Float_intf.S] | |
| sexp_of_process_times [Unix] | |
| sexp_of_read_only [Common] | |
| sexp_of_read_write [Common] | |
| sexp_of_resource [Unix.RLimit] | |
| 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_string [Std_internal] | |
| sexp_of_sys_behavior [Signal] | |
| sexp_of_sysconf [Unix] | |
| sexp_of_t [Time] | |
| sexp_of_t [Weekday] | |
| sexp_of_t [Unpack_buffer] | |
| sexp_of_t [Univ_map.Key] | create name to_sexpgenerates a fresh key. | 
| sexp_of_t [Univ_map] | |
| sexp_of_t [Univ.Constr] | |
| sexp_of_t [Univ] | |
| sexp_of_t [Unique_id_intf.Id] | |
| sexp_of_t [Tuple.Hashable_sexpable] | |
| sexp_of_t [Tuple.Comparable_sexpable] | |
| sexp_of_t [Tuple.T3] | |
| sexp_of_t [Tuple.T2] | |
| sexp_of_t [Thread_safe_queue] | |
| sexp_of_t [Zone] | |
| sexp_of_t [Stable_containers.Map.V1] | |
| sexp_of_t [Stable_containers.Hash_set.V1] | |
| sexp_of_t [Stable_containers.Hashtbl.V1] | |
| sexp_of_t [Stable_containers.Set.V1] | |
| sexp_of_t [Zone.Stable.V1] | |
| sexp_of_t [Weekday.Stable.V1] | |
| sexp_of_t [Time.Stable.V1] | |
| sexp_of_t [String_id.Stable.V1] | |
| sexp_of_t [Squeue] | |
| sexp_of_t [Span.Stable.V1] | |
| sexp_of_t [Span.Parts] | |
| sexp_of_t [Span] | |
| sexp_of_t [Source_code_position0] | |
| sexp_of_t [Source_code_position] | |
| sexp_of_t [Signal] | |
| sexp_of_t [Sexpable.S3] | |
| sexp_of_t [Sexpable.S2] | |
| sexp_of_t [Sexpable.S1] | |
| sexp_of_t [Sexpable.Of_stringable] | |
| sexp_of_t [Set_once] | |
| sexp_of_t [Stable_unit_test_intf.Arg] | |
| sexp_of_t [Result.Stable.V1] | |
| sexp_of_t [Result] | |
| sexp_of_t [Ref] | |
| sexp_of_t [Piecewise_linear.Key] | |
| sexp_of_t [Piecewise_linear.S] | |
| sexp_of_t [Pid] | |
| sexp_of_t [Or_error] | |
| sexp_of_t [Ordering] | |
| sexp_of_t [Option] | |
| sexp_of_t [Ofday.Stable.V1] | |
| sexp_of_t [Ofday] | |
| sexp_of_t [Nano_mutex] | |
| sexp_of_t [Month.Stable.V1] | |
| sexp_of_t [Month] | |
| sexp_of_t [Linux_ext.Epoll.Flags] | |
| sexp_of_t [Linux_ext.Epoll] | |
| sexp_of_t [Linux_ext.Priority] | |
| sexp_of_t [Linux_ext.Sysinfo] | |
| sexp_of_t [Int_intf.S] | |
| 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 [Sexpable.S] | |
| sexp_of_t [Int_conversions.Make] | |
| sexp_of_t [Info] | |
| sexp_of_t [Identifiable.S] | |
| sexp_of_t [Heap_block] | |
| sexp_of_t [Heap] | |
| sexp_of_t [Hash_set_intf.S] | |
| sexp_of_t [Hash_set.Poly] | |
| sexp_of_t [Hash_set] | |
| sexp_of_t [Fqueue] | |
| sexp_of_t [Force_once] | |
| sexp_of_t [Float_intf.S.Terse] | |
| sexp_of_t [Float_intf.S.Sign] | |
| sexp_of_t [Float_intf.S.Class] | |
| sexp_of_t [Exn] | |
| sexp_of_t [Doubly_linked.Elt] | |
| sexp_of_t [Doubly_linked] | |
| sexp_of_t [Dequeue] | |
| sexp_of_t [Date.Stable.V1] | |
| sexp_of_t [Date] | |
| sexp_of_t [Weak] | |
| 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.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.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 [String] | |
| sexp_of_t [Stack] | |
| sexp_of_t [Sexp.Sexp_maybe] | |
| sexp_of_t [Sexp] | |
| sexp_of_t [Core_set_intf.S.Tree] | |
| sexp_of_t [Core_set_intf.S] | |
| sexp_of_t [Set.Tree] | |
| sexp_of_t [Set.Poly.Tree] | |
| sexp_of_t [Set.Poly] | |
| sexp_of_t [Queue] | |
| sexp_of_t [Core_map_intf.S.Tree] | |
| sexp_of_t [Core_map_intf.S] | |
| sexp_of_t [Map.Tree] | |
| sexp_of_t [Map.Poly.Tree] | |
| sexp_of_t [Map.Poly] | |
| sexp_of_t [List.Assoc] | |
| sexp_of_t [List] | |
| sexp_of_t [Lazy] | |
| sexp_of_t [Core_hashtbl_intf.S] | |
| sexp_of_t [Core_hashtbl_intf.Key] | |
| sexp_of_t [Hashtbl.Poly] | |
| sexp_of_t [Hashtbl] | |
| sexp_of_t [Gc.Control] | |
| sexp_of_t [Gc.Stat] | |
| sexp_of_t [Char] | |
| sexp_of_t [Array] | |
| sexp_of_t [Constrained_float.S] | |
| sexp_of_t [Comparator.Pre_binable] | |
| sexp_of_t [Comparator.Pre] | |
| sexp_of_t [Commutative_group.S] | |
| sexp_of_t [Byte_units.Measure] | |
| sexp_of_t [Byte_units] | |
| sexp_of_t [Bucket.S] | |
| sexp_of_t [Bucket.Contents] | |
| sexp_of_t [Bucket.Make] | |
| sexp_of_t [Bounded_int_table.With_key] | |
| sexp_of_t [Bounded_int_table] | |
| sexp_of_t [Bool] | |
| sexp_of_t [Blang.Stable.V1] | |
| sexp_of_t [Blang] | |
| sexp_of_t [Bigstring] | |
| sexp_of_t [Bag.Elt] | |
| sexp_of_t [Bag] | |
| sexp_of_t [Backtrace] | |
| sexp_of_tcp_bool_option [Linux_ext] | |
| sexp_of_tm [Unix] | |
| sexp_of_wait_on [Unix] | |
| sg [Quickcheck] | 
string generator
 | 
| shift [Weekday] | shift t igoes forward (or backward) the specified number of weekdays | 
| shift [Month] | shift t igoes forward (or backward) the specified number of months | 
| shift_epoch_time [Zone] | |
| shift_left [Int_intf.S] | |
| shift_right [Int_intf.S] | |
| shift_right_logical [Int_intf.S] | |
| 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 sigschanges the set of blocked signals for the
   calling thread. | 
| sign [Float_intf.S] | |
| signal [Signal] | signal tSet the behavior of the system on receipt of a given signal. | 
| signal [Condition] | |
| sigpending [Signal] | sigpending ()returns the set of blocked signals that are currently
 * pending. | 
| sigprocmask [Signal] | sigprocmask cmd sigschanges the set of blocked signals. | 
| sigsuspend [Signal] | sigsuspend sigsatomically sets the blocked signals tosigsand waits for
 * a non-ignored, non-blocked signal to be delivered. | 
| single_write [Unix] | 
Same as  writebut ensures that all errors are reported and
   that no character has ever been written when an error is reported. | 
| singleton [Core_set_intf.Creators] | |
| singleton [Queue] | |
| singleton [Core_map_intf.Creators] | 
map with one key, data pair
 | 
| size [Timer] | size timerreturns the number of events in a timer's heap. | 
| skip [Bigstring_marshal] | skip ?pos bufskips the marshalled data starting at positionpos. | 
| sleep [Unix] | 
Stop execution for the given number of seconds.
 | 
| slice [Ordered_collection_common] | |
| slice [String] | slice s start stopgets a slice ofsbetweenstartandstop. | 
| slice [List] | slice l start stopreturns a new list including elementsl.(start)throughl.(stop-1), normalized python-style. | 
| slice [Array] | slice array start stopreturns a fresh array including elementsarray.(start)througharray.(stop-1)with the small tweak that the start and stop positions are
    normalized and a stop index of 0 means the same thing a stop index ofArray.length
    array. | 
| small_diff [Ofday] | |
| snd3 [Common] | |
| 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.getsockoptand modified withUnixLabels.setsockopt. | 
| socket_domain_of_sexp [Unix] | |
| socket_float_option_of_sexp [Unix] | 
The socket options that can be consulted with  UnixLabels.getsockopt_floatand modified withUnixLabels.setsockopt_float. | 
| socket_int_option_of_sexp [Unix] | 
The socket options that can be consulted with  UnixLabels.getsockopt_intand modified withUnixLabels.setsockopt_int. | 
| socket_type_of_sexp [Unix] | |
| socketpair [Unix] | 
Create a pair of unnamed sockets, connected together.
 | 
| some [Option] | |
| some_if [Option] | |
| sort [List] | 
Sort a list in increasing order according to a comparison function.
 | 
| sort [Array] | |
| sort_and_align [Arg] | 
Like align, except that the specification list is also sorted by key
 | 
| sorted_copy [Array] | sorted_copy ar cmpreturns a shallow copy ofarthat is sorted. | 
| space_overhead [Gc.Control.Fields] | |
| space_overhead [Gc.Control] | |
| specialize [Blang] | specialize t fpartially evaluatestaccording to a
    perhaps-incomplete assignmentfof the values of base propositions. | 
| split [String.Escaping] | split s ~escape_char ~on | 
| split [String] | split s ~on | 
| split [Core_set_intf.Accessors] | split x setproduces a tripletriplewherefst3 tripleis the set of elements
      strictly less thanx,snd3 triple=mem set x, andtrd3 tripleis the set of
      elements strictly larger thanx. | 
| split [Filename] | split filenamereturns (dirname filename, basename filename) | 
| split [Array] | split arsplits an array of pairs into two arrays of single elements. | 
| split_extension [Filename] | split_extension fnreturn the portion of the filename before the
    extension and the (optional) extension. | 
| split_n [List] | split_n n [e1; ...; em]is([e1; ...; en], [en+1; ...; em]). | 
| split_on_chars [String.Escaping] | split_on_chars s ~on | 
| split_on_chars [String] | split_on_chars s ~on | 
| sprintf [Printf] | |
| stable_dedup [List] | stable_dedupSame asdedupbut maintains the order of the list and doesn't allow
      compare function to be specified (otherwise, the implementation in terms of Set.t
      would hide a heavyweight functor instantiation at each call). | 
| stable_dedup_involving_an_application_of_the_set_functor [List] | |
| stable_dedup_list [Core_set_intf.Creators] | |
| stable_sort [List] | 
Same as sort, but guaranteed to be stable
 | 
| stable_sort [Array] | |
| stack [Unix.RLimit] | |
| stack_limit [Gc.Control.Fields] | |
| stack_limit [Gc.Control] | |
| stack_size [Gc.Stat.Fields] | |
| stack_size [Gc.Stat] | |
| stage [Staged] | |
| stage [Common] | |
| start_of_day [Ofday] | |
| stat [Unix.Native_file] | 
Return the information for the named file.
 | 
| stat [Unix] | 
Return the information for the named file.
 | 
| stat [Gc] | 
Return the current values of the memory management counters in a
    statrecord. | 
| stats_of_sexp [Unix.Native_file] | |
| stats_of_sexp [Unix] | 
The informations returned by the  UnixLabels.statcalls. | 
| stderr [Out_channel] | |
| stderr [Unix] | 
File descriptor for standard standard error.
 | 
| stdin [In_channel] | |
| stdin [Unix] | 
File descriptor for standard input.
 | 
| stdout [Out_channel] | |
| 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  tmargument, into a formatted string. | 
| strict_add [Hash_set_intf.Accessors] | |
| strict_add_exn [Hash_set_intf.Accessors] | |
| strict_remove [Hash_set_intf.Accessors] | |
| strict_remove_exn [Hash_set_intf.Accessors] | |
| string [Command.Spec] | |
| string_bigstring [Make_substring.Blit] | |
| string_kind [Unix.IOVec] | |
| string_of_float [Common] | |
| string_of_sexp [Std_internal] | |
| string_string [Make_substring.Blit] | |
| strip [String] | strip ?drop sreturns a string with consecutive chars satisfyingdrop(by default
    white space, e.g. | 
| 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 ssubtracts the spansfrom timetand returns the
    resulting time. | 
| sub [Ofday] | |
| sub [Float_intf.S] | |
| sub [String] | |
| sub [List] | sub pos len lis thelen-element sublist ofl, starting atpos. | 
| sub [Array] | Array.sub a start lenreturns a fresh array of lengthlen,
   containing the elements numberstarttostart + len - 1of arraya. | 
| sub [Bigstring] | sub ?pos ?len bstr | 
| sub [Bigbuffer] | Bigbuffer.sub b off lenreturns (a copy of) the substring of the
current contents of the bufferbstarting at offsetoffof lengthlenbytes. | 
| sub_shared [Bigstring] | sub_shared ?pos ?len bstr | 
| subset [Core_set_intf.Accessors] | |
| succ [Int_intf.S] | |
| suffix [Substring_intf.S] | |
| suffix [Make_substring.F] | |
| suffix [String] | suffix s nreturns the longest suffix ofsof length less than or equal ton | 
| summary [Command.Deprecated] | |
| sun [Weekday] | |
| swap [Tuple.T2] | |
| swap [Ref] | swap t1 t2swaps the values int1andt2. | 
| swap [Array] | swap arr i jswaps the value at indexiwith that at indexj. | 
| swap [Array_permute] | |
| symlink [Unix] | symlink source destcreates the filedestas a symbolic link
   to the filesource. | 
| symmetric_diff [Core_map_intf.Accessors] | symmetric_diff t1 t2 ~data_equalreturns a list of changes between t1 and t2. | 
| sync [Unix] | 
Synchronize all filesystem buffers with disk.
 | 
| synchronize [Mutex0] | |
| synchronize [Mutex] | synchronize fcreates a mutex and returns a new function that is identical tofexcept 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.
 | 
| sys_behavior_of_sexp__ [Signal] | |
| 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 [Time] | |
| t_of_sexp [Weekday] | |
| t_of_sexp [Unique_id_intf.Id] | |
| t_of_sexp [Tuple.Hashable_sexpable] | |
| t_of_sexp [Tuple.Comparable_sexpable] | |
| t_of_sexp [Tuple.T3] | |
| t_of_sexp [Tuple.T2] | |
| t_of_sexp [Zone] | |
| t_of_sexp [Stable_containers.Map.V1] | |
| t_of_sexp [Stable_containers.Hash_set.V1] | |
| t_of_sexp [Stable_containers.Hashtbl.V1] | |
| t_of_sexp [Stable_containers.Set.V1] | |
| t_of_sexp [Zone.Stable.V1] | |
| t_of_sexp [Weekday.Stable.V1] | |
| t_of_sexp [Time.Stable.V1] | |
| t_of_sexp [String_id.Stable.V1] | |
| t_of_sexp [Span.Stable.V1] | |
| t_of_sexp [Span.Parts] | |
| t_of_sexp [Span] | |
| t_of_sexp [Source_code_position0] | |
| t_of_sexp [Source_code_position] | |
| t_of_sexp [Signal] | |
| t_of_sexp [Sexpable.S3] | |
| t_of_sexp [Sexpable.S2] | |
| t_of_sexp [Sexpable.S1] | |
| t_of_sexp [Sexpable.Of_stringable] | |
| t_of_sexp [Set_once] | |
| t_of_sexp [Stable_unit_test_intf.Arg] | |
| t_of_sexp [Result.Stable.V1] | |
| t_of_sexp [Result] | |
| t_of_sexp [Ref] | |
| t_of_sexp [Piecewise_linear.Key] | |
| t_of_sexp [Piecewise_linear.S] | |
| t_of_sexp [Pid] | |
| t_of_sexp [Or_error] | |
| t_of_sexp [Ordering] | |
| t_of_sexp [Option] | |
| t_of_sexp [Ofday.Stable.V1] | |
| t_of_sexp [Ofday] | |
| t_of_sexp [Month.Stable.V1] | |
| t_of_sexp [Month] | |
| t_of_sexp [Linux_ext.Priority] | |
| t_of_sexp [Linux_ext.Sysinfo] | |
| t_of_sexp [Int_intf.S] | |
| 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 [Sexpable.S] | |
| t_of_sexp [Info] | |
| t_of_sexp [Identifiable.S] | |
| t_of_sexp [Hash_set_intf.S] | |
| t_of_sexp [Hash_set.Poly] | |
| t_of_sexp [Fqueue] | |
| t_of_sexp [Float_intf.S.Terse] | |
| t_of_sexp [Float_intf.S.Sign] | |
| t_of_sexp [Float_intf.S.Class] | |
| t_of_sexp [Doubly_linked] | |
| t_of_sexp [Dequeue] | |
| 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.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 [String] | |
| t_of_sexp [Stack] | |
| t_of_sexp [Sexp.Sexp_maybe] | |
| t_of_sexp [Sexp] | |
| t_of_sexp [Core_set_intf.S.Tree] | |
| t_of_sexp [Core_set_intf.S] | |
| t_of_sexp [Set.Poly.Tree] | |
| t_of_sexp [Set.Poly] | |
| t_of_sexp [Queue] | |
| t_of_sexp [Core_map_intf.S.Tree] | |
| t_of_sexp [Core_map_intf.S] | |
| t_of_sexp [Map.Poly.Tree] | |
| t_of_sexp [Map.Poly] | |
| t_of_sexp [List.Assoc] | |
| t_of_sexp [List] | |
| t_of_sexp [Lazy] | |
| t_of_sexp [Core_hashtbl_intf.S] | |
| t_of_sexp [Core_hashtbl_intf.Key] | |
| t_of_sexp [Hashtbl.Poly] | |
| t_of_sexp [Gc.Control] | |
| t_of_sexp [Gc.Stat] | |
| t_of_sexp [Char] | |
| t_of_sexp [Array] | |
| t_of_sexp [Constrained_float.S] | |
| t_of_sexp [Comparator.Pre_binable] | |
| t_of_sexp [Comparator.Pre] | |
| t_of_sexp [Commutative_group.S] | |
| t_of_sexp [Byte_units.Measure] | |
| t_of_sexp [Byte_units] | |
| t_of_sexp [Bucket.S] | |
| t_of_sexp [Bucket.Contents] | |
| t_of_sexp [Bucket.Make] | |
| t_of_sexp [Bounded_int_table.With_key] | |
| t_of_sexp [Bool] | |
| t_of_sexp [Blang.Stable.V1] | |
| t_of_sexp [Blang] | |
| t_of_sexp [Bigstring] | |
| t_of_sexp__ [Source_code_position0] | |
| t_of_sexp__ [Unix.Scheduler.Policy] | |
| t_of_sexp__ [Unix.Protocol_family] | |
| t_of_sexp__ [Byte_units.Measure] | |
| t_of_sexp_abs [Time] | |
| tag [Info] | |
| tag_arg [Info] | |
| take [List] | take l nisfst (split_n n l). | 
| take [Bucket.S] | |
| take [Bucket.Make] | |
| take_at_most [Bucket.S] | |
| take_at_most [Bucket.Make] | |
| take_back_exn [Dequeue] | |
| take_front_exn [Dequeue] | |
| take_while [List] | take_while l ~freturns the longest prefix oflfor whichfistrue. | 
| 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:
      TCOOFFsuspends output,TCOONrestarts output,TCIOFFtransmits a STOP character to suspend input,
     andTCIONtransmits 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:  TCIFLUSHflushes data received but not read,TCOFLUSHflushes data written but not transmitted, andTCIOFLUSHflushes 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                                   |
 | 
| test [Binary_packing] | |
| test_invariants [Fqueue] | 
test via asserts whether invariants hold
 | 
| tests [Stable_unit_test_intf.Arg] | |
| tests [Inline_tests] | |
| tg [Quickcheck] | 
triple generator
 | 
| threads_have_been_created [Thread] | trueiff Thread.create has ever been called, even if there is
    currently only one running thread. | 
| thu [Weekday] | |
| time [Unix] | 
Return the current time since 00:00:00 GMT, Jan.
 | 
| time_span [Command.Spec] | |
| timedlock [Mutex] | timedlock mtx timeoutlikelock, but takes atimeoutparameter. | 
| timedwait [Condition] | timedwait cond mtx timeoutwaits on condition variablecondwith mutexmtxuntil either the condition is signalled, or untiltimeoutexpires. | 
| timegm [Unix] | 
Convert a UTC time in a tm record to a time in seconds
 | 
| times [Unix] | 
Return the execution times of the process.
 | 
| tl [List] | |
| tl_exn [List] | 
Return the given list without its first element.
 | 
| tm_of_sexp [Unix] | 
The type representing wallclock time and calendar date.
 | 
| to_alist [Core_map_intf.Accessors] | 
creates association list from map.
 | 
| to_alist [Core_hashtbl_intf.Accessors] | 
Returns the list of all (key,data) pairs for given hashtable.
 | 
| to_alist [Bounded_int_table] | |
| to_array [Hash_queue.Make] | |
| to_array [Queue] | |
| to_array [Container.Generic_phantom] | |
| to_array [Container.Generic] | |
| to_array [Container.S1_phantom] | |
| to_array [Container.S1] | |
| to_array [Container.S0_phantom] | |
| to_array [Container.S0] | |
| to_array [Container.Make] | |
| to_bigstring [Substring_intf.S] | |
| to_bigstring [Make_substring.F] | |
| to_bigstring [Binable0] | |
| to_bigstring [Binable] | |
| to_caml_int [Signal] | |
| to_date [Time] | |
| to_date_ofday [Time] | |
| to_day [Span] | |
| to_epoch [Time] | to_epoch treturns the number of seconds since Jan 1, 1970 00:00:00 in UTC | 
| to_exn [Info] | |
| to_filename_string [Time] | to_filename_string tconvertstto string with format YYYY-MM-DD_HH-MM-SS.mmm
    which is suitable for using in filenames | 
| to_float [Floatable.S] | |
| to_float [Int64] | |
| to_hr [Span] | |
| to_int [Weekday] | to_int treturns an int in 0,1,...6. | 
| to_int [Pid] | |
| to_int [Month] | to_int treturns an int in 1,2,...12. | 
| to_int [Linux_ext.Priority] | |
| to_int [Float_intf.S] | |
| to_int [Unix.File_descr] | |
| to_int [Nativeint] | |
| to_int [Int64] | |
| to_int [Int63] | |
| to_int [Int32] | |
| to_int [Int] | |
| to_int [Char] | 
Return the ASCII code of the argument.
 | 
| to_int32 [Nativeint] | |
| to_int32 [Int64] | |
| to_int32 [Int32] | |
| to_int32 [Int] | |
| to_int32_exn [Int_intf.S] | |
| to_int32_exn [Nativeint] | |
| to_int64 [Int_intf.S] | |
| to_int64 [Float_intf.S] | |
| to_int_exn [Intable.S] | |
| to_int_exn [Nativeint] | |
| to_knots [Piecewise_linear.S] | |
| to_list [Hash_queue.Make] | |
| to_list [Fqueue] | to_list treturns a list of the elements intin order from least-recently-added
    (at the head) to most-recently added (at the tail). | 
| to_list [Unix.Resource_usage.Fields] | |
| to_list [Queue] | |
| to_list [Gc.Control.Fields] | |
| to_list [Gc.Stat.Fields] | |
| to_list [Container.Generic_phantom] | |
| to_list [Container.Generic] | |
| to_list [Container.S1_phantom] | |
| to_list [Container.S1] | |
| to_list [Container.S0_phantom] | |
| to_list [Container.S0] | |
| to_list [Container.Make] | |
| to_list_rev [String] | 
Returns the reversed list of characters contained in a list.
 | 
| to_local_date [Time] | |
| to_local_date_ofday [Time] | |
| to_local_ofday [Time] | |
| to_localized_string [Time] | to_localized_string time zonereturns a string representation oftimein the given zone in the form like "2008-11-18 15:34:56.123". | 
| to_millisec_string [Ofday] | 
with milliseconds
 | 
| to_min [Span] | |
| to_ms [Span] | |
| to_nativeint [Nativeint] | |
| to_nativeint [Int64] | |
| to_nativeint [Int32] | |
| to_nativeint [Int] | |
| to_nativeint_exn [Int_intf.S] | |
| 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 tSame as to_string, but without milliseconds | 
| to_sec_string [Ofday] | 
trailing milliseconds are trimmed
 | 
| to_sexp_hum [Source_code_position0] | |
| to_sexp_hum [Source_code_position] | |
| to_short_string [Span] | to_short_string tpretty-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 treturns a human-readable name: "sigabrt", "sigalrm", ... | 
| to_string [Sexpable.To_stringable] | |
| to_string [Substring_intf.S] | |
| to_string [Make_substring.F] | |
| to_string [Int_set] | |
| to_string [Stringable.S] | |
| to_string [Exn] | |
| to_string [Unix.Inet_addr] | 
Return the printable representation of the given Internet address.
 | 
| to_string [Printexc] | |
| to_string [List] | |
| to_string [Bin_prot.Writer] | |
| to_string [Binable] | |
| to_string [Bigstring] | to_string ?pos ?len bstr | 
| to_string [Backtrace] | |
| to_string_abs [Time] | to_string_abs ?zone treturns a string that represents an absolute time, rather than
    a local time with an assumed time zone. | 
| to_string_american [Date] | |
| to_string_deprecated [Time] | to_string_deprecatedreturns a string in the old format | 
| to_string_fix_proto [Time] | |
| to_string_hum [Int_intf.S] | |
| to_string_hum [Int_conversions.Make] | |
| to_string_hum [Info] | 
might be an expensive operation
 | 
| to_string_hum [Float_intf.S] | 
Pretty print float, for example  to_string_hum ~decimals:3 1234.1999 = "1_234.200"to_string_hum ~decimals:3 ~strip_zero:true 1234.1999 = "1_234.2" . | 
| 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 tSame 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_tree [Core_set_intf.Accessors] | |
| to_tree [Core_map_intf.Accessors] | |
| to_us [Span] | |
| today [Time.Date] | |
| top [Heap] | top heap | 
| top [Hash_heap.S] | |
| top [Hash_heap.Make] | |
| top [Fqueue] | 
like  top_exn, but returns result optionally, without exception, Complexity: O(1) | 
| top [Stack] | top treturnsNoneiftis empty, otherwise it returnsSome xwherexis the top oft. | 
| top_exn [Heap] | top_exn heap | 
| top_exn [Hash_heap.S] | |
| top_exn [Hash_heap.Make] | |
| top_exn [Fqueue] | 
Like  bot_exn, except returns top (least-recently enqueued element. | 
| top_exn [Stack] | top_exn treturns the top element oft, raisingEmptyiftis empty. | 
| top_heap_el [Heap] | top_heap_el heap | 
| top_heap_el_exn [Heap] | top_heap_el_exn heap | 
| top_heap_words [Gc.Stat.Fields] | |
| top_heap_words [Gc.Stat] | |
| top_with_key [Hash_heap.S] | |
| top_with_key [Hash_heap.Make] | |
| top_with_key_exn [Hash_heap.S] | |
| top_with_key_exn [Hash_heap.Make] | |
| tr [String] | tr target replacement sreplaces every instance oftargetinswithreplacement. | 
| tr_inplace [String] | tr_inplace target replacement sdestructively modifies s (in place!)
    replacing every instance oftargetinswithreplacement. | 
| transfer [Doubly_linked] | transfer ~src ~dsthas the same behavior asiter src ~f:(insert_last dst); clear srcexcept that it runs in constant time. | 
| transfer [Queue] | transfer ~src ~dstadds all of the elements ofsrcto the end ofdst,
    then clearssrc. | 
| transfer [Bag] | transfer ~src ~dstmoves all of the elements fromsrctodstin constant
    time. | 
| 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.
 | 
| transpose [List] | transpose mtransposes the rows and columns of the matrixm,
    considered as either a row of column lists or (dually) a column of row lists. | 
| transpose_exn [List] | transpose_exntransposes the rows and columns of its argument, throwing exception if
    the list is not rectangular. | 
| trd3 [Common] | |
| true_ [Blang] | |
| truncate [Unix.Native_file] | |
| truncate [Unix] | 
Truncates the named file to the given size.
 | 
| truncate [Common] | |
| try_lock [Nano_mutex] | try_lock tlockstif it can immediately do so. | 
| try_lock [Mutex] | try_lock mtxlikelock, but returns immediately withfalseif the mutex is already being held by another thread, or acquires
    the mutex and returnstrueotherwise. | 
| try_lock_exn [Nano_mutex] | |
| try_with [Result] | |
| try_with [Or_error] | try_with fcatches exceptions thrown byfand returns them in the Result.t as an
    Error.t. | 
| try_with [Option] | try_with freturnsSome xiffreturnsxandNoneiffraises an
    exception. | 
| try_with_join [Or_error] | |
| tstp [Signal] | 
| Stop      | Interactive stop                              |
 | 
| ttin [Signal] | 
| Stop      | Terminal read from background process         |
 | 
| ttou [Signal] | 
| Stop      | Terminal write from background process        |
 | 
| tue [Weekday] | |
| tune [Gc] | 
Adjust the specified GC parameters.
 | 
| tuple [Host_and_port] | |
| U | |
| ubound [Interval_intf.Gen_set] | |
| ubound [Interval_intf.Gen] | |
| ubound_exn [Interval_intf.Gen_set] | |
| ubound_exn [Interval_intf.Gen] | |
| uig [Quickcheck] | 
unsigned int generator (uniform random in range min_int, max_int)
 | 
| umask [Unix] | 
Set the process creation mask, and return the previous mask.
 | 
| uname [Unix] | |
| uncapitalize [String] | |
| uncurry [Tuple.T3] | |
| uncurry [Tuple.T2] | |
| unescape [String.Escaping] | unescape ~escape_charis defined asunescape_gen_exn ~map:[] ~escape_char | 
| unescape_gen [String.Escaping] | |
| unescape_gen_exn [String.Escaping] | unescape_gen_exnis the inverse operation ofescape_gen_exn. | 
| unimplemented [Or_error] | unimplemented namereturns a standard error value for an unimplemented value. | 
| unimplemented [Common] | |
| union [Union_find] | union t1 t2makes the class oft1and the class oft2be the same (if they are
    already equal, then nothing changes). | 
| union [Core_set_intf.Accessors] | |
| union_list [Core_set_intf.Creators] | |
| unit [Memo] | 
efficient special case for argument type  unit | 
| unix_error [Unix] | |
| unlink [Unix] | 
Removes the named file
 | 
| unlock [Nano_mutex] | unlock tunlockst, if the current thread holds it. | 
| unlock [Unix.Flock_command] | |
| unlock [Mutex] | unlock mtxunlocksmtx. | 
| unlock_exn [Nano_mutex] | |
| unmarshal [Bigstring_marshal] | unmarshal ?pos bufunmarshals data contained inbufstarting
    at positionpos. | 
| unmarshal_from_sock [Bigstring_marshal] | unmarshal_from_sock ?buf sockunmarshals data from socketsockusing unmarshalling bufferbuf. | 
| unmarshal_next [Bigstring_marshal] | unmarshal_next ?pos bufunmarshals data contained inbufstarting
    at positionpos. | 
| unordered_append [List] | |
| unpack [Unpack_buffer] | unpack tunpacks all the values that it can fromt. | 
| unpack_float [Binary_packing] | 
As with integers, floats can be be packed big endian or little endian, depending on
    the order in which the bytes of the float are layed out.
 | 
| unpack_padded_fixed_string [Binary_packing] | 
Decode the fixed length padded string having length  lenfrombufstarting atpos. | 
| unpack_signed_16 [Binary_packing] | |
| unpack_signed_16_big_endian [Binary_packing] | |
| unpack_signed_16_little_endian [Binary_packing] | |
| unpack_signed_32 [Binary_packing] | |
| unpack_signed_32_int [Binary_packing] | |
| unpack_signed_32_int_big_endian [Binary_packing] | |
| unpack_signed_32_int_little_endian [Binary_packing] | |
| unpack_signed_64 [Binary_packing] | |
| unpack_signed_64_big_endian [Binary_packing] | |
| unpack_signed_64_int [Binary_packing] | |
| unpack_signed_64_little_endian [Binary_packing] | |
| unpack_signed_8 [Binary_packing] | |
| unpack_unsigned_16 [Binary_packing] | |
| unpack_unsigned_16_big_endian [Binary_packing] | |
| unpack_unsigned_16_little_endian [Binary_packing] | |
| unpack_unsigned_32_int [Binary_packing] | |
| unpack_unsigned_32_int_big_endian [Binary_packing] | |
| unpack_unsigned_32_int_little_endian [Binary_packing] | |
| unpack_unsigned_8 [Binary_packing] | |
| unsafe_blit [Bigstring] | unsafe_blit ~src ~src_pos ~dst ~dst_pos ~lensimilar toBigstring.blit, but does not perform any bounds checks. | 
| unsafe_blit_bigstring_string [Bigstring] | unsafe_blit_bigstring_string ~src ~src_pos ~dst ~dst_pos ~lensimilar toBigstring.blit_bigstring_string, but does not perform
    any bounds checks. | 
| unsafe_blit_string_bigstring [Bigstring] | unsafe_blit_string_bigstring ~src ~src_pos ~dst ~dst_pos ~lensimilar toBigstring.blit_string_bigstring, but does not perform
    any bounds checks. | 
| unsafe_destroy [Bigstring] | unsafe_destroy bstrdestroys the bigstring by deallocating its associated data or,
    if memory-mapped, unmapping the corresponding file, and setting all dimensions to
    zero. | 
| unsafe_get [Array] | 
Unsafe version of  get. | 
| unsafe_get_int16_be [Bigstring] | |
| unsafe_get_int16_le [Bigstring] | |
| unsafe_get_int32_be [Bigstring] | |
| unsafe_get_int32_le [Bigstring] | |
| unsafe_get_int32_t_be [Bigstring] | |
| unsafe_get_int32_t_le [Bigstring] | |
| unsafe_get_int64_be_exn [Bigstring] | |
| unsafe_get_int64_le_exn [Bigstring] | |
| unsafe_get_int64_t_be [Bigstring] | |
| unsafe_get_int64_t_le [Bigstring] | |
| unsafe_get_uint16_be [Bigstring] | |
| unsafe_get_uint16_le [Bigstring] | |
| unsafe_input [Bigstring] | unsafe_input ~min_len ic ~pos ~len bstrsimilar toBigstring.input, but does not perform any bounds checks. | 
| unsafe_input_value [In_channel] | |
| unsafe_of_int [Char] | |
| unsafe_output [Bigstring] | unsafe_output ~min_len oc ~pos ~len bstrsimilar toBigstring.output, but does not perform any bounds checks. | 
| unsafe_read [Bigstring] | unsafe_read ~min_len fd ~pos ~len bstrsimilar toBigstring.read, but does not perform any bounds checks. | 
| unsafe_read_assume_fd_is_nonblocking [Bigstring] | unsafe_read_assume_fd_is_nonblocking fd ~pos ~len bstrsimilar toBigstring.read_assume_fd_is_nonblocking, but does
    not perform any bounds checks. | 
| unsafe_really_recv [Bigstring] | unsafe_really_recv sock ~pos ~len bstrsimilar toBigstring.really_recv, but does not perform any
    bounds checks. | 
| unsafe_really_send_no_sigpipe [Bigstring] | unsafe_really_send_no_sigpipe sock ~pos ~len bstrsimilar toBigstring.send, but does not perform any
    bounds checks. | 
| unsafe_really_write [Bigstring] | unsafe_really_write fd ~pos ~len bstrsimilar toBigstring.write, but does not perform any bounds checks. | 
| unsafe_send_nonblocking_no_sigpipe [Bigstring] | unsafe_send_nonblocking_no_sigpipe sock ~pos ~len bstrsimilar toBigstring.send_nonblocking_no_sigpipe, but does not perform any
    bounds checks. | 
| unsafe_sendmsg_nonblocking_no_sigpipe [Bigstring] | unsafe_sendmsg_nonblocking_no_sigpipe fd iovecs countsimilar toBigstring.sendmsg_nonblocking_no_sigpipe, but
    does not perform any bounds checks. | 
| unsafe_set [Array] | 
Unsafe version of  set. | 
| unsafe_set_int16_be [Bigstring] | |
| unsafe_set_int16_le [Bigstring] | |
| unsafe_set_int32_be [Bigstring] | |
| unsafe_set_int32_le [Bigstring] | |
| unsafe_set_int32_t_be [Bigstring] | |
| unsafe_set_int32_t_le [Bigstring] | |
| unsafe_set_int64_be [Bigstring] | |
| unsafe_set_int64_le [Bigstring] | |
| unsafe_set_int64_t_be [Bigstring] | |
| unsafe_set_int64_t_le [Bigstring] | |
| unsafe_set_uint16_be [Bigstring] | |
| unsafe_set_uint16_le [Bigstring] | |
| unsafe_write [Bigstring] | unsafe_write fd ~pos ~len bstrsimilar toBigstring.write, but does not perform any bounds checks. | 
| unsafe_write_assume_fd_is_nonblocking [Bigstring] | unsafe_write_assume_fd_is_nonblocking fd ~pos ~len bstrsimilar toBigstring.write_assume_fd_is_nonblocking, but does
    not perform any bounds checks. | 
| unsafe_writev [Bigstring] | unsafe_writev fd iovecs countsimilar toBigstring.writev, but does not perform any bounds checks. | 
| unsetenv [Unix] | unsetenv namedeletes the variablenamefrom the environment. | 
| unstage [Staged] | |
| unstage [Common] | |
| until_empty [Stack] | until_empty t frepeatedly pops an elementvoff oftand runsf vuntiltbecomes empty. | 
| until_empty [Bag] | until_empty t frepeatedly removes a valuevfromtand runsf v,
    continuing untiltis empty. | 
| unzip [List] | 
Transform a list of pairs into a pair of lists:
     unzip [(a1,b1); ...; (an,bn)]is([a1; ...; an], [b1; ...; bn]). | 
| update [Heap] | update heap_el elupdatesheap_elwith elementelin its
    associated heap. | 
| update_broadcast [Mutex0] | |
| update_broadcast [Mutex] | update_broadcast mtx cnd ~fupdates some state within a critical
    section protected by mutexmtxusing functionfand broadcasts
    condition variablecndafter finishing. | 
| update_signal [Mutex0] | |
| update_signal [Mutex] | update_signal mtx cnd ~fupdates some state within a critical
    section protected by mutexmtxusing functionfand signals
    condition variablecndafter finishing. | 
| uppercase [String] | |
| uppercase [Char] | 
Convert the given character to its equivalent uppercase character.
 | 
| usage [Arg] | Arg.usage speclist usage_msgprints to standard error
    an error message that includes the list of valid options. | 
| usage_string [Arg] | 
Returns the message that would have been printed by  Arg.usage,
    if provided with the same parameters. | 
| usr1 [Signal] | 
| Terminate | Application-defined signal 1                  |
 | 
| usr2 [Signal] | 
| Terminate | Application-defined signal 2                  |
 | 
| utc [Zone] | utcthe 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.
 | 
| uw [Common] | 
Option handling
 | 
| V | |
| value [Option] | value None ~default=defaultvalue (Some x) ~default=x | 
| value [Heap_block] | value treturns the value that is physically equal tot | 
| value [Doubly_linked.Elt] | |
| value [Bag.Elt] | |
| value_exn [Option] | value_exn (Some x)=x. | 
| value_map [Option] | value_map t ~f ~defaultis equivalent tovalue (map t ~f) ~default, except that
    it is slightly faster since it avoids creating the intermediate option. | 
| values [Blang] | values tforms the list containing everyvfor whichBase vis a subexpression oft | 
| verbose [Gc.Control.Fields] | |
| verbose [Gc.Control] | |
| version [Unix.Utsname] | |
| version [Command.Deprecated] | |
| virtual_memory [Unix.RLimit] | |
| volatile_contents [Bigbuffer] | 
Return the actual underlying bigstring used by this bigbuffer.
 | 
| vtalrm [Signal] | 
| Terminate | Timeout in virtual time                       |
 | 
| W | |
| wait [Linux_ext.Epoll] | wait t ~timeoutblocks until at least one file descriptor intis ready for one
      of the events it is being watched for, ortimeoutpasses. | 
| wait [Unix] | |
| wait [Condition] | |
| wait_nohang [Unix] | |
| wait_nohang_untraced [Unix] | |
| wait_not_empty [Squeue] | wait_not_empty sqWaits for something to be available. | 
| wait_on_of_sexp [Unix] | |
| wait_on_of_sexp__ [Unix] | |
| wait_read [Thread] | 
See  Thread.wait_write. | 
| wait_signal [Thread] | wait_signal sigssuspends the execution of the calling thread
   until the process receives one of the signals specified in the
   listsigs. | 
| wait_timed_read [Thread] | 
See  Thread.wait_timed_write. | 
| wait_timed_write [Thread] | 
Same as  Thread.wait_readandThread.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 pidwaits for child processpidto terminate, and returns its exit status. | 
| waitpid_exn [Unix] | |
| wed [Weekday] | |
| weekdays_between [Date] | |
| with_file [Out_channel] | |
| with_file [In_channel] | with_file ~f fnameexecutes~fon the open channel fromfname, and closes it afterwards. | 
| with_file [Unix] | with_file file ~mode ~perm ~fopensfile, and appliesfto the resulting file
    descriptor. | 
| with_return [With_return] | |
| with_return [Common] | |
| word_size [Word_size] | |
| word_size [Sys] | 
Size of one word on the machine currently executing the Caml program, in
    bits: 32 or 64.
 | 
| wordexp [Unix] | |
| words [Byte_units] | |
| wrap [Command.Spec] | 
combinator for defining a class of commands with common behavior
 | 
| write [Unix] | write fd buff ofs lenwriteslencharacters to descriptorfd, taking them from stringbuff, starting at positionofsin stringbuff. | 
| write [Bigstring] | write fd ?pos ?len bstrwriteslenbytes in bigstringbstrstarting at positionposto file
    descriptorfd. | 
| write_all [Out_channel] | write_all file datawrites all data to the named file. | 
| write_assume_fd_is_nonblocking [Unix] | write_assume_fd_is_nonblocking fd ?pos ?len bufcalls the system callwriteASSUMING THAT IT IS NOT GOING TO BLOCK. | 
| write_assume_fd_is_nonblocking [Bigstring] | write_assume_fd_is_nonblocking fd ?pos ?len bstrwriteslenbytes in bigstringbstrstarting at positionposto file
    descriptorfdwithout yielding to other OCaml-threads. | 
| write_lines [Out_channel] | write_lines file linesworks like output_lines, except that the output is sent to
    the named file. | 
| write_new_string_and_sexp_formats__read_both [Time] | 
If this is ever called then all future calls to to_string and sexp_of_t will produce a
    new format sexp/string that includes enough offset information to reproduce the
    correct Time.t when of_string/t_of_sexp is called, even if they are called on a
    machine with a different timezone than the writing machine.
 | 
| write_new_string_and_sexp_formats__read_only_new [Time] | 
This does the same as  write_new_string_and_sexp_formats__read_bothand additionallyof_stringandt_of_sexpwill not accept formats without a timezone. | 
| writev [Unix] | writev fd ?count iovecslikeUnix.writev_assume_fd_is_nonblocking, but does
    not require the descriptor to not block. | 
| writev [Bigstring] | writev fd ?count iovecswritescountiovecsof
    bigstrings to file descriptorfd. | 
| writev_assume_fd_is_nonblocking [Unix] | writev_assume_fd_is_nonblocking fd ?count iovecscalls the system callwritevASSUMING THAT IT IS NOT GOING TO BLOCK usingcountI/O-vectorsiovecs. | 
| writev_assume_fd_is_nonblocking [Bigstring] | writev_assume_fd_is_nonblocking fd ?count iovecswritescountiovecsof bigstrings to file descriptorfdwithout yielding to
    other OCaml-threads. | 
| Y | |
| year [Date] | |
| yield [Thread] | 
Re-schedule the calling thread without suspending it.
 | 
| Z | |
| zero [Span] | |
| zero [Signal] | |
| zero [Int_intf.S] | |
| zero [Float_intf.S] | |
| zero [Commutative_group.S] | |
| zero [Bucket.Contents] | |
| zip [List] | 
Transform a pair of lists into an (optional) list of pairs:
     zip [a1; ...; an] [b1; ...; bn]is[(a1,b1); ...; (an,bn)]. | 
| zip_exn [List] |