# Index of values

( * ) [Percent] |
( * ) [Int_math.T] |
( * ) [Int_intf.S.O] |
( * ) [Int_intf.S] |
( * ) [Float_intf.S.O] |
( * ) [Float_intf.S] |
( *> ) [Applicative_intf.S2.Applicative_infix] |
( *> ) [Applicative_intf.S.Applicative_infix] |
( <* ) [Applicative_intf.S2.Applicative_infix] |
( <* ) [Applicative_intf.S.Applicative_infix] |
(!) [Ref.Permissioned] | `get` and `(!)` are two names for the same function.
(!) [Ref] |
(!=) [Common] |
(%) [Std_internal] |
(%) [Int_math.Make] |
(%) [Int_intf.S.O] |
(%) [Int_intf.S] |
(&) [Common] |
(+) [Time_ns.Span] |
(+) [Int_math.T] |
(+) [Int_intf.S.O] |
(+) [Int_intf.S] |
(+) [Float_intf.S.O] |
(+) [Float_intf.S] |
(+) [Flags_intf.S] | set union, bitwise or
(+) [Commutative_group.S] |
(+) [Byte_units.Infix] | `( / ) t mul` scales `t` by `1/mul`
(+) [Bucket.Contents] |
(-) [Time_ns.Span] |
(-) [Int_math.T] |
(-) [Int_intf.S.O] |
(-) [Int_intf.S] |
(-) [Float_intf.S.O] |
(-) [Float_intf.S] |
(-) [Flags_intf.S] | set difference
(-) [Commutative_group.S] |
(-) [Byte_units.Infix] |
(-) [Bucket.Contents] |
(/%) [Std_internal] |
(/%) [Int_math.Make] |
(/%) [Int_intf.S.O] |
(/%) [Int_intf.S] | There are two pairs of integer division and remainder functions, `/%` and `%`, and `/` and `rem`.
(/) [Time_ns.Span] |
(/) [Int_math.T] |
(/) [Int_intf.S.O] |
(/) [Int_intf.S] |
(/) [Float_intf.S.O] |
(/) [Float_intf.S] |
(/) [Byte_units.Infix] |
(//) [Std_internal] |
(//) [Time_ns.Span] |
(//) [Int_math.Make] |
(//) [Int_intf.S.O] |
(//) [Int_intf.S] | float division of integers
(//) [Byte_units.Infix] | `( // ) t1 t2` returns the ratio of t1 to t2
(:=) [Ref.Permissioned] |
(:=) [Ref] |
(<) [Polymorphic_compare] |
(<) [No_polymorphic_compare] |
(<) [Polymorphic_compare_intf.Infix] |
(<*>) [Applicative_intf.S2.Applicative_infix] |
(<*>) [Applicative_intf.S.Applicative_infix] | same as `apply`
(<.) [Robustly_comparable.S] |
(</>) [Core_string.Infix] |
(<=) [Polymorphic_compare] |
(<=) [No_polymorphic_compare] |
(<=) [Polymorphic_compare_intf.Infix] |
(<=.) [Robustly_comparable.S] |
(<>) [Polymorphic_compare] |
(<>) [No_polymorphic_compare] |
(<>) [Polymorphic_compare_intf.Infix] |
(<>.) [Robustly_comparable.S] |
(<|>) [Core_array.Permissioned.Infix] |
(<|>) [Core_array.Infix] |
(=) [Polymorphic_compare] |
(=) [No_polymorphic_compare] |
(=) [Polymorphic_compare_intf.Infix] |
(=.) [Robustly_comparable.S] |
(==) [Common] |
(==>) [Common] |
(>) [Polymorphic_compare] |
(>) [No_polymorphic_compare] |
(>) [Polymorphic_compare_intf.Infix] |
(>.) [Robustly_comparable.S] |
(>=) [Polymorphic_compare] |
(>=) [No_polymorphic_compare] |
(>=) [Polymorphic_compare_intf.Infix] |
(>=.) [Robustly_comparable.S] |
(>>=) [Monad_intf.Infix2] |
(>>=) [Monad_intf.Infix] | `t >>= f` returns a computation that sequences the computations represented by two monad elements.
(>>|) [Monad_intf.Infix2] |
(>>|) [Monad_intf.Infix] | `t >>| f` is `t >>= (fun a -> return (f a))`.
(@) [Sequence.Infix] |
(@) [Core_list.Infix] |
(@>) [Applicative_intf.Args2] |
(@>) [Applicative_intf.Args] | infix operator for `cons`
(^) [Rope] | takes O(1) time
(^) [Core_string] | String append.
(or) [Common] |
(|!) [Fn] | A 'pipe' operator.
(|!) [Common] | Functions from fn.ml
(|>) [Fn] | A pipe operator, equivalent to |!, but this notation is more broadly accepted
(|>) [Common] |
(~-) [Int_math.T] |
(~-) [Int_intf.S.O] |
(~-) [Int_intf.S] |
(~-) [Float_intf.S.O] |
(~-) [Float_intf.S] |
__bin_read_decimal__ [Std_kernel] |
__bin_read_immutable__ [Perms.Export] |
__bin_read_me__ [Perms.Stable.V1] |
__bin_read_me__ [Perms] |
__bin_read_no_raise__ [Core_sexp] |
__bin_read_nobody__ [Perms.Stable.V1] |
__bin_read_nobody__ [Perms] |
__bin_read_outer__ [Float_intf.S] |
__bin_read_perms__ [Perms.Export] |
__bin_read_read__ [Perms.Export] |
__bin_read_read_write__ [Perms.Export] |
__bin_read_sexp_array__ [Std_internal] |
__bin_read_sexp_bool__ [Std_internal] |
__bin_read_sexp_list__ [Std_internal] |
__bin_read_sexp_list__ [Stable_internal] |
__bin_read_sexp_opaque__ [Std_internal] |
__bin_read_sexp_option__ [Std_internal] |
__bin_read_sexp_option__ [Stable_internal] |
__bin_read_t__ [Validated_intf.Raw_binable] |
__bin_read_t__ [Timing_wheel_intf.Interval_num.Span] |
__bin_read_t__ [Timing_wheel_intf.Interval_num] |
__bin_read_t__ [T.T_bin] |
__bin_read_t__ [Unique_id_intf.Id] |
__bin_read_t__ [Total_map.Key] |
__bin_read_t__ [Total_map.S] |
__bin_read_t__ [String_id.S.Stable.V1] |
__bin_read_t__ [Time_ns.Span] |
__bin_read_t__ [Time_ns] |
__bin_read_t__ [Stack_unit_tests.Test] |
__bin_read_t__ [Stack_unit_tests.Debug] |
__bin_read_t__ [Stack_intf.S] |
__bin_read_t__ [Stable_unit_test_intf.Unordered_container_arg] |
__bin_read_t__ [Stable_internal.Sexp] |
__bin_read_t__ [Stable_containers.Hashable.V1.S.Hash_set] |
__bin_read_t__ [Stable_containers.Hashable.V1.S.Table] |
__bin_read_t__ [Source_code_position0.Stable.V1] |
__bin_read_t__ [Source_code_position] |
__bin_read_t__ [Set_once] |
__bin_read_t__ [Stable_unit_test_intf.Arg] |
__bin_read_t__ [Result] |
__bin_read_t__ [Ref.Permissioned] |
__bin_read_t__ [Ref] |
__bin_read_t__ [Pool_intf.S.Pointer.Id] |
__bin_read_t__ [Pid] |
__bin_read_t__ [Perms.Stable.V1.Upper_bound] |
__bin_read_t__ [Perms.Stable.V1.Read_write] |
__bin_read_t__ [Perms.Stable.V1.Immutable] |
__bin_read_t__ [Perms.Stable.V1.Write] |
__bin_read_t__ [Perms.Stable.V1.Read] |
__bin_read_t__ [Perms.Upper_bound] |
__bin_read_t__ [Perms.Read_write] |
__bin_read_t__ [Perms.Immutable] |
__bin_read_t__ [Perms.Write] |
__bin_read_t__ [Perms.Read] |
__bin_read_t__ [Percent.Stable.V1] |
__bin_read_t__ [Ordering] |
__bin_read_t__ [Or_error] |
__bin_read_t__ [Option] |
__bin_read_t__ [Nothing0] |
__bin_read_t__ [Nothing.Stable.V1] |
__bin_read_t__ [Month.Stable.V1] |
__bin_read_t__ [Month] |
__bin_read_t__ [Linked_queue] |
__bin_read_t__ [Stable_module_types.S2] |
__bin_read_t__ [Int_intf.S] |
__bin_read_t__ [Int_intf.Hexable.Hex] |
__bin_read_t__ [Stable_module_types.S0] |
__bin_read_t__ [Info] |
__bin_read_t__ [Identifiable.S] |
__bin_read_t__ [Host_and_port.Stable.V1] |
__bin_read_t__ [Fqueue.Stable.V1] |
__bin_read_t__ [Fqueue] |
__bin_read_t__ [Float_intf.S.Terse] |
__bin_read_t__ [Float_intf.S.Class] |
__bin_read_t__ [Fdeque.Stable.V1] |
__bin_read_t__ [Fdeque] |
__bin_read_t__ [Either_intf.S] |
__bin_read_t__ [Deque] |
__bin_read_t__ [Decimal] |
__bin_read_t__ [Day_of_week.Stable.V1] |
__bin_read_t__ [Day_of_week] |
__bin_read_t__ [Core_string] |
__bin_read_t__ [Core_sexp.With_text] |
__bin_read_t__ [Core_sexp.Sexp_maybe] |
__bin_read_t__ [Core_sexp.Sexp_opaque] |
__bin_read_t__ [Core_sexp.Sexp_array] |
__bin_read_t__ [Core_sexp.Sexp_list] |
__bin_read_t__ [Core_sexp.Sexp_option] |
__bin_read_t__ [Core_sexp] |
__bin_read_t__ [Core_set_intf.Elt_binable] |
__bin_read_t__ [Core_set.Poly] |
__bin_read_t__ [Core_queue] |
__bin_read_t__ [Core_map_intf.Key_binable] |
__bin_read_t__ [Core_map.Poly] |
__bin_read_t__ [Core_list.Assoc] |
__bin_read_t__ [Core_list] |
__bin_read_t__ [Stable_module_types.S1] |
__bin_read_t__ [Core_lazy] |
__bin_read_t__ [Core_hashtbl_intf.Hashtbl.Poly] |
__bin_read_t__ [Core_hashtbl_intf.Key_binable] |
__bin_read_t__ [Core_gc.Control] |
__bin_read_t__ [Core_gc.Stat] |
__bin_read_t__ [Core_char] |
__bin_read_t__ [Core_array.Permissioned.Float] |
__bin_read_t__ [Core_array.Permissioned.Int] |
__bin_read_t__ [Core_array.Permissioned] |
__bin_read_t__ [Core_array.Float] |
__bin_read_t__ [Core_array.Int] |
__bin_read_t__ [Core_array] |
__bin_read_t__ [Constrained_float.S] |
__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] |
__decimal_of_sexp__ [Std_kernel] |
__t_of_sexp__ [Source_code_position0.Stable.V1] |
__t_of_sexp__ [Perms.Upper_bound] |
__t_of_sexp__ [Perms.Read_write] |
__t_of_sexp__ [Perms.Immutable] |
__t_of_sexp__ [Perms.Write] |
__t_of_sexp__ [Perms.Read] |
__t_of_sexp__ [Nothing0] |
__t_of_sexp__ [Byte_units.Measure] |
_squelch_unused_module_warning_ [Std] |
_squelch_unused_module_warning_ [No_polymorphic_compare] | `_squelch_unused_module_warning_` helps avoid spurious unused-`open` warnings in OCaml 4.0.
_squelch_unused_module_warning_ [Comparable_intf.S_common.Replace_polymorphic_compare] |
A
abs [Time_ns.Span] |
abs [Percent] |
abs [Int_math.T] |
abs [Int_intf.S.O] |
abs [Int_intf.S] | Returns the absolute value of the argument.
abs [Float_intf.S.O] |
abs [Float_intf.S] |
abs_diff [Time_ns] |
abs_float [Common] |
add [Univ_map_intf.S1] |
add [Univ_map_intf.S] |
add [Timing_wheel_intf.Timing_wheel.Priority_queue] | `add t ~key value` adds a new value to `t` and returns an element that can later be supplied to `remove` the element from `t`.
add [Timing_wheel_intf.Timing_wheel] | `add t ~at a` adds a new value `a` to `t` and returns an alarm that can later be supplied to `remove` the alarm from `t`.
add [Timing_wheel_intf.Interval_num] |
add [Timing_wheel_intf.Timing_wheel_time] |
add [Univ_map.Multi] |
add [Univ_map.With_fold] | fold value into accumulator
add [Time_ns] |
add [Int_set] | `add t i` add `i` to the set
add [Heap_intf.S] |
add [Hash_set_intf.Accessors] |
add [Float_intf.S] | Ordinary functions for arithmetic operations
add [Fheap] | `add t v` returns the new heap after addition.
add [Core_set_intf.Accessors2_with_comparator] |
add [Core_set_intf.Accessors2] |
add [Core_set_intf.Accessors1] |
add [Core_set_intf.Accessors0] |
add [Core_set_intf.Accessors_generic] |
add [Core_set] | `add t a` returns a new set with `a` added to `t`, or returns `t` if `mem t a`.
add [Core_map_intf.Accessors3_with_comparator] |
add [Core_map_intf.Accessors3] |
add [Core_map_intf.Accessors2] |
add [Core_map_intf.Accessors1] |
add [Core_map_intf.Accessors_generic] |
add [Core_map] | returns a new map with the specified new binding; if the key was already bound, its previous binding disappears.
add [Core_list.Assoc] |
add [Core_hashtbl_intf.Accessors] |
add [Bounded_int_table] |
add [Bag] | `add t v` adds `v` to the bag `t`, 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_at_interval_num [Timing_wheel_intf.Timing_wheel] |
add_buffer [Bigbuffer] | `add_buffer b1 b2` appends the current contents of buffer `b2` at the end of buffer `b1`.
add_char [Bigbuffer] | `add_char b c` appends the character `c` at the end of the buffer `b`.
add_exn [Univ_map_intf.S1] |
add_exn [Univ_map_intf.S] |
add_exn [Core_hashtbl_intf.Accessors] |
add_exn [Bounded_int_table] |
add_finalizer [Core_gc.Expert] | `add_finalizer b f` ensures that `f` runs after `b` becomes unreachable.
add_finalizer_exn [Core_gc.Expert] |
add_multi [Core_map_intf.Accessors3_with_comparator] |
add_multi [Core_map_intf.Accessors3] |
add_multi [Core_map_intf.Accessors2] |
add_multi [Core_map_intf.Accessors1] |
add_multi [Core_map_intf.Accessors_generic] |
add_multi [Core_map] | 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 ~data` if `key` is present in the table then cons `data` on the list, otherwise add `key` with a single element list.
add_or_error [Core_hashtbl_intf.Accessors] |
add_range [Int_set] | `add_range t i j` add all the numbers between `i` and `j` (inclusive) to the set.
add_removable [Heap.Removable] | `add_removable t v` adds `v` to `t`, returning a token that can be used to delete `v` from `t` in lg(n) amortized time.
add_string [Bigbuffer] | `add_string b s` appends the string `s` at the end of the buffer `b`.
add_substitute [Bigbuffer] | `add_substitute b f s` appends the string pattern `s` at the end of the buffer `b` with substitution.
add_substring [Bigbuffer] | `add_substring b s ofs len` takes `len` characters from offset `ofs` in string `s` and appends them at the end of the buffer `b`.
advance_clock [Timing_wheel_intf.Timing_wheel] | `advance_clock t ~to_ ~handle_fired` advances `t`'s clock to `to_`.
alarm_precision [Timing_wheel_intf.Timing_wheel.Config] | accessors
alarm_precision [Timing_wheel_intf.Timing_wheel] | Accessors
alarm_upper_bound [Timing_wheel_intf.Timing_wheel] | `alarm_upper_bound t` returns the upper bound on an `at` that can be supplied to `add`.
alist [Validate] | Validates an association list, naming each element using a user-defined function for computing the name.
all [Validate] | Combine a list of validation functions into one that does all validations.
all [Total_map.Key] |
all [Pretty_printer] | `all ()` returns all pretty printers that have been `register`ed.
all [Month] |
all [Monad_intf.S2] |
all [Monad_intf.S] |
all [Day_of_week] |
all [Applicative_intf.S2] |
all [Applicative_intf.S] |
all_ignore [Monad_intf.S2] |
all_ignore [Monad_intf.S] |
allocated_bytes [Core_gc] | Return the total number of bytes allocated since the program was started.
allocation_policy [Core_gc.Control.Fields] |
allocation_policy [Core_gc.Control] |
allow_intersecting [Flags_intf.Make_arg] | `allow_intersecting` says whether to allow intersecting `known` flags.
am_recording [Backtrace.Exn] |
and_ [Blang] | n-ary `And`
append [Sequence] | `append t1 t2` first produces the elements of `t1`, then produces the elements of `t2`.
append [Core_list] | E.g.
append [Core_array.Permissioned] |
append [Core_array] | `Array.append v1 v2` returns a fresh array containing the concatenation of the arrays `v1` and `v2`.
apply [Percent] | `apply t x` multiplies the percent `t` by `x`, returning a float
apply [Applicative_intf.S2] |
apply [Applicative_intf.Basic2] |
apply [Applicative_intf.S] |
apply [Applicative_intf.Basic] | The following identities ought to hold for every Applicative (for some value of =):
applyN [Applicative_intf.Args2] |
applyN [Applicative_intf.Args] |
apply_n_times [Fn] | `apply_n_times ~n f x` is the `n`-fold application of `f` to `x`.
are_disjoint [Flags_intf.S] |
array [Type_immediacy.Never] |
ascending [Polymorphic_compare] | `ascending` is identical to `compare`.
ascending [Comparable_intf.S_common] | `ascending` is identical to `compare`.
at [Timing_wheel_intf.Timing_wheel.Alarm] | All `Alarm` functions will raise if `not (Timing_wheel.mem timing_wheel t)`.
attempts_used [Raw_quickcheck_generator.Choice] | `attempts_used t` reports the number of attempts made to choose a value.
B
back_index [Deque] | `back_index t` return the index of the back item in `t`.
back_index_exn [Deque] | `back_index_exn t` throws an exception if `t` is empty, otherwise returns the index of the back item in `t`
backtrace [Exn] | The same as `Printexc.get_backtrace`
backtrace_status [Core_printexc] |
base [Substring_intf.S] | The pos refers to the position in the base string, not any other substring that this substring was generated from.
base [Make_substring.F] |
base [Blang] |
between [Comparable_intf.S_common] |
big [Binary_searchable_intf.Indexable.For_test] |
big_contents [Bigbuffer] | Return a copy of the current contents of the buffer as a bigstring.
bigstring_bigstring [Make_substring.Blit] |
bigstring_string [Make_substring.Blit] |
bin_decimal [Std_kernel] |
bin_immutable [Perms.Export] |
bin_me [Perms.Stable.V1] |
bin_me [Perms] |
bin_no_raise [Core_sexp] |
bin_nobody [Perms.Stable.V1] |
bin_nobody [Perms] |
bin_outer [Float_intf.S] |
bin_perms [Perms.Export] |
bin_read [Perms.Export] |
bin_read_decimal [Std_kernel] |
bin_read_immutable [Perms.Export] |
bin_read_me [Perms.Stable.V1] |
bin_read_me [Perms] |
bin_read_no_raise [Core_sexp] |
bin_read_nobody [Perms.Stable.V1] |
bin_read_nobody [Perms] |
bin_read_outer [Float_intf.S] |
bin_read_perms [Perms.Export] |
bin_read_read [Perms.Export] |
bin_read_read_write [Perms.Export] |
bin_read_sexp_array [Std_internal] |
bin_read_sexp_bool [Std_internal] |
bin_read_sexp_list [Std_internal] |
bin_read_sexp_list [Stable_internal] |
bin_read_sexp_opaque [Std_internal] |
bin_read_sexp_option [Std_internal] |
bin_read_sexp_option [Stable_internal] |
bin_read_t [Validated_intf.Raw_binable] |
bin_read_t [Timing_wheel_intf.Interval_num.Span] |
bin_read_t [Timing_wheel_intf.Interval_num] |
bin_read_t [T.T_bin] |
bin_read_t [Unique_id_intf.Id] |
bin_read_t [Total_map.Key] |
bin_read_t [Total_map.S] |
bin_read_t [String_id.S.Stable.V1] |
bin_read_t [Time_ns.Span] |
bin_read_t [Time_ns] |
bin_read_t [Stack_unit_tests.Test] |
bin_read_t [Stack_unit_tests.Debug] |
bin_read_t [Stack_intf.S] |
bin_read_t [Stable_unit_test_intf.Unordered_container_arg] |
bin_read_t [Stable_internal.Sexp] |
bin_read_t [Stable_containers.Hashable.V1.S.Hash_set] |
bin_read_t [Stable_containers.Hashable.V1.S.Table] |
bin_read_t [Source_code_position0.Stable.V1] |
bin_read_t [Source_code_position] |
bin_read_t [Set_once] |
bin_read_t [Stable_unit_test_intf.Arg] |
bin_read_t [Result] |
bin_read_t [Ref.Permissioned] |
bin_read_t [Ref] |
bin_read_t [Pool_intf.S.Pointer.Id] |
bin_read_t [Pid] |
bin_read_t [Perms.Stable.V1.Upper_bound] |
bin_read_t [Perms.Stable.V1.Read_write] |
bin_read_t [Perms.Stable.V1.Immutable] |
bin_read_t [Perms.Stable.V1.Write] |
bin_read_t [Perms.Stable.V1.Read] |
bin_read_t [Perms.Upper_bound] |
bin_read_t [Perms.Read_write] |
bin_read_t [Perms.Immutable] |
bin_read_t [Perms.Write] |
bin_read_t [Perms.Read] |
bin_read_t [Percent.Stable.V1] |
bin_read_t [Ordering] |
bin_read_t [Or_error] |
bin_read_t [Option] |
bin_read_t [Nothing0] |
bin_read_t [Nothing.Stable.V1] |
bin_read_t [Month.Stable.V1] |
bin_read_t [Month] |
bin_read_t [Linked_queue] |
bin_read_t [Stable_module_types.S2] |
bin_read_t [Int_intf.S] |
bin_read_t [Int_intf.Hexable.Hex] |
bin_read_t [Stable_module_types.S0] |
bin_read_t [Info] |
bin_read_t [Identifiable.S] |
bin_read_t [Host_and_port.Stable.V1] |
bin_read_t [Fqueue.Stable.V1] |
bin_read_t [Fqueue] |
bin_read_t [Float_intf.S.Terse] |
bin_read_t [Float_intf.S.Class] |
bin_read_t [Fdeque.Stable.V1] |
bin_read_t [Fdeque] |
bin_read_t [Either_intf.S] |
bin_read_t [Deque] |
bin_read_t [Decimal] |
bin_read_t [Day_of_week.Stable.V1] |
bin_read_t [Day_of_week] |
bin_read_t [Core_string] |
bin_read_t [Core_sexp.With_text] |
bin_read_t [Core_sexp.Sexp_maybe] |
bin_read_t [Core_sexp.Sexp_opaque] |
bin_read_t [Core_sexp.Sexp_array] |
bin_read_t [Core_sexp.Sexp_list] |
bin_read_t [Core_sexp.Sexp_option] |
bin_read_t [Core_sexp] |
bin_read_t [Core_set_intf.Elt_binable] |
bin_read_t [Core_set.Poly] |
bin_read_t [Core_queue] |
bin_read_t [Core_map_intf.Key_binable] |
bin_read_t [Core_map.Poly] |
bin_read_t [Core_list.Assoc] |
bin_read_t [Core_list] |
bin_read_t [Stable_module_types.S1] |
bin_read_t [Core_lazy] |
bin_read_t [Core_hashtbl_intf.Hashtbl.Poly] |
bin_read_t [Core_hashtbl_intf.Key_binable] |
bin_read_t [Core_gc.Control] |
bin_read_t [Core_gc.Stat] |
bin_read_t [Core_char] |
bin_read_t [Core_array.Permissioned.Float] |
bin_read_t [Core_array.Permissioned.Int] |
bin_read_t [Core_array.Permissioned] |
bin_read_t [Core_array.Float] |
bin_read_t [Core_array.Int] |
bin_read_t [Core_array] |
bin_read_t [Constrained_float.S] |
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_write [Perms.Export] |
bin_reader_decimal [Std_kernel] |
bin_reader_immutable [Perms.Export] |
bin_reader_me [Perms.Stable.V1] |
bin_reader_me [Perms] |
bin_reader_no_raise [Core_sexp] |
bin_reader_nobody [Perms.Stable.V1] |
bin_reader_nobody [Perms] |
bin_reader_outer [Float_intf.S] |
bin_reader_perms [Perms.Export] |
bin_reader_read [Perms.Export] |
bin_reader_read_write [Perms.Export] |
bin_reader_sexp_array [Std_internal] |
bin_reader_sexp_bool [Std_internal] |
bin_reader_sexp_list [Std_internal] |
bin_reader_sexp_list [Stable_internal] |
bin_reader_sexp_opaque [Std_internal] |
bin_reader_sexp_option [Std_internal] |
bin_reader_sexp_option [Stable_internal] |
bin_reader_t [Validated_intf.Raw_binable] |
bin_reader_t [Timing_wheel_intf.Interval_num.Span] |
bin_reader_t [Timing_wheel_intf.Interval_num] |
bin_reader_t [T.T_bin] |
bin_reader_t [Unique_id_intf.Id] |
bin_reader_t [Total_map.Key] |
bin_reader_t [Total_map.S] |
bin_reader_t [String_id.S.Stable.V1] |
bin_reader_t [Time_ns.Span] |
bin_reader_t [Time_ns] |
bin_reader_t [Stack_unit_tests.Test] |
bin_reader_t [Stack_unit_tests.Debug] |
bin_reader_t [Stack_intf.S] |
bin_reader_t [Stable_unit_test_intf.Unordered_container_arg] |
bin_reader_t [Stable_internal.Sexp] |
bin_reader_t [Stable_containers.Hashable.V1.S.Hash_set] |
bin_reader_t [Stable_containers.Hashable.V1.S.Table] |
bin_reader_t [Source_code_position0.Stable.V1] |
bin_reader_t [Source_code_position] |
bin_reader_t [Set_once] |
bin_reader_t [Stable_unit_test_intf.Arg] |
bin_reader_t [Result] |
bin_reader_t [Ref.Permissioned] |
bin_reader_t [Ref] |
bin_reader_t [Pool_intf.S.Pointer.Id] |
bin_reader_t [Pid] |
bin_reader_t [Perms.Stable.V1.Upper_bound] |
bin_reader_t [Perms.Stable.V1.Read_write] |
bin_reader_t [Perms.Stable.V1.Immutable] |
bin_reader_t [Perms.Stable.V1.Write] |
bin_reader_t [Perms.Stable.V1.Read] |
bin_reader_t [Perms.Upper_bound] |
bin_reader_t [Perms.Read_write] |
bin_reader_t [Perms.Immutable] |
bin_reader_t [Perms.Write] |
bin_reader_t [Perms.Read] |
bin_reader_t [Percent.Stable.V1] |
bin_reader_t [Ordering] |
bin_reader_t [Or_error] |
bin_reader_t [Option] |
bin_reader_t [Nothing0] |
bin_reader_t [Nothing.Stable.V1] |
bin_reader_t [Month.Stable.V1] |
bin_reader_t [Month] |
bin_reader_t [Linked_queue] |
bin_reader_t [Stable_module_types.S2] |
bin_reader_t [Int_intf.S] |
bin_reader_t [Int_intf.Hexable.Hex] |
bin_reader_t [Stable_module_types.S0] |
bin_reader_t [Info] |
bin_reader_t [Identifiable.S] |
bin_reader_t [Host_and_port.Stable.V1] |
bin_reader_t [Fqueue.Stable.V1] |
bin_reader_t [Fqueue] |
bin_reader_t [Float_intf.S.Terse] |
bin_reader_t [Float_intf.S.Class] |
bin_reader_t [Fdeque.Stable.V1] |
bin_reader_t [Fdeque] |
bin_reader_t [Either_intf.S] |
bin_reader_t [Deque] |
bin_reader_t [Decimal] |
bin_reader_t [Day_of_week.Stable.V1] |
bin_reader_t [Day_of_week] |
bin_reader_t [Core_string] |
bin_reader_t [Core_sexp.With_text] |
bin_reader_t [Core_sexp.Sexp_maybe] |
bin_reader_t [Core_sexp.Sexp_opaque] |
bin_reader_t [Core_sexp.Sexp_array] |
bin_reader_t [Core_sexp.Sexp_list] |
bin_reader_t [Core_sexp.Sexp_option] |
bin_reader_t [Core_sexp] |
bin_reader_t [Core_set_intf.Elt_binable] |
bin_reader_t [Core_set.Poly] |
bin_reader_t [Core_queue] |
bin_reader_t [Core_map_intf.Key_binable] |
bin_reader_t [Core_map.Poly] |
bin_reader_t [Core_list.Assoc] |
bin_reader_t [Core_list] |
bin_reader_t [Stable_module_types.S1] |
bin_reader_t [Core_lazy] |
bin_reader_t [Core_hashtbl_intf.Hashtbl.Poly] |
bin_reader_t [Core_hashtbl_intf.Key_binable] |
bin_reader_t [Core_gc.Control] |
bin_reader_t [Core_gc.Stat] |
bin_reader_t [Core_char] |
bin_reader_t [Core_array.Permissioned.Float] |
bin_reader_t [Core_array.Permissioned.Int] |
bin_reader_t [Core_array.Permissioned] |
bin_reader_t [Core_array.Float] |
bin_reader_t [Core_array.Int] |
bin_reader_t [Core_array] |
bin_reader_t [Constrained_float.S] |
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_sexp_array [Std_internal] |
bin_sexp_bool [Std_internal] |
bin_sexp_list [Std_internal] |
bin_sexp_list [Stable_internal] |
bin_sexp_opaque [Std_internal] |
bin_sexp_option [Std_internal] |
bin_sexp_option [Stable_internal] |
bin_size_decimal [Std_kernel] |
bin_size_immutable [Perms.Export] |
bin_size_me [Perms.Stable.V1] |
bin_size_me [Perms] |
bin_size_no_raise [Core_sexp] |
bin_size_nobody [Perms.Stable.V1] |
bin_size_nobody [Perms] |
bin_size_outer [Float_intf.S] |
bin_size_perms [Perms.Export] |
bin_size_read [Perms.Export] |
bin_size_read_write [Perms.Export] |
bin_size_sexp_array [Std_internal] |
bin_size_sexp_bool [Std_internal] |
bin_size_sexp_list [Std_internal] |
bin_size_sexp_list [Stable_internal] |
bin_size_sexp_opaque [Std_internal] |
bin_size_sexp_option [Std_internal] |
bin_size_sexp_option [Stable_internal] |
bin_size_t [Validated_intf.Raw_binable] |
bin_size_t [Timing_wheel_intf.Interval_num.Span] |
bin_size_t [Timing_wheel_intf.Interval_num] |
bin_size_t [T.T_bin] |
bin_size_t [Unique_id_intf.Id] |
bin_size_t [Total_map.Key] |
bin_size_t [Total_map.S] |
bin_size_t [String_id.S.Stable.V1] |
bin_size_t [Time_ns.Span] |
bin_size_t [Time_ns] |
bin_size_t [Stack_unit_tests.Test] |
bin_size_t [Stack_unit_tests.Debug] |
bin_size_t [Stack_intf.S] |
bin_size_t [Stable_unit_test_intf.Unordered_container_arg] |
bin_size_t [Stable_internal.Sexp] |
bin_size_t [Stable_containers.Hashable.V1.S.Hash_set] |
bin_size_t [Stable_containers.Hashable.V1.S.Table] |
bin_size_t [Source_code_position0.Stable.V1] |
bin_size_t [Source_code_position] |
bin_size_t [Set_once] |
bin_size_t [Stable_unit_test_intf.Arg] |
bin_size_t [Result] |
bin_size_t [Ref.Permissioned] |
bin_size_t [Ref] |
bin_size_t [Pool_intf.S.Pointer.Id] |
bin_size_t [Pid] |
bin_size_t [Perms.Stable.V1.Upper_bound] |
bin_size_t [Perms.Stable.V1.Read_write] |
bin_size_t [Perms.Stable.V1.Immutable] |
bin_size_t [Perms.Stable.V1.Write] |
bin_size_t [Perms.Stable.V1.Read] |
bin_size_t [Perms.Upper_bound] |
bin_size_t [Perms.Read_write] |
bin_size_t [Perms.Immutable] |
bin_size_t [Perms.Write] |
bin_size_t [Perms.Read] |
bin_size_t [Percent.Stable.V1] |
bin_size_t [Ordering] |
bin_size_t [Or_error] |
bin_size_t [Option] |
bin_size_t [Nothing0] |
bin_size_t [Nothing.Stable.V1] |
bin_size_t [Month.Stable.V1] |
bin_size_t [Month] |
bin_size_t [Linked_queue] |
bin_size_t [Stable_module_types.S2] |
bin_size_t [Int_intf.S] |
bin_size_t [Int_intf.Hexable.Hex] |
bin_size_t [Stable_module_types.S0] |
bin_size_t [Info] |
bin_size_t [Identifiable.S] |
bin_size_t [Host_and_port.Stable.V1] |
bin_size_t [Fqueue.Stable.V1] |
bin_size_t [Fqueue] |
bin_size_t [Float_intf.S.Terse] |
bin_size_t [Float_intf.S.Class] |
bin_size_t [Fdeque.Stable.V1] |
bin_size_t [Fdeque] |
bin_size_t [Either_intf.S] |
bin_size_t [Deque] |
bin_size_t [Decimal] |
bin_size_t [Day_of_week.Stable.V1] |
bin_size_t [Day_of_week] |
bin_size_t [Core_string] |
bin_size_t [Core_sexp.With_text] |
bin_size_t [Core_sexp.Sexp_maybe] |
bin_size_t [Core_sexp.Sexp_opaque] |
bin_size_t [Core_sexp.Sexp_array] |
bin_size_t [Core_sexp.Sexp_list] |
bin_size_t [Core_sexp.Sexp_option] |
bin_size_t [Core_sexp] |
bin_size_t [Core_set_intf.Elt_binable] |
bin_size_t [Core_set.Poly] |
bin_size_t [Core_queue] |
bin_size_t [Core_map_intf.Key_binable] |
bin_size_t [Core_map.Poly] |
bin_size_t [Core_list.Assoc] |
bin_size_t [Core_list] |
bin_size_t [Stable_module_types.S1] |
bin_size_t [Core_lazy] |
bin_size_t [Core_hashtbl_intf.Hashtbl.Poly] |
bin_size_t [Core_hashtbl_intf.Key_binable] |
bin_size_t [Core_gc.Control] |
bin_size_t [Core_gc.Stat] |
bin_size_t [Core_char] |
bin_size_t [Core_array.Permissioned.Float] |
bin_size_t [Core_array.Permissioned.Int] |
bin_size_t [Core_array.Permissioned] |
bin_size_t [Core_array.Float] |
bin_size_t [Core_array.Int] |
bin_size_t [Core_array] |
bin_size_t [Constrained_float.S] |
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_t [Validated_intf.Raw_binable] |
bin_t [Timing_wheel_intf.Interval_num.Span] |
bin_t [Timing_wheel_intf.Interval_num] |
bin_t [T.T_bin] |
bin_t [Unique_id_intf.Id] |
bin_t [Total_map.Key] |
bin_t [Total_map.S] |
bin_t [String_id.S.Stable.V1] |
bin_t [Time_ns.Span] |
bin_t [Time_ns] |
bin_t [Stack_unit_tests.Test] |
bin_t [Stack_unit_tests.Debug] |
bin_t [Stack_intf.S] |
bin_t [Stable_unit_test_intf.Unordered_container_arg] |
bin_t [Stable_internal.Sexp] |
bin_t [Stable_containers.Hashable.V1.S.Hash_set] |
bin_t [Stable_containers.Hashable.V1.S.Table] |
bin_t [Source_code_position0.Stable.V1] |
bin_t [Source_code_position] |
bin_t [Set_once] |
bin_t [Stable_unit_test_intf.Arg] |
bin_t [Result] |
bin_t [Ref.Permissioned] |
bin_t [Ref] |
bin_t [Pool_intf.S.Pointer.Id] |
bin_t [Pid] |
bin_t [Perms.Stable.V1.Upper_bound] |
bin_t [Perms.Stable.V1.Read_write] |
bin_t [Perms.Stable.V1.Immutable] |
bin_t [Perms.Stable.V1.Write] |
bin_t [Perms.Stable.V1.Read] |
bin_t [Perms.Upper_bound] |
bin_t [Perms.Read_write] |
bin_t [Perms.Immutable] |
bin_t [Perms.Write] |
bin_t [Perms.Read] |
bin_t [Percent.Stable.V1] |
bin_t [Ordering] |
bin_t [Or_error] |
bin_t [Option] |
bin_t [Nothing0] |
bin_t [Nothing.Stable.V1] |
bin_t [Month.Stable.V1] |
bin_t [Month] |
bin_t [Linked_queue] |
bin_t [Stable_module_types.S2] |
bin_t [Int_intf.S] |
bin_t [Int_intf.Hexable.Hex] |
bin_t [Stable_module_types.S0] |
bin_t [Info] |
bin_t [Identifiable.S] |
bin_t [Host_and_port.Stable.V1] |
bin_t [Fqueue.Stable.V1] |
bin_t [Fqueue] |
bin_t [Float_intf.S.Terse] |
bin_t [Float_intf.S.Class] |
bin_t [Fdeque.Stable.V1] |
bin_t [Fdeque] |
bin_t [Either_intf.S] |
bin_t [Deque] |
bin_t [Decimal] |
bin_t [Day_of_week.Stable.V1] |
bin_t [Day_of_week] |
bin_t [Core_string] |
bin_t [Core_sexp.With_text] |
bin_t [Core_sexp.Sexp_maybe] |
bin_t [Core_sexp.Sexp_opaque] |
bin_t [Core_sexp.Sexp_array] |
bin_t [Core_sexp.Sexp_list] |
bin_t [Core_sexp.Sexp_option] |
bin_t [Core_sexp] |
bin_t [Core_set_intf.Elt_binable] |
bin_t [Core_set.Poly] |
bin_t [Core_queue] |
bin_t [Core_map_intf.Key_binable] |
bin_t [Core_map.Poly] |
bin_t [Core_list.Assoc] |
bin_t [Core_list] |
bin_t [Stable_module_types.S1] |
bin_t [Core_lazy] |
bin_t [Core_hashtbl_intf.Hashtbl.Poly] |
bin_t [Core_hashtbl_intf.Key_binable] |
bin_t [Core_gc.Control] |
bin_t [Core_gc.Stat] |
bin_t [Core_char] |
bin_t [Core_array.Permissioned.Float] |
bin_t [Core_array.Permissioned.Int] |
bin_t [Core_array.Permissioned] |
bin_t [Core_array.Float] |
bin_t [Core_array.Int] |
bin_t [Core_array] |
bin_t [Constrained_float.S] |
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_write_decimal [Std_kernel] |
bin_write_immutable [Perms.Export] |
bin_write_me [Perms.Stable.V1] |
bin_write_me [Perms] |
bin_write_no_raise [Core_sexp] |
bin_write_nobody [Perms.Stable.V1] |
bin_write_nobody [Perms] |
bin_write_outer [Float_intf.S] |
bin_write_perms [Perms.Export] |
bin_write_read [Perms.Export] |
bin_write_read_write [Perms.Export] |
bin_write_sexp_array [Std_internal] |
bin_write_sexp_bool [Std_internal] |
bin_write_sexp_list [Std_internal] |
bin_write_sexp_list [Stable_internal] |
bin_write_sexp_opaque [Std_internal] |
bin_write_sexp_option [Std_internal] |
bin_write_sexp_option [Stable_internal] |
bin_write_t [Validated_intf.Raw_binable] |
bin_write_t [Timing_wheel_intf.Interval_num.Span] |
bin_write_t [Timing_wheel_intf.Interval_num] |
bin_write_t [T.T_bin] |
bin_write_t [Unique_id_intf.Id] |
bin_write_t [Total_map.Key] |
bin_write_t [Total_map.S] |
bin_write_t [String_id.S.Stable.V1] |
bin_write_t [Time_ns.Span] |
bin_write_t [Time_ns] |
bin_write_t [Stack_unit_tests.Test] |
bin_write_t [Stack_unit_tests.Debug] |
bin_write_t [Stack_intf.S] |
bin_write_t [Stable_unit_test_intf.Unordered_container_arg] |
bin_write_t [Stable_internal.Sexp] |
bin_write_t [Stable_containers.Hashable.V1.S.Hash_set] |
bin_write_t [Stable_containers.Hashable.V1.S.Table] |
bin_write_t [Source_code_position0.Stable.V1] |
bin_write_t [Source_code_position] |
bin_write_t [Set_once] |
bin_write_t [Stable_unit_test_intf.Arg] |
bin_write_t [Result] |
bin_write_t [Ref.Permissioned] |
bin_write_t [Ref] |
bin_write_t [Pool_intf.S.Pointer.Id] |
bin_write_t [Pid] |
bin_write_t [Perms.Stable.V1.Upper_bound] |
bin_write_t [Perms.Stable.V1.Read_write] |
bin_write_t [Perms.Stable.V1.Immutable] |
bin_write_t [Perms.Stable.V1.Write] |
bin_write_t [Perms.Stable.V1.Read] |
bin_write_t [Perms.Upper_bound] |
bin_write_t [Perms.Read_write] |
bin_write_t [Perms.Immutable] |
bin_write_t [Perms.Write] |
bin_write_t [Perms.Read] |
bin_write_t [Percent.Stable.V1] |
bin_write_t [Ordering] |
bin_write_t [Or_error] |
bin_write_t [Option] |
bin_write_t [Nothing0] |
bin_write_t [Nothing.Stable.V1] |
bin_write_t [Month.Stable.V1] |
bin_write_t [Month] |
bin_write_t [Linked_queue] |
bin_write_t [Stable_module_types.S2] |
bin_write_t [Int_intf.S] |
bin_write_t [Int_intf.Hexable.Hex] |
bin_write_t [Stable_module_types.S0] |
bin_write_t [Info] |
bin_write_t [Identifiable.S] |
bin_write_t [Host_and_port.Stable.V1] |
bin_write_t [Fqueue.Stable.V1] |
bin_write_t [Fqueue] |
bin_write_t [Float_intf.S.Terse] |
bin_write_t [Float_intf.S.Class] |
bin_write_t [Fdeque.Stable.V1] |
bin_write_t [Fdeque] |
bin_write_t [Either_intf.S] |
bin_write_t [Deque] |
bin_write_t [Decimal] |
bin_write_t [Day_of_week.Stable.V1] |
bin_write_t [Day_of_week] |
bin_write_t [Core_string] |
bin_write_t [Core_sexp.With_text] |
bin_write_t [Core_sexp.Sexp_maybe] |
bin_write_t [Core_sexp.Sexp_opaque] |
bin_write_t [Core_sexp.Sexp_array] |
bin_write_t [Core_sexp.Sexp_list] |
bin_write_t [Core_sexp.Sexp_option] |
bin_write_t [Core_sexp] |
bin_write_t [Core_set_intf.Elt_binable] |
bin_write_t [Core_set.Poly] |
bin_write_t [Core_queue] |
bin_write_t [Core_map_intf.Key_binable] |
bin_write_t [Core_map.Poly] |
bin_write_t [Core_list.Assoc] |
bin_write_t [Core_list] |
bin_write_t [Stable_module_types.S1] |
bin_write_t [Core_lazy] |
bin_write_t [Core_hashtbl_intf.Hashtbl.Poly] |
bin_write_t [Core_hashtbl_intf.Key_binable] |
bin_write_t [Core_gc.Control] |
bin_write_t [Core_gc.Stat] |
bin_write_t [Core_char] |
bin_write_t [Core_array.Permissioned.Float] |
bin_write_t [Core_array.Permissioned.Int] |
bin_write_t [Core_array.Permissioned] |
bin_write_t [Core_array.Float] |
bin_write_t [Core_array.Int] |
bin_write_t [Core_array] |
bin_write_t [Constrained_float.S] |
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_writer_decimal [Std_kernel] |
bin_writer_immutable [Perms.Export] |
bin_writer_me [Perms.Stable.V1] |
bin_writer_me [Perms] |
bin_writer_no_raise [Core_sexp] |
bin_writer_nobody [Perms.Stable.V1] |
bin_writer_nobody [Perms] |
bin_writer_outer [Float_intf.S] |
bin_writer_perms [Perms.Export] |
bin_writer_read [Perms.Export] |
bin_writer_read_write [Perms.Export] |
bin_writer_sexp_array [Std_internal] |
bin_writer_sexp_bool [Std_internal] |
bin_writer_sexp_list [Std_internal] |
bin_writer_sexp_list [Stable_internal] |
bin_writer_sexp_opaque [Std_internal] |
bin_writer_sexp_option [Std_internal] |
bin_writer_sexp_option [Stable_internal] |
bin_writer_t [Validated_intf.Raw_binable] |
bin_writer_t [Timing_wheel_intf.Interval_num.Span] |
bin_writer_t [Timing_wheel_intf.Interval_num] |
bin_writer_t [T.T_bin] |
bin_writer_t [Unique_id_intf.Id] |
bin_writer_t [Total_map.Key] |
bin_writer_t [Total_map.S] |
bin_writer_t [String_id.S.Stable.V1] |
bin_writer_t [Time_ns.Span] |
bin_writer_t [Time_ns] |
bin_writer_t [Stack_unit_tests.Test] |
bin_writer_t [Stack_unit_tests.Debug] |
bin_writer_t [Stack_intf.S] |
bin_writer_t [Stable_unit_test_intf.Unordered_container_arg] |
bin_writer_t [Stable_internal.Sexp] |
bin_writer_t [Stable_containers.Hashable.V1.S.Hash_set] |
bin_writer_t [Stable_containers.Hashable.V1.S.Table] |
bin_writer_t [Source_code_position0.Stable.V1] |
bin_writer_t [Source_code_position] |
bin_writer_t [Set_once] |
bin_writer_t [Stable_unit_test_intf.Arg] |
bin_writer_t [Result] |
bin_writer_t [Ref.Permissioned] |
bin_writer_t [Ref] |
bin_writer_t [Pool_intf.S.Pointer.Id] |
bin_writer_t [Pid] |
bin_writer_t [Perms.Stable.V1.Upper_bound] |
bin_writer_t [Perms.Stable.V1.Read_write] |
bin_writer_t [Perms.Stable.V1.Immutable] |
bin_writer_t [Perms.Stable.V1.Write] |
bin_writer_t [Perms.Stable.V1.Read] |
bin_writer_t [Perms.Upper_bound] |
bin_writer_t [Perms.Read_write] |
bin_writer_t [Perms.Immutable] |
bin_writer_t [Perms.Write] |
bin_writer_t [Perms.Read] |
bin_writer_t [Percent.Stable.V1] |
bin_writer_t [Ordering] |
bin_writer_t [Or_error] |
bin_writer_t [Option] |
bin_writer_t [Nothing0] |
bin_writer_t [Nothing.Stable.V1] |
bin_writer_t [Month.Stable.V1] |
bin_writer_t [Month] |
bin_writer_t [Linked_queue] |
bin_writer_t [Stable_module_types.S2] |
bin_writer_t [Int_intf.S] |
bin_writer_t [Int_intf.Hexable.Hex] |
bin_writer_t [Stable_module_types.S0] |
bin_writer_t [Info] |
bin_writer_t [Identifiable.S] |
bin_writer_t [Host_and_port.Stable.V1] |
bin_writer_t [Fqueue.Stable.V1] |
bin_writer_t [Fqueue] |
bin_writer_t [Float_intf.S.Terse] |
bin_writer_t [Float_intf.S.Class] |
bin_writer_t [Fdeque.Stable.V1] |
bin_writer_t [Fdeque] |
bin_writer_t [Either_intf.S] |
bin_writer_t [Deque] |
bin_writer_t [Decimal] |
bin_writer_t [Day_of_week.Stable.V1] |
bin_writer_t [Day_of_week] |
bin_writer_t [Core_string] |
bin_writer_t [Core_sexp.With_text] |
bin_writer_t [Core_sexp.Sexp_maybe] |
bin_writer_t [Core_sexp.Sexp_opaque] |
bin_writer_t [Core_sexp.Sexp_array] |
bin_writer_t [Core_sexp.Sexp_list] |
bin_writer_t [Core_sexp.Sexp_option] |
bin_writer_t [Core_sexp] |
bin_writer_t [Core_set_intf.Elt_binable] |
bin_writer_t [Core_set.Poly] |
bin_writer_t [Core_queue] |
bin_writer_t [Core_map_intf.Key_binable] |
bin_writer_t [Core_map.Poly] |
bin_writer_t [Core_list.Assoc] |
bin_writer_t [Core_list] |
bin_writer_t [Stable_module_types.S1] |
bin_writer_t [Core_lazy] |
bin_writer_t [Core_hashtbl_intf.Hashtbl.Poly] |
bin_writer_t [Core_hashtbl_intf.Key_binable] |
bin_writer_t [Core_gc.Control] |
bin_writer_t [Core_gc.Stat] |
bin_writer_t [Core_char] |
bin_writer_t [Core_array.Permissioned.Float] |
bin_writer_t [Core_array.Permissioned.Int] |
bin_writer_t [Core_array.Permissioned] |
bin_writer_t [Core_array.Float] |
bin_writer_t [Core_array.Int] |
bin_writer_t [Core_array] |
bin_writer_t [Constrained_float.S] |
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] | Note that the sexps are not directly inferred from the type above -- there are lots of fancy shortcuts.
bin_writer_t [Bigstring] |
binary_search [Binary_searchable_intf.S1_permissions] |
binary_search [Binary_searchable_intf.S1] |
binary_search [Binary_searchable_intf.S] | `binary_search ?pos ?len t ~compare which elt` takes `t` that is sorted in nondecreasing order according to `compare`, where `compare` and `elt` divide `t` into three (possibly empty) segments:
binary_search_segmented [Binary_searchable_intf.S1_permissions] |
binary_search_segmented [Binary_searchable_intf.S1] |
binary_search_segmented [Binary_searchable_intf.S] | `binary_search_segmented ?pos ?len t ~segment_of which` takes an `segment_of` function that divides `t` into two (possibly empty) segments:
bind [Raw_quickcheck_generator] | `bind t f` is a monadic bind that replaces each value `x` that has probability `p` in `t` with the probability distribution `f x` weighted proportionally by `p`.
bind [Monad_intf.S2] |
bind [Monad_intf.Basic2] |
bind [Monad_intf.S] | `bind t f` = `t >>= f`
bind [Monad_intf.Basic] |
bind_choice [Raw_quickcheck_generator] | `bind_choice t f` is like `bind t f`, except `f` is passed an `'a Choice.t` and can thus use subsets of `t` by using `Choice.gen` with the `~keep` option.
bit_and [Int_intf.S] |
bit_not [Int_intf.S] |
bit_or [Int_intf.S] |
bit_xor [Int_intf.S] |
bits [Core_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 [Core_random] | Return 30 random bits in a nonnegative integer.
bits_of_float [Core_int64] |
bits_of_float [Core_int32] |
blit [Make_substring.Base] |
blit [Flat_array_debug.Debug] |
blit [Blit_intf.S_distinct] |
blit [Blit_intf.S1_permissions] |
blit [Blit_intf.S1] |
blit [Blit_intf.S_permissions] |
blit [Blit_intf.S] |
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_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] |
blit_transfer [Core_queue] | Transfers up to `len` elements from the front of `src` to the end of `dst`, removing them from `src`.
blito [Flat_array_debug.Debug] |
blito [Blit_intf.S_distinct] |
blito [Blit_intf.S1_permissions] |
blito [Blit_intf.S1] |
blito [Blit_intf.S_permissions] |
blito [Blit_intf.S] |
bool [Type_immediacy.Always] |
bool [Quickcheck_observer] |
bool [Quickcheck_generator] |
bool [Core_random.State] |
bool [Core_random] | `Random.bool ()` returns `true` or `false` with probability 0.5 each.
booltest [Validate] | Create a validation function from a function that produces a bool
bot [Fqueue] | like `bot_exn`, but returns result optionally, without exception.
bot_exn [Fqueue] | returns the bottom (most-recently enqueued element).
both [Option] |
both [Applicative_intf.S2] |
both [Applicative_intf.S] |
bounded_length [Sequence] | `bounded_length ~at_most t` returns ``Is len` if `len = length t <= at_most`, and otherwise returns ``Greater`.
bprintf [Std_internal] |
bprintf [Core_printf] |
bprintf [Bigbuffer.Printf] |
bprintf [Bigbuffer.Format] |
branching_factor [Raw_quickcheck_observer] | `branching_factor t` produces the number of nodes in the decision tree of `t`, or one less than the number of buckets in `t`.
bytes [Heap_block] | `bytes t` returns the number of bytes on the heap taken by heap block `t`, including the header.
bytes [Byte_units] |
C
call [Option] | `call x f` run optional function on argument
capacity [Pool_intf.S] | `capacity` returns the maximum number of tuples that the pool can hold.
capacity [Flat_queue] | `capacity t` returns the length of the array backing `t`.
capacity [Core_stack] | `capacity t` returns the length of the array backing `t`.
capacity [Core_queue] | Returns the current length of the backing array.
capitalize [Core_string] |
cartesian_product [Sequence] | Returns a sequence with all possible pairs.
cartesian_product [Core_list] | Returns a list with all possible pairs -- if the input lists have length len1 and len2, the resulting list will have length len1*len2.
cartesian_product [Core_array.Permissioned] |
cartesian_product [Core_array] |
catch [Core_printexc] |
ceil [Common] |
ceil_pow2 [Int_pow2] |
ceil_pow2 [Core_int] | `ceil_pow2 x` returns the smallest power of 2 that is greater than or equal to `x`.
change [Univ_map_intf.S1] |
change [Univ_map_intf.S] |
change [Univ_map.Multi] |
change [Univ_map.With_fold] | accumulator update
change [Univ_map.With_default] |
change [Total_map] |
change [Core_map_intf.Accessors3_with_comparator] |
change [Core_map_intf.Accessors3] |
change [Core_map_intf.Accessors2] |
change [Core_map_intf.Accessors1] |
change [Core_map_intf.Accessors_generic] |
change [Core_map] | `change map key f` updates the given map by changing the value stored under `key` according to `f`.
change [Core_hashtbl_intf.Accessors] | `change t key f` updates the given table by changing the value stored under `key` according to `f`, just like `Map.change` (see that for example).
change_exn [Univ_map_intf.S1] |
change_exn [Univ_map_intf.S] |
change_key [Timing_wheel_intf.Timing_wheel.Priority_queue] | `change_key t elt ~key` changes the key of `elt` to `key`.
char [Type_immediacy.Always] |
char [Quickcheck_observer] |
char [Quickcheck_generator] |
char_alpha [Quickcheck_generator] |
char_alphanum [Quickcheck_generator] |
char_digit [Quickcheck_generator] |
char_lowercase [Quickcheck_generator] |
char_print [Quickcheck_generator] |
char_uppercase [Quickcheck_generator] |
char_whitespace [Quickcheck_generator] |
check_args [Bigstring] | `check_args ~loc ~pos ~len bstr` checks the position and length arguments `pos` and `len` for bigstrings `bstr`.
check_field [Invariant_intf.Invariant] | `check_field` is used when checking invariants using `Fields.iter`.
check_invariant [Pool_intf.Pool.Debug] |
check_invariant [Flat_queue_debug.Debug] |
check_invariant [Debug.Make] | Whether the invariants are called on each invocation
check_invariant [Core_queue_debug.Debug] |
check_pos_len_exn [Ordered_collection_common] | `check_pos_len_exn ~pos ~len ~length` raises unless `pos >= 0 && len >= 0 && pos + len <= length`.
choose [Raw_quickcheck_generator] | `choose t ~random_float_between_zero_and_one` makes a choice in `t` at random, using `random_float_between_zero_and_one` to produce random floats between 0.
choose [Core_set_intf.Accessors2_with_comparator] |
choose [Core_set_intf.Accessors2] |
choose [Core_set_intf.Accessors1] |
choose [Core_set_intf.Accessors0] |
choose [Core_set_intf.Accessors_generic] |
choose [Core_set] | returns an arbitrary element, or `None` if the set is empty.
choose [Bag] | `choose t` returns some element in the bag.
choose_exn [Core_set_intf.Accessors2_with_comparator] |
choose_exn [Core_set_intf.Accessors2] |
choose_exn [Core_set_intf.Accessors1] |
choose_exn [Core_set_intf.Accessors0] |
choose_exn [Core_set_intf.Accessors_generic] |
choose_exn [Core_set] |
chop_prefix [Core_string] |
chop_prefix_exn [Core_string] | `chop_prefix s ~pref` returns a copy `s` without the leading `pref`
chop_suffix [Core_string] |
chop_suffix_exn [Core_string] | `chop_suffix s ~suf` returns a copy `s` without the trailing `suff`
classify [Float_intf.S] | return the Class.t.
classify_float [Common] |
clear [Timing_wheel_intf.Timing_wheel.Priority_queue] | `clear t` removes all elts from `t`.
clear [Timing_wheel_intf.Timing_wheel] | `clear t` removes all alarms from `t`.
clear [Stack_unit_tests.Test] |
clear [Stack_unit_tests.Debug] |
clear [Stack_intf.S] | `clear t` discards all elements from `t`.
clear [Linked_queue] | `clear t` discards all elements from `t`.
clear [Hash_set_intf.Accessors] |
clear [Hash_queue.S] | clear the queue
clear [Hash_queue.Make] |
clear [Flat_queue] | `clear t` removes all elements from `t`.
clear [Doubly_linked] | `clear t` removes all elements from the list in constant time.
clear [Deque] | `clear t` removes all elements from `t`.
clear [Core_queue] |
clear [Core_hashtbl_intf.Accessors] |
clear [Bounded_int_table] |
clear [Bigbuffer] | Empty the buffer.
clear [Bag] | `clear t` removes all elements from the bag.
clear_internal_pool [Thread_safe_queue] | The queue maintains an internal pool of unused elements, which are used by `enqueue` and returned to the pool by `dequeue_exn`.
close [Out_channel] | `close t` flushes and closes `t`, and may raise an exception.
close [In_channel] | `close t` closes t, and may raise an exception.
close_in [Common] | we have our own version of these two, the INRIA version doesn't release the runtime lock.
close_out [Common] |
closest_key [Core_map_intf.Accessors3_with_comparator] |
closest_key [Core_map_intf.Accessors3] |
closest_key [Core_map_intf.Accessors2] |
closest_key [Core_map_intf.Accessors1] |
closest_key [Core_map_intf.Accessors_generic] |
closest_key [Core_map] | `closest_key t dir k` returns the `(key, value)` pair in `t` with `key` closest to `k`, which satisfies the given inequality bound.
combine [Result] | Returns `Ok` if both are `Ok` and `Error` otherwise.
combine [Either_intf.Focused] |
combine [Core_array.Permissioned] |
combine [Core_array] | `combine ar` combines two arrays to an array of pairs.
combine_all [Either_intf.Focused] |
combine_all_unit [Either_intf.Focused] |
combine_errors [Or_error] | `combine_errors ts` returns `Ok` if every element in `ts` is `Ok`, else it returns `Error` with all the errors in `ts`.
combine_errors_unit [Or_error] | `combine_errors_unit` returns `Ok` if every element in `ts` is `Ok ()`, else it returns `Error` with all the errors in `ts`, like `combine_errors`.
compact [Core_gc] | Perform a full major collection and compact the heap.
compactions [Core_gc.Stat.Fields] |
compactions [Core_gc.Stat] |
compactions [Core_gc] |
comparator [Core_set] |
comparator [Core_map] |
comparator [Comparator.S] |
comparator [Comparator.S1] |
compare [Timing_wheel_intf.Interval_num.Span] |
compare [Timing_wheel_intf.Interval_num] |
compare [Timing_wheel_intf.Timing_wheel_time.Span] |
compare [Timing_wheel_intf.Timing_wheel_time] |
compare [Tuple.T3] |
compare [Tuple.T2] |
compare [Total_map.Key] |
compare [Total_map.S] |
compare [String_id.S.Stable.V1] |
compare [Time_ns.Span] |
compare [Time_ns] |
compare [Stable_internal.Sexp] |
compare [Source_code_position0.Stable.V1] |
compare [Sequence] |
compare [Result] |
compare [Ref] |
compare [Polymorphic_compare] |
compare [Perms.Stable.V1.Upper_bound] |
compare [Perms.Stable.V1.Read_write] |
compare [Perms.Stable.V1.Immutable] |
compare [Perms.Stable.V1.Write] |
compare [Perms.Stable.V1.Read] |
compare [Perms.Upper_bound] |
compare [Perms.Read_write] |
compare [Perms.Immutable] |
compare [Perms.Write] |
compare [Perms.Read] |
compare [Percent.Stable.V1] |
compare [Ordering] |
compare [Or_error] |
compare [Option] | Compares `None` as smaller than any `Some x`
compare [Nothing0] |
compare [Nothing.Stable.V1] |
compare [No_polymorphic_compare] |
compare [Month.Stable.V1] |
compare [Stable_module_types.S2] |
compare [Int_intf.Hexable.Hex] |
compare [Stable_module_types.S0] |
compare [Info] |
compare [Host_and_port.Stable.V1] |
compare [Hashable.S] |
compare [Fqueue.Stable.V1] |
compare [Fqueue] |
compare [Fdeque.Stable.V1] |
compare [Fdeque] |
compare [Either_intf.S] |
compare [Decimal] |
compare [Day_of_week.Stable.V1] |
compare [Day_of_week] |
compare [Core_sexp.Sexp_maybe] |
compare [Core_sexp.Sexp_opaque] |
compare [Core_sexp.Sexp_array] |
compare [Core_sexp.Sexp_list] |
compare [Core_sexp.Sexp_option] |
compare [Core_set_intf.S0.Tree] |
compare [Core_set_intf.S0] |
compare [Core_set_intf.Elt_binable] |
compare [Core_set_intf.Elt] |
compare [Core_set.Poly] |
compare [Core_set] |
compare [Core_queue] |
compare [Core_map_intf.S] |
compare [Core_map_intf.Key_binable] |
compare [Core_map_intf.Key] |
compare [Core_map.Poly] |
compare [Core_list.Assoc] |
compare [Core_list] |
compare [Stable_module_types.S1] |
compare [Core_lazy] |
compare [Core_hashtbl_intf.Key] |
compare [Core_array.Permissioned.Float] |
compare [Core_array.Permissioned.Int] |
compare [Core_array.Permissioned] |
compare [Core_array.Float] |
compare [Core_array.Int] |
compare [Core_array] |
compare [Polymorphic_compare_intf.S] |
compare [Blang.Stable.V1] |
compare [Blang] |
compare [Bigstring] |
compare_decimal [Std_kernel] |
compare_direct [Core_set_intf.Accessors2_with_comparator] |
compare_direct [Core_set_intf.Accessors2] |
compare_direct [Core_set_intf.Accessors1] |
compare_direct [Core_set_intf.Accessors0] |
compare_direct [Core_set_intf.Accessors_generic] |
compare_direct [Core_set] | `compare_direct t1 t2` compares the sets `t1` and `t2`.
compare_direct [Core_map_intf.Accessors3_with_comparator] |
compare_direct [Core_map_intf.Accessors3] |
compare_direct [Core_map_intf.Accessors2] |
compare_direct [Core_map_intf.Accessors1] |
compare_direct [Core_map_intf.Accessors_generic] |
compare_direct [Core_map] | Total ordering between maps.
compare_fn [Quickcheck_generator] | Generator for comparison functions; result is guaranteed to be a partial order.
compare_fn_with_sexp [Quickcheck_generator] |
compare_immutable [Perms.Export] |
compare_me [Perms.Stable.V1] |
compare_me [Perms] |
compare_nobody [Perms.Stable.V1] |
compare_nobody [Perms] |
compare_perms [Perms.Export] |
compare_read [Perms.Export] |
compare_read_write [Perms.Export] |
compare_sexp_array [Std_internal] |
compare_sexp_bool [Std_internal] |
compare_sexp_list [Std_internal] |
compare_sexp_list [Stable_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.Stable.V1] |
compare_t [Nothing0] |
compare_write [Perms.Export] |
comparison [Quickcheck_observer] | `comparison ~compare ~eq ~lt ~gt` combines observers `lt` and `gt`, where `lt` observes values less than `eq` according to `compare`, and `gt` observes values greater than `eq` according to `compare`.
complement [Flags_intf.S] | bitwise not
compose [Fn] | `compose f g x` is `f (g x)`
concat [Sequence] | `concat tt` produces the elements of each inner sequence sequentially.
concat [Substring_intf.S] |
concat [Make_substring.F] |
concat [Core_string] | concatanate all strings in the list using separator `sep` (default sep "")
concat [Core_list] | Concatenate a list of lists.
concat [Core_array.Permissioned] |
concat [Core_array] | Same as `Array.append`, but concatenates a list of arrays.
concat_array [Core_string] | `concat_array sep ar` like `String.concat`, but operates on arrays
concat_bigstring [Substring_intf.S] |
concat_bigstring [Make_substring.F] |
concat_map [Sequence] | `concat_map t ~f` is `concat (map t ~f)`.
concat_map [Linked_queue] |
concat_map [Core_string] | Like `map`, but allows replacement of a single character with zero or two or more characters.
concat_map [Core_queue] | creates a new queue with elements equal to `List.concat_map ~f (to_list t)`.
concat_map [Core_list] | `concat_map t ~f` is `concat (map t ~f)`, except that there is no guarantee about the order in which `f` is applied to the elements of `t`.
concat_map [Core_array.Permissioned] |
concat_map [Core_array] | same as `List.concat_map`
concat_mapi [Sequence] | `concat_mapi t ~f` is like concat_map, but passes the index as an argument.
concat_mapi [Core_list] | `concat_mapi t ~f` is like concat_map, but passes the index as an argument
concat_no_order [Core_list] | Same as `concat` but 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] |
cons [Core_list] |
cons [Applicative_intf.Args2] |
cons [Applicative_intf.Args] | prepend an argument
const [Fn] | produces a function that just returns its first argument
const [Common] |
constant [Blang] | `function true -> true_ | false -> false_`
constant_value [Blang] | `constant_value t = Some b` iff `t = constant b`
contains [Core_string] |
contains_dup [Core_list] | `contains_dup` True if there are any two elements in the list which are the same.
contents [Bigbuffer] | Return a copy of the current contents of the buffer.
conv [Type_equal] | `conv t x` uses the type equality `t : (a, b) t` as evidence to safely cast `x` from type `a` to type `b`.
copy [Stack_unit_tests.Test] |
copy [Stack_unit_tests.Debug] |
copy [Stack_intf.S] | `copy t` returns a copy of `t`.
copy [Obj_array] | `copy t` returns a new array with the same elements as `t`.
copy [Linked_queue] | `copy t` returns a copy of `t`.
copy [Heap_intf.S] | `copy t` returns a shallow copy
copy [Hash_set_intf.Accessors] | preserves the equality function
copy [Hash_heap.S] |
copy [Hash_heap.Make] |
copy [Flat_array_debug.Debug] |
copy [Flat_array] | `copy a` returns a shallow copy of `a`, that is, a fresh array containing the same elements as `a`.
copy [Doubly_linked] |
copy [Core_string] |
copy [Core_queue] |
copy [Core_hashtbl_intf.Accessors] |
copy [Core_array.Permissioned] |
copy [Core_array] | `Array.copy a` returns a copy of `a`, that is, a fresh array containing the same elements as `a`.
copy [Core_random.State] |
count [Stack_unit_tests.Debug] |
count [Hash_queue.Make] |
count [Core_set] | `count t` returns the number of elements of `t` for which `f` returns `true`.
count [Core_list] | `count l ~f` is the number of elements in `l` that satisfy the predicate `f`.
count [Container_unit_tests.Test_generic] |
count [Container_intf.Container] |
count [Container_intf.Generic_phantom] |
count [Container_intf.Generic] |
count [Container_intf.S1_permissions] | Returns the number of elements for which the provided function evaluates to true.
count [Container_intf.S1_phantom_invariant] | Returns the number of elements for which the provided function evaluates to true.
count [Container_intf.S1] | Returns the number of elements for which the provided function evaluates to true.
count [Container_intf.S0_phantom] | Returns the number of elements for which the provided function evaluates to true.
count [Container_intf.S0] | Returns the number of elements for which the provided function evaluates to true.
count [Caml_modify] | `count ()` returns the number of times `caml_modify` has been called since the last call to `Caml_modify.reset`.
counters [Core_gc] | Return `(minor_words, promoted_words, major_words)`.
create [Validated_intf.Validated] |
create [Timing_wheel_intf.Timing_wheel.Priority_queue] | `create ?level_bits ()` creates a new empty timing wheel, `t`, with `length t = 0` and `min_allowed_key t = 0`.
create [Timing_wheel_intf.Timing_wheel.Config] | `create` raises if `alarm_precision <= 0`.
create [Timing_wheel_intf.Timing_wheel] | `create ~config ~start` creates a new timing wheel with current time `start`.
create [Unpack_buffer] |
create [Univ_map.Multi.Key] |
create [Univ_map.With_fold.Key] |
create [Univ_map.With_default.Key] |
create [Univ] |
create [Unique_id_intf.Id] | Always returns a value that is not equal to any other value created with `create`.
create [Union_find] | `create v` returns a new object in its own equivalence class that has value `v`.
create [Type_equal.Id] | `create ~name` defines a new type identity.
create [Tuple.T3] |
create [Tuple.T2] |
create [Total_map.S] |
create [Thread_safe_queue] | `create ()` returns an empty queue.
create [Time_ns.Span] |
create [Stack_unit_tests.Test] |
create [Stack_unit_tests.Debug] |
create [Stack_intf.S] | `create ()` returns an empty stack.
create [Set_once] |
create [Ref.Permissioned] |
create [Ref] |
create [Pool_intf.Pool.Unsafe] | `create slots ~capacity` creates an empty pool that can hold up to `capacity` N-tuples.
create [Pool_intf.S] | `create slots ~capacity ~dummy` creates an empty pool that can hold up to `capacity` N-tuples.
create [Out_channel] |
create [Obj_array] | `create ~len` returns an obj-array of length `len`, all of whose indices have value `Obj.repr 0`.
create [Substring_intf.S] | `create ?pos ?len base` creates a substring of the base sequence of length `len` starting at position `pos`, i.e.
create [Make_substring.Base] |
create [Make_substring.F] |
create [Linked_queue] | `create ()` returns an empty queue.
create [Info] | For `create message a sexp_of_a`, `sexp_of_a a` is lazily computed, when the info is converted to a sexp.
create [In_channel] |
create [Host_and_port] |
create [Heap_intf.S] | `create ?min_size ~cmp` returns a new min-heap that can store `min_size` elements without reallocations, using ordering function `cmp`.
create [Heap_block] | `create v` returns `Some t` if `v` is a heap block, where `t` is physically equal to `v`
create [Hash_set_intf.Creators] |
create [Hash_queue.S] | `create ()` returns an empty queue.
create [Hash_queue.Make] |
create [Hash_heap.S] |
create [Hash_heap.Make] |
create [Force_once] | `create f` creates a new force_once
create [Flat_queue] | `create ?capacity slots` creates an empty queue with capacity at least the supplied `capacity`.
create [Flat_array_debug.Debug] |
create [Flat_array] | `create slots ~len init` creates an array of flat tuples, whose slots are initialized to the slots of `init`, which is an ordinary OCaml tuple.
create [Flags_intf.Flags] | `create ~bit:n` creates a flag with the `n`th bit set.
create [Fheap] | `create ~cmp` returns a new min-heap that uses ordering function `cmp`.
create [Doubly_linked] | creating doubly-linked lists
create [Deque] | `create ?initial_length ?never_shrink ()` create a new `t`.
create [Core_weak] |
create [Core_string.Search_pattern] | `create pattern` preprocesses `pattern` as per KMP, building an `int array` of length `length pattern`.
create [Core_string] |
create [Core_queue] | Create an empty queue.
create [Core_hashtbl_intf.Creators] |
create [Core_gc.Expert.Alarm] | `create f` arranges for `f` to be called at the end of each major GC cycle, starting with the current cycle or the next one.
create [Core_gc.Control.Fields] |
create [Core_gc.Stat.Fields] |
create [Core_bytes] |
create [Core_array.Permissioned] |
create [Core_array] | `create ~len x` creates an array of length `len` with the value `x` populated in each element
create [Byte_units] | `create measure value` creates a `t` from `value` units of the given measure.
create [Bucket.S] |
create [Bucket.Make] |
create [Bounded_int_table.With_key] |
create [Bounded_int_table] | `create ~num_keys ~key_to_int` returns a table where the keys can map to 0 ..
create [Blit_intf.Sequence] |
create [Bigstring] | `create length`
create [Bigbuffer] | `create n` returns a fresh buffer, initially empty.
create [Bag] | `create ()` returns an empty bag.
create_bigstring [Binable0] |
create_bin_prot [Unpack_buffer.Unpack_one] | `create_bin_prot reader` returns 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 reader` returns 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_exn [Validated_intf.Validated] |
create_exn [Timing_wheel_intf.Timing_wheel.Level_bits] | In `create_exn bits`, it is an error if any of the `b_i` in `bits` has `b_i <= 0`, or if the sum of the `b_i` in `bits` is greater than `max_num_bits`.
create_exn [Heap_block] |
create_ieee [Float_intf.S] | These functions construct and destruct 64-bit floating point numbers based on their IEEE representation with sign bit, 11-bit non-negative (biased) exponent, and 52-bit non-negative mantissa (or significand).
create_ieee_exn [Float_intf.S] |

create_mapped [Core_hashtbl_intf.Creators]

     create_mapped get_key get_data [x1,...,xn]
             = of_alist [get_key x1, get_data x1; ...; get_key xn, get_data xn]

create_unit [Timing_wheel_unit_tests.Make] | `create_unit` is exposed for use in additional unit tests.

create_with_key [Core_hashtbl_intf.Creators]

     create_with_key ~get_key [x1,...,xn]
             = of_alist [get_key x1, x1; ...; get_key xn, xn]

create_with_key_exn [Core_hashtbl_intf.Creators] |
create_with_key_or_error [Core_hashtbl_intf.Creators] |
createf [Info] | Construct a `t` containing only a string from a format.
curry [Tuple.T3] |
curry [Tuple.T2] |
cycle_list_exn [Sequence] | `cycle_list_exn xs` repeats the elements of `xs` forever.
D
data [Core_map_intf.Accessors3_with_comparator] |
data [Core_map_intf.Accessors3] |
data [Core_map_intf.Accessors2] |
data [Core_map_intf.Accessors1] |
data [Core_map_intf.Accessors_generic] |
data [Core_map] | returns list of data in map
data [Core_hashtbl_intf.Accessors] | `filter_inplace t ~f` removes all the elements from `t` that don't satisfy `f`.
data [Bounded_int_table] |
day [Time_ns.Span] |
debug [Unpack_buffer] | `debug` controls whether invariants are checked at each call.
debug [Flat_array_debug.Debug] |
debug [Debug.Make] | We avoid labels so that the applications are more concise -- see example above
debug [Bounded_int_table] | set `debug := true` to turn on debugging, including potentially slow invariant checking.
debug_get [Flat_array_debug.Debug] |
debug_set [Flat_array_debug.Debug] |
decimal_of_sexp [Std_kernel] |
decr [Int_intf.S] |
dedup [Core_list] | `dedup` (de-duplicate).
default [Timing_wheel_intf.Timing_wheel.Config] | `default` is `create ()`.
default [Timing_wheel_intf.Timing_wheel.Level_bits] | `default` returns the default value of `level_bits` used by `Timing_wheel.create` and `Timing_wheel.Priority_queue.create`.
default [Core_random.State] |
default_attempts_per_trial [Quickcheck_intf.Quickcheck_config] | `default_attempts_per_trial` determines the maximum number of attempts to generate inputs for trials, as a multiplier for the number of trials, except in tests that explicitly override it.
default_seed [Quickcheck_intf.Quickcheck_config] | `default_seed` is used initialize the pseudo-random generator that chooses random values from generators, in each test that is not provided its own seed.
default_trial_count [Quickcheck_intf.Quickcheck_config] | `default_trial_count` determines the number of trials per test, except in tests that explicitly override it.
default_trial_count_for_test_no_duplicates [Quickcheck_intf.Quickcheck_config] | `default_trial_count_for_test_no_duplicates` determines the number of trials when running `test_no_duplicates` without `~trials`, either as a constant or as a factor of `default_trial_count`.
delayed_fold [Sequence] | `delayed_fold` allows to do an on-demand fold, while maintaining a state.
delete [Core_gc.Expert.Alarm] | `delete t` will stop the calls to the function associated to `t`.
dequeue [Linked_queue] | `dequeue t` returns `None` if `t` is empty, otherwise it removes and returns the front of `t`
dequeue [Hash_queue.S] | `dequeue t` returns the front element of the queue.
dequeue [Hash_queue.Make] |
dequeue [Fqueue] | Like `dequeue_exn`, but returns result optionally, without exception.
dequeue [Fdeque] | `dequeue t side` produces `Option.both (peek t side) (drop t side)`.
dequeue [Deque] | `dequeue t back_or_front` remove and return the `back_or_front` of `t`
dequeue [Core_queue] |
dequeue_all [Hash_queue.S] | `dequeue_all t ~f` dequeues every element of the queue and applies f to each one.
dequeue_all [Hash_queue.Make] |
dequeue_back [Fdeque] |
dequeue_back [Deque] |
dequeue_back_exn [Fdeque] |
dequeue_back_exn [Deque] |
dequeue_exn [Thread_safe_queue] | `dequeue_exn t` raises if `length t = 0`.
dequeue_exn [Linked_queue] |
dequeue_exn [Hash_queue.S] |
dequeue_exn [Hash_queue.Make] |
dequeue_exn [Fqueue] | `dequeue_exn t` removes and returns the front of `t`, raising `Empty` if `t` is empty.
dequeue_exn [Fdeque] |
dequeue_exn [Deque] |
dequeue_exn [Core_queue] |
dequeue_front [Fdeque] |
dequeue_front [Deque] |
dequeue_front_exn [Fdeque] |
dequeue_front_exn [Deque] |
dequeue_with_key [Hash_queue.S] | `dequeue_with_key t` returns 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 [Polymorphic_compare] |
descending [Comparable_intf.S_common] |
dest [Type_immediacy] |
detuple2 [Type_equal] | `tuple2` and `detuple2` convert between equality on a 2-tuple and its components.
diff [Timing_wheel_intf.Interval_num] |
diff [Time_ns] |
diff [Hash_set_intf.Accessors] |
diff [Core_set_intf.Accessors2_with_comparator] |
diff [Core_set_intf.Accessors2] |
diff [Core_set_intf.Accessors1] |
diff [Core_set_intf.Accessors0] |
diff [Core_set_intf.Accessors_generic] |
diff [Core_set] | `diff t1 t2` computes the set difference `t1 - t2`, i.e., the set containing all elements in `t1` that are not in `t2`.
disable_compaction [Core_gc] |
discard_exn [Fqueue] | Returns version of queue with top element removed.
div [Time_ns.Span] |
do_intersect [Flags_intf.S] |
does_match [Univ] | `does_match t id` returns `true` iff `t` was created by `create id v`.
does_raise [Std_kernel] |
does_raise [Exn] | `does_raise f` returns `true` iff `f ()` raises, which is often useful in unit tests.
doubleton [Quickcheck_observer] | `doubleton f ~f_sexp` maps values to two "buckets" (as described in `t` above), depending on whether they satisfy `f`.
doubleton [Quickcheck_generator] |
drop [Sequence] | `drop t n` produces all elements of `t` except the first `n` elements.
drop [Fdeque] | `drop t side` produces `Some` of `t` with the element at its `side` removed, or `None` if `t` is empty.
drop [Deque] | `drop ?n t back_or_front` drop `n` elements (default 1) from the `back_or_front` of `t`.
drop [Core_list] |
drop_back [Fdeque] |
drop_back [Deque] |
drop_back_exn [Fdeque] |
drop_eagerly [Sequence] | `drop_eagerly t n` immediately consumes the first `n` elements of `t` and returns the unevaluated tail of `t`.
drop_exn [Fdeque] |
drop_front [Flat_queue] | `drop_front ?n t` drops the the first `n` elements of `t`.
drop_front [Fdeque] |
drop_front [Deque] |
drop_front_exn [Fdeque] |
drop_prefix [Substring_intf.S] |
drop_prefix [Make_substring.F] |
drop_prefix [Core_string] | `drop_prefix s n` drops the longest prefix of `s` of length less than or equal to `n`
drop_suffix [Substring_intf.S] |
drop_suffix [Make_substring.F] |
drop_suffix [Core_string] | `drop_suffix s n` drops the longest suffix of `s` of length less than or equal to `n`
drop_while [Sequence] | `drop_while t ~f` produces the suffix of `t` beginning with the first element of `t` for which `f` is `false`.
drop_while [Core_list] | `drop_while l ~f` drops the longest prefix of `l` for which `f` is `true`.
drop_while_option [Sequence] | `drop_while_option t ~f` immediately consumes the elements from `t` until the predicate `f` fails and returns the first element that failed along with the unevaluated tail of `t`.
durations [Timing_wheel_intf.Timing_wheel.Config] | `durations t` returns the durations of the levels in `t`
E
either [Quickcheck_observer] |
either [Quickcheck_generator] |
elements [Core_set_intf.Accessors2_with_comparator] |
elements [Core_set_intf.Accessors2] |
elements [Core_set_intf.Accessors1] |
elements [Core_set_intf.Accessors0] |
elements [Core_set_intf.Accessors_generic] |
elements [Core_set] | Same as `Core_set.to_list`.
elts [Bag] |
empty [Univ_map_intf.S1] |
empty [Univ_map_intf.S] |
empty [Sequence] | `empty` is a sequence with no elements.
empty [Obj_array] |
empty [Int_set] |
empty [Fqueue] | The empty queue
empty [Flags_intf.S] |
empty [Fdeque] | The empty deque.
empty [Core_set_intf.Creators2_with_comparator] |
empty [Core_set_intf.Creators2] |
empty [Core_set_intf.Creators1] |
empty [Core_set_intf.Creators0] |
empty [Core_set_intf.Creators_generic] |
empty [Core_set] | Creates an empty set based on the provided comparator.
empty [Core_map_intf.Creators3_with_comparator] |
empty [Core_map_intf.Creators2] |
empty [Core_map_intf.Creators1] |
empty [Core_map_intf.Creators_generic] |
empty [Core_map] | the empty map
empty [Core_array.Permissioned] |
empty [Core_array] | `empty ()` creates an empty array
empty [Avltree] |
enqueue [Thread_safe_queue] |
enqueue [Linked_queue] | `enqueue t x` adds `x` to the end of `t`.
enqueue [Hash_queue.S] | `enqueue t k v` adds 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 x` returns a queue with adds `x` to the end of `t`.
enqueue [Fdeque] | `enqueue t side x` produces `t` updated with `x` added to its `side`.
enqueue [Deque] | `enqueue t back_or_front v` push `v` onto the `back_or_front` of `t`.
enqueue [Core_queue] |
enqueue1 [Flat_queue] | There is an `enqueueN` function for each possible arity of a flat queue.
enqueue2 [Flat_queue] |
enqueue3 [Flat_queue] |
enqueue4 [Flat_queue] |
enqueue5 [Flat_queue] |
enqueue6 [Flat_queue] |
enqueue7 [Flat_queue] |
enqueue8 [Flat_queue] |
enqueue9 [Flat_queue] |
enqueue_back [Fdeque] |
enqueue_back [Deque] |
enqueue_exn [Hash_queue.S] |
enqueue_exn [Hash_queue.Make] |
enqueue_front [Fdeque] |
enqueue_front [Deque] |
enqueue_top [Fqueue] | enqueue a single element on the *top* of the queue.
enum [Quickcheck_observer] | `enum n ~f` maps values to `n` buckets, where `f` produces the index for a bucket from `0` to `n-1` for each value.
epoch [Timing_wheel_intf.Timing_wheel_time] |
epoch [Time_ns] | Unix epoch (1970-01-01 00:00:00 UTC)
eprint [Debug] | `eprint message` prints to stderr `message`, followed by a newline and flush.
eprintf [Std_internal] |
eprintf [Debug] | `eprintf message arg1 ... argn` prints to stderr `message`, with sprintf-style format characters instantiated, followed by a newline and flush.
eprintf [Core_printf] |
eprints [Debug] | `eprints message a sexp_of_a` prints to stderr `message` and `a` as a sexp, followed by a newline and flush.
epsilon_float [Float_intf.S] | The difference between 1.0 and the smallest exactly representable floating-point number greater than 1.0.
epsilon_float [Common] |
equal [Tuple.T3] |
equal [Tuple.T2] |
equal [Stable_unit_test_intf.Unordered_container_arg] |
equal [Stable_unit_test_intf.Arg] | `tests` is a list of (value, sexp-representation, bin-io-representation) triples.
equal [Polymorphic_compare] |
equal [Option] |
equal [No_polymorphic_compare] |
equal [Hash_set_intf.Accessors] |
equal [Tuple_type_intf.Slot] |
equal [Equal.S3] |
equal [Equal.S2] |
equal [Equal.S1] |
equal [Equal.S] |
equal [Either_intf.S] |
equal [Doubly_linked.Elt] | pointer equality
equal [Doubly_linked] | predicates
equal [Core_string] | fast equality function on strings, doesn't use compare_val
equal [Core_set_intf.Accessors2_with_comparator] |
equal [Core_set_intf.Accessors2] |
equal [Core_set_intf.Accessors1] |
equal [Core_set_intf.Accessors0] |
equal [Core_set_intf.Accessors_generic] |
equal [Core_set] | `equal t1 t2` returns `true` iff the two sets have the same elements.
equal [Core_map_intf.Accessors3_with_comparator] |
equal [Core_map_intf.Accessors3] |
equal [Core_map_intf.Accessors2] |
equal [Core_map_intf.Accessors1] |
equal [Core_map_intf.Accessors_generic] |
equal [Core_map] | `equal cmp m1 m2` tests whether the maps `m1` and `m2` are equal, that is, contain equal keys and associate them with equal data.
equal [Core_list] |
equal [Core_hashtbl_intf.Accessors] | `equal t1 t2 f` and `similar t1 t2 f` both return true iff `t1` and `t2` have the same keys and for all keys `k`, `f (find_exn t1 k) (find_exn t2 k)`.
equal [Core_array.Permissioned] |
equal [Core_array] |
equal [Polymorphic_compare_intf.S] |
equal [Blit_intf.Elt] | `of_bool` is used to generate two distinct values of type `t`, used in unit tests.
equal [Bag.Elt] |
equal_fn [Quickcheck_generator] | Generator for equality functions; result is guaranteed to be an equivalence relation.
equal_fn_with_sexp [Quickcheck_generator] |
error [Result] |
error [Or_error] | `error` is a wrapper around `Error.create`:
error [Common] | `Or_error.error`
error_string [Or_error] | `error_string message` is `Error (Error.of_string message)`
errorf [Or_error] | `errorf format arg1 arg2 ...` is `Error (sprintf format arg1 arg2 ...)`.
errors [Validate] | Returns a list of formatted error strings, which include both the error message and the path to the error.

escape [Core_string.Escaping]

`escape ~escapeworthy ~escape_char s` is

            escape_gen_exn ~escapeworthy_map:(List.zip_exn escapeworthy escapeworthy)
              ~escape_char

.

escape_gen [Core_string.Escaping] |
escape_gen_exn [Core_string.Escaping] | `escape_gen_exn escapeworthy_map escape_char` returns a function that will escape a string `s` as follows: if `(c1,c2)` is in `escapeworthy_map`, then all occurences of `c1` are replaced by `escape_char` concatenated to `c2`.
escaped [Core_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 [Core_char] | Return a string representing the given character, with special characters escaped following the lexical conventions of Objective Caml.
eval [Blang] | `eval t f` evaluates the proposition `t` relative to an environment `f` that assigns truth values to base propositions.
exists [Stack_unit_tests.Debug] |
exists [Hash_queue.Make] |
exists [Core_set] | `exists t ~f` returns `true` iff there exists an `a` in `t` for which `f a`.
exists [Core_map_intf.Accessors3_with_comparator] |
exists [Core_map_intf.Accessors3] |
exists [Core_map_intf.Accessors2] |
exists [Core_map_intf.Accessors1] |
exists [Core_map_intf.Accessors_generic] |
exists [Core_map] |
exists [Core_hashtbl_intf.Accessors] |
exists [Core_gc.Control.Fields] |
exists [Core_gc.Stat.Fields] |
exists [Container_unit_tests.Test_generic] |
exists [Container_intf.Container] |
exists [Container_intf.Generic_phantom] |
exists [Container_intf.Generic] |
exists [Container_intf.S1_permissions] | Returns `true` if and only if there exists an element for which the provided function evaluates to `true`.
exists [Container_intf.S1_phantom_invariant] | Returns `true` if and only if there exists an element for which the provided function evaluates to `true`.
exists [Container_intf.S1] | Returns `true` if and only if there exists an element for which the provided function evaluates to `true`.
exists [Container_intf.S0_phantom] | Returns `true` if and only if there exists an element for which the provided function evaluates to `true`.
exists [Container_intf.S0] | Returns `true` if and only if there exists an element for which the provided function evaluates to `true`.
exists [Bounded_int_table] |
exists2_exn [Core_list] | Same as `List.exists`, but for a two-argument predicate.
existsi [Core_hashtbl_intf.Accessors] |
existsi [Bounded_int_table] |
exitf [Core_printf] | print to stderr; exit 1
exn_if_dup [Core_list] | `exn_if_dup ?compare ?context t ~to_sexp` will run `find_a_dup` on `t`, and raise `Duplicate_found` if a duplicate is found.
F
fail [Validate] | A result containing a single error
fail [Result] |
fail_fn [Validate] | `fail_fn err` returns a function that always returns fail, with `err` as the error message.
failf [Validate] | Like `sprintf` or `failwithf` but produces a `t` instead of a string or exception
failf [Result] | e.g.
fails [Validate] |
failure [Raw_quickcheck_generator] | Empty generator that is guaranteed to fail to produce a value.
failwithf [Core_printf] | raises Failure
failwithf [Common] |
failwithp [Error] |
failwithp [Common] | `Error.failwithp`

failwiths [Error]

          failwiths ?strict ?here message a sexp_of_a
          = Error.raise (Error.create ?strict ?here s a sexp_of_a)

failwiths [Common] | `Error.failwiths`
false_ [Blang] |
feed [Unpack_buffer] | `feed t buf ?pos ?len` adds the specified substring of `buf` to `t`'s buffer.
feed_string [Unpack_buffer] |
field [Validate] | Used for validating an individual field.
field_folder [Validate] | Creates a function for use in a `Fields.fold`.
fill [Core_string] |
fill [Core_array.Permissioned] |
fill [Core_array] | `Array.fill a ofs len x` modifies the array `a` in place, storing `x` in elements number `ofs` to `ofs + len - 1`.
fill [Bucket.S] |
fill [Bucket.Make] |
filter [Sequence] |
filter [Quickcheck_generator] |
filter [Option] |
filter [Linked_queue] |
filter [Hash_set_intf.Accessors] |
filter [Core_string] | `filter s ~f:predicate` discards characters not satisfying `predicate`
filter [Core_set_intf.Accessors2_with_comparator] |
filter [Core_set_intf.Accessors2] |
filter [Core_set_intf.Accessors1] |
filter [Core_set_intf.Accessors0] |
filter [Core_set_intf.Accessors_generic] |
filter [Core_set] | `filter t ~f` returns the subset of `t` for which `f` evaluates to true.
filter [Core_queue] | `filter` is like `filter_map`, except with `List.filter`.
filter [Core_map_intf.Accessors3_with_comparator] |
filter [Core_map_intf.Accessors3] |
filter [Core_map_intf.Accessors2] |
filter [Core_map_intf.Accessors1] |
filter [Core_map_intf.Accessors_generic] |
filter [Core_map] | `filter`, `filter_map`, and `filter_mapi` run in O(n * lg n) time; they simply accumulate each key & data retained by `f` into a new map using `add`.
filter [Core_list] | `filter l ~f` returns all the elements of the list `l` that satisfy the predicate `p`.
filter [Core_hashtbl_intf.Accessors] |
filter [Core_array.Permissioned] |
filter [Core_array] | `filter ~f array` removes the elements for which `f` returns false.
filter_inplace [Linked_queue] | `filter_inplace t ~f` removes all elements of `t` that don't satisfy `f`.
filter_inplace [Hash_set_intf.Accessors] |
filter_inplace [Doubly_linked] | `filter_inplace t ~f` removes all elements of `t` that don't satisfy `f`.
filter_inplace [Core_queue] | `filter_inplace t ~f` removes all elements of `t` that don't satisfy `f`.
filter_inplace [Core_hashtbl_intf.Accessors] |
filter_inplace [Bag] | `filter_inplace t ~f` removes all the elements from `t` that don't satisfy `f`.
filter_map [Sequence] | `filter_map t ~f` produce mapped elements of `t` which are not `None`.
filter_map [Quickcheck_generator] | `filter_map t ~f` produces `y` for every `x` in `t` such that `f x = Some y`.
filter_map [Linked_queue] |
filter_map [Core_set_intf.Creators2_with_comparator] |
filter_map [Core_set_intf.Creators2] |
filter_map [Core_set_intf.Creators1] |
filter_map [Core_set_intf.Creators0] |
filter_map [Core_set_intf.Creators_generic] |
filter_map [Core_set] | Like `Core_set.map`, except elements for which `f` returns `None` will be dropped.
filter_map [Core_queue] | `filter_map` creates a new queue with elements equal to `List.filter_map ~f (to_list t)`.
filter_map [Core_map_intf.Accessors3_with_comparator] |
filter_map [Core_map_intf.Accessors3] |
filter_map [Core_map_intf.Accessors2] |
filter_map [Core_map_intf.Accessors1] |
filter_map [Core_map_intf.Accessors_generic] |
filter_map [Core_map] | returns new map with bound values filtered by f applied to the bound values
filter_map [Core_list] | `filter_map l ~f` is the sublist of `l` containing only elements for which `f` returns `Some e`.
filter_map [Core_hashtbl_intf.Accessors] | returns new map with bound values filtered by f applied to the bound values
filter_map [Core_array.Permissioned] |
filter_map [Core_array] | `filter_map ~f array` maps `f` over `array` and filters `None` out of the results.
filter_map [Bounded_int_table] |
filter_mapi [Sequence] | `filter_mapi` is just like `filter_map`, but it also passes in the index of each element to `f`.
filter_mapi [Core_map_intf.Accessors3_with_comparator] |
filter_mapi [Core_map_intf.Accessors3] |
filter_mapi [Core_map_intf.Accessors2] |
filter_mapi [Core_map_intf.Accessors1] |
filter_mapi [Core_map_intf.Accessors_generic] |
filter_mapi [Core_map] | like `filter_map`, but function takes both key and data as arguments
filter_mapi [Core_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 [Core_array.Permissioned] |
filter_mapi [Core_array] | Same as `filter_map` but uses `Array.mapi`.
filter_mapi [Bounded_int_table] |
filter_opt [Sequence] | `filter_opt t` produces the elements of `t` which are not `None`.
filter_opt [Core_list] | `filter_opt l` is the sublist of `l` containing only elements which are `Some e`.
filter_opt [Core_array.Permissioned] |
filter_opt [Core_array] | `filter_opt array` returns a new array where `None` entries are omitted and `Some x` entries are replaced with `x`.
filteri [Sequence] |
filteri [Core_list] |
filteri [Core_hashtbl_intf.Accessors] |
filteri [Core_array.Permissioned] |
filteri [Core_array] | Like `filter` except `f` also receives the index.
filteri_inplace [Core_hashtbl_intf.Accessors] |
finalize_release [Core_gc.Expert] | The runtime essentially maintains a bool ref:
find [Univ_map_intf.S1] |
find [Univ_map_intf.S] |
find [Univ_map.Multi] |
find [Univ_map.With_fold] | the current accumulator
find [Univ_map.With_default] |
find [Total_map] |
find [Stack_unit_tests.Debug] |
find [Hash_queue.Make] |
find [Hash_heap.S] |
find [Hash_heap.Make] |
find [Core_set] | `find t f` returns an element of `t` for which `f` returns true, with no guarantee as to which element is returned.
find [Core_map_intf.Accessors3_with_comparator] |
find [Core_map_intf.Accessors3] |
find [Core_map_intf.Accessors2] |
find [Core_map_intf.Accessors1] |
find [Core_map_intf.Accessors_generic] |
find [Core_map] | returns the value bound to the given key, raising `Not_found` if none such exists
find [Core_list.Assoc] |
find [Core_hashtbl_intf.Accessors] | `find t k` returns Some (the current binding) of k in t, or None if no such binding exists
find [Container_unit_tests.Test_generic] |
find [Container_intf.Container] |
find [Container_intf.Generic_phantom] |
find [Container_intf.Generic] |
find [Container_intf.S1_permissions] | Returns as an `option` the first element for which `f` evaluates to true.
find [Container_intf.S1_phantom_invariant] | Returns as an `option` the first element for which `f` evaluates to true.
find [Container_intf.S1] | Returns as an `option` the first element for which `f` evaluates to true.
find [Container_intf.S0_phantom] | Returns as an `option` the first element for which `f` evaluates to true.
find [Container_intf.S0] | Returns as an `option` the first element for which `f` evaluates to true.
find [Bounded_int_table] |
find [Bigstring] | `find ?pos ?len char t` returns `Some i` for the smallest `i >= pos` such that `t.{i} = char`, or `None` if there is no such `i`.
find [Avltree] | if the specified key exists in the tree, return the corresponding value.
find_a_dup [Core_list] | `find_a_dup` returns a duplicate from the list (no guarantees about which duplicate you get), or None if there are no dups.
find_and_call [Core_hashtbl_intf.Accessors] | `find_and_call t k ~if_found ~if_not_found`
find_and_call [Avltree] | `find_and_call t ~compare k ~if_found ~if_not_found`
find_and_remove [Core_hashtbl_intf.Accessors] | `find_and_remove t k` returns Some (the current binding) of k in t and removes it, or None is no such binding exists
find_consecutive_duplicate [Sequence] | `find_consecutive_duplicate t ~equal` returns the first pair of consecutive elements `(a1, a2)` in `t` such that `equal a1 a2`.
find_consecutive_duplicate [Core_list] | `find_consecutive_duplicate t ~equal` returns the first pair of consecutive elements `(a1, a2)` in `t` such that `equal a1 a2`.
find_consecutive_duplicate [Core_array.Permissioned] |
find_consecutive_duplicate [Core_array] | `find_consecutive_duplicate t ~equal` returns the first pair of consecutive elements `(a1, a2)` in `t` such that `equal a1 a2`.
find_elt [Heap.Removable] | `find_elt t ~f`.
find_elt [Doubly_linked] | `find_elt t ~f` finds the first element in `t` that satisfies `f`, by testing each of element of `t` in turn until `f` succeeds.
find_elt [Bag] | `find_elt t ~f` looks at elements in the bag one-by-one until it finds one `elt` such that `f (Elt.value elt)`, in which case it returns `Some elt`.
find_exn [Univ_map_intf.S1] |
find_exn [Univ_map_intf.S] |
find_exn [Sequence] | `find_exn t ~f` returns the first element of `t` that satisfies `f`.
find_exn [Hash_heap.S] |
find_exn [Hash_heap.Make] |
find_exn [Core_set_intf.Accessors2_with_comparator] |
find_exn [Core_set_intf.Accessors2] |
find_exn [Core_set_intf.Accessors1] |
find_exn [Core_set_intf.Accessors0] |
find_exn [Core_set_intf.Accessors_generic] |
find_exn [Core_set] | Like `find`, but throws an exception on failure.
find_exn [Core_map_intf.Accessors3_with_comparator] |
find_exn [Core_map_intf.Accessors3] |
find_exn [Core_map_intf.Accessors2] |
find_exn [Core_map_intf.Accessors1] |
find_exn [Core_map_intf.Accessors_generic] |
find_exn [Core_map] |
find_exn [Core_list.Assoc] |
find_exn [Core_list] | `find_exn t ~f` returns the first element of `t` that satisfies `f`.
find_exn [Core_hashtbl_intf.Accessors] | `find_exn t k` returns the current binding of k in t, or raises Not_found if no such binding exists.
find_exn [Core_array.Permissioned] |
find_exn [Core_array] | `find_exn f t` returns the first `a` in `t` for which `f t.(i)` is true.
find_exn [Bounded_int_table] |
find_index [Core_set_intf.Accessors2_with_comparator] |
find_index [Core_set_intf.Accessors2] |
find_index [Core_set_intf.Accessors1] |
find_index [Core_set_intf.Accessors0] |
find_index [Core_set_intf.Accessors_generic] |
find_index [Core_set] | `find_index t i` returns the `i`th smallest element of `t`, in `O(log n)` time.
find_map [Stack_unit_tests.Debug] |
find_map [Hash_queue.Make] |
find_map [Core_set] | `find_map t f` returns `b` for some `a` in `t` for which `f a = Some b`.
find_map [Container_unit_tests.Test_generic] |
find_map [Container_intf.Container] |
find_map [Container_intf.Generic_phantom] |
find_map [Container_intf.Generic] |
find_map [Container_intf.S1_permissions] | Returns the first evaluation of `f` that returns `Some`, and returns `None` if there is no such element.
find_map [Container_intf.S1_phantom_invariant] | Returns the first evaluation of `f` that returns `Some`, and returns `None` if there is no such element.
find_map [Container_intf.S1] | Returns the first evaluation of `f` that returns `Some`, and returns `None` if there is no such element.
find_map [Container_intf.S0_phantom] | Returns the first evaluation of `f` that returns `Some`, and returns `None` if there is no such element.
find_map [Container_intf.S0] | Returns the first evaluation of `f` that returns `Some`, and returns `None` if there is no such element.
find_or_add [Core_hashtbl_intf.Accessors] | `find_or_add t k ~default` returns 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] | Mutation of the heap during iteration is not supported, but there is no check to prevent it.
find_pop_exn [Hash_heap.Make] |
findi [Sequence] |
findi [Core_list] |
findi [Core_array.Permissioned] |
findi [Core_array] | `findi t f` returns the first index `i` of `t` for which `f i t.(i)` is true
findi_exn [Core_array.Permissioned] |
findi_exn [Core_array] | `findi_exn t f` returns the first index `i` of `t` for which `f i t.(i)` is true.
fire_past_alarms [Timing_wheel_intf.Timing_wheel] | `fire_past_alarms t ~handle_fired` fires and removes all alarms `a` in `t` with `Time.( <= ) (Alarm.at t a) (now t)`, applying `handle_fired` to each such `a`.
first [Hash_queue.S] | `first t` returns the front element of the queue, without removing it.
first [Hash_queue.Make] |
first [Either_intf.S] | `first` and `second` are `First.return` and `Second.return`.
first [Doubly_linked] |
first [Avltree] |
first_elt [Doubly_linked] | constant-time extraction of first and last elements.
first_failure [Validate] |
first_some [Option] |
first_with_key [Hash_queue.S] | `first_with_key t` returns the front element of the queue and its key, without removing it.
first_with_key [Hash_queue.Make] |
flip [Fn] | reverse the order of arguments for a binary function
float [Type_immediacy.Never] |
float [Quickcheck_observer] |
float [Quickcheck_generator] |
float [Core_random.State] |
float [Core_random] | `Random.float bound` returns a random floating-point number between 0 (inclusive) and `bound` (exclusive).
float_between [Quickcheck_generator] | `float_between ~nan ~lower_bound ~upper_bound` produces floating point numbers within the given bounds.
float_finite [Quickcheck_generator] | `float_finite` includes finite values, but excludes infinite and NaN values.
float_of_bits [Core_int64] |
float_of_bits [Core_int32] |
float_of_int [Common] |
float_of_string [Common] |
float_without_nan [Quickcheck_generator] | `float_without_nan` includes finite and infinite values, but excludes NaN.
floor [Common] |
floor_pow2 [Int_pow2] |
floor_pow2 [Core_int] | `floor_pow2 x` returns the largest power of 2 that is less than or equal to `x`.
flush [Out_channel] |
fn [Raw_quickcheck_observer] | Observer for function type.
fn [Quickcheck_generator] | Generators for functions; take observers for inputs and a generator for outputs.
fn2 [Quickcheck_generator] |
fn2_with_sexp [Quickcheck_generator] |
fn3 [Quickcheck_generator] |
fn3_with_sexp [Quickcheck_generator] |
fn4 [Quickcheck_generator] |
fn4_with_sexp [Quickcheck_generator] |
fn5 [Quickcheck_generator] |
fn5_with_sexp [Quickcheck_generator] |
fn6 [Quickcheck_generator] |
fn6_with_sexp [Quickcheck_generator] |
fn_sexp [Quickcheck_generator] |
fn_with_sexp [Quickcheck_generator] |
fold [Stack_unit_tests.Debug] |
fold [Linked_queue] |
fold [Hash_queue.Make] |
fold [Flat_queue] | In `iter t ~f` and `fold t ~init ~f`, if `f` mutates `t`, then the iteration will raise.
fold [Core_set] | `fold t ~init ~f` folds over the elements of the set from smallest to largest.
fold [Core_map_intf.Accessors3_with_comparator] |
fold [Core_map_intf.Accessors3] |
fold [Core_map_intf.Accessors2] |
fold [Core_map_intf.Accessors1] |
fold [Core_map_intf.Accessors_generic] |
fold [Core_map] | folds over keys and data in map in increasing order of key.
fold [Core_hashtbl_intf.Accessors] |
fold [Core_gc.Control.Fields.Direct] |
fold [Core_gc.Control.Fields] |
fold [Core_gc.Stat.Fields.Direct] |
fold [Core_gc.Stat.Fields] |
fold [Container_unit_tests.Test_generic] |
fold [Container_intf.Make_arg] |
fold [Container_intf.Generic_phantom] |
fold [Container_intf.Generic] |
fold [Container_intf.S1_permissions] | `fold t ~init ~f` returns `f (... f (f (f init e1) e2) e3 ...) en`, where `e1..en` are the elements of `t`
fold [Container_intf.S1_phantom_invariant] | `fold t ~init ~f` returns `f (... f (f (f init e1) e2) e3 ...) en`, where `e1..en` are the elements of `t`
fold [Container_intf.S1] | `fold t ~init ~f` returns `f (... f (f (f init e1) e2) e3 ...) en`, where `e1..en` are the elements of `t`
fold [Container_intf.S0_phantom] | `fold t ~init ~f` returns `f (... f (f (f init e1) e2) e3 ...) en`, where `e1..en` are the elements of `t`
fold [Container_intf.S0] | `fold t ~init ~f` returns `f (... f (f (f init e1) e2) e3 ...) en`, where `e1..en` are the elements of `t`
fold [Bounded_int_table] |
fold [Avltree] | fold over the tree
fold' [Deque] | `fold' t ~init ~f` fold over the elements of `t`
fold2_exn [Core_list] | `List.fold2_exn ~f ~init:a [b1; ...; bn] [c1; ...; cn]` is `f (... (f (f a b1 c1) b2 c2) ...) bn cn`.
fold2_exn [Core_array.Permissioned] |
fold2_exn [Core_array] |
fold_elt [Doubly_linked] | `fold_elt t ~init ~f` is the same as fold, except `f` is called with the `'a Elt.t`'s from the list instead of the contained `'a` values.
fold_left [Core_list] | `fold_left` is the same as `fold`, and one should always use `fold` rather than `fold_left`, except in functors that are parameterized over a more general signature where this equivalence does not hold.
fold_lines [In_channel] | `fold_lines ?fix_win_eol t ~init ~f` folds over the lines read from `t` using `input_line`.
fold_range_inclusive [Core_map_intf.Accessors3_with_comparator] |
fold_range_inclusive [Core_map_intf.Accessors3] |
fold_range_inclusive [Core_map_intf.Accessors2] |
fold_range_inclusive [Core_map_intf.Accessors1] |
fold_range_inclusive [Core_map_intf.Accessors_generic] |
fold_range_inclusive [Core_map] | `fold_range_inclusive t ~min ~max ~init ~f` folds f (with initial value ~init) over all keys (and their associated values) that are in the range `min, max` (inclusive).
fold_right [Doubly_linked] |
fold_right [Core_set_intf.Accessors2_with_comparator] |
fold_right [Core_set_intf.Accessors2] |
fold_right [Core_set_intf.Accessors1] |
fold_right [Core_set_intf.Accessors0] |
fold_right [Core_set_intf.Accessors_generic] |
fold_right [Core_set] | Like `Core_set.fold`, except that it goes from the largest to the smallest element.
fold_right [Core_map_intf.Accessors3_with_comparator] |
fold_right [Core_map_intf.Accessors3] |
fold_right [Core_map_intf.Accessors2] |
fold_right [Core_map_intf.Accessors1] |
fold_right [Core_map_intf.Accessors_generic] |
fold_right [Core_map] | folds over keys and data in map in decreasing order of key.
fold_right [Core_list] | `List.fold_right [a1; ...; an] ~f ~init:b` is `f a1 (f a2 (... (f an b) ...))`.
fold_right [Core_array.Permissioned] |
fold_right [Core_array] | `Array.fold_right f a ~init` computes `f a.(0) (f a.(1) ( ... (f a.(n-1) init) ...))`, where `n` is the length of the array `a`.
fold_until [Core_set_intf.Accessors2_with_comparator] |
fold_until [Core_set_intf.Accessors2] |
fold_until [Core_set_intf.Accessors1] |
fold_until [Core_set_intf.Accessors0] |
fold_until [Core_set_intf.Accessors_generic] |
fold_until [Core_set] | Like `Core_set.fold`, except that it will terminate early, if `f` returns ``Stop`.
foldi [Sequence] | `foldi` is just like `fold`, but it also passes in the index of each element to `f`.
foldi [Hash_queue.S] |
foldi [Hash_queue.Make] |
foldi [Deque] | `foldi t ~init ~f` as `fold`, but also passes in the index of the current element.
foldi [Core_string] | `foldi` works similarly to `fold`, but also pass in index of each character to `f`
foldi [Core_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 [Core_array.Permissioned] |
foldi [Core_array] |
foldi' [Deque] | `foldi' t ~init ~f` as `fold'`, but also passes in the index of the current element to `f`.
for_all [Stack_unit_tests.Debug] |
for_all [Hash_queue.Make] |
for_all [Core_set] | `for_all t ~f` returns `true` iff for all `a` in `t`, `f a`.
for_all [Core_map_intf.Accessors3_with_comparator] |
for_all [Core_map_intf.Accessors3] |
for_all [Core_map_intf.Accessors2] |
for_all [Core_map_intf.Accessors1] |
for_all [Core_map_intf.Accessors_generic] |
for_all [Core_map] | same semantics as similar functions in List
for_all [Core_hashtbl_intf.Accessors] |
for_all [Core_gc.Control.Fields] |
for_all [Core_gc.Stat.Fields] |
for_all [Container_unit_tests.Test_generic] |
for_all [Container_intf.Container] |
for_all [Container_intf.Generic_phantom] |
for_all [Container_intf.Generic] |
for_all [Container_intf.S1_permissions] | Returns `true` if and only if the provided function evaluates to `true` for all elements.
for_all [Container_intf.S1_phantom_invariant] | Returns `true` if and only if the provided function evaluates to `true` for all elements.
for_all [Container_intf.S1] | Returns `true` if and only if the provided function evaluates to `true` for all elements.
for_all [Container_intf.S0_phantom] | Returns `true` if and only if the provided function evaluates to `true` for all elements.
for_all [Container_intf.S0] | Returns `true` if and only if the provided function evaluates to `true` for all elements.
for_all [Bounded_int_table] |
for_all2_exn [Core_list] | Same as `List.for_all`, but for a two-argument predicate.
for_all2_exn [Core_array.Permissioned] |
for_all2_exn [Core_array] | `for_all2_exn t1 t2 ~f` fails if `length t1 <> length t2`.
for_alli [Core_hashtbl_intf.Accessors] |
for_alli [Bounded_int_table] |
force [Only_in_test] |
force [Force_once] | `force t` runs the thunk if it hadn't already been forced, else it raises an exception.
force [Core_lazy] | `force x` forces the suspension `x` and returns its result.
force [Common] |
force_eagerly [Sequence] | `force_eagerly t` precomputes the sequence.
force_val [Core_lazy] | Like `force` except that if the computation of `x` raises an exception, it is unspecified whether `force_val x` raises the same exception or `Undefined`.
forever [Fn] | `forever f` runs `f ()` until it throws an exception and returns the exception.
formatter_of_buffer [Bigbuffer.Format] |
fprintf [Std_internal] |
fprintf [Core_printf] |
fractional [Float_intf.S.Parts] |
fragments [Core_gc.Stat.Fields] |
fragments [Core_gc.Stat] |
free [Pool_intf.S] | `free t pointer` frees the tuple pointed to by `pointer` from `t`.
free_blocks [Core_gc.Stat.Fields] |
free_blocks [Core_gc.Stat] |
free_words [Core_gc.Stat.Fields] |
free_words [Core_gc.Stat] |
frexp [Float_intf.S] | `frexp f` returns the pair of the significant and the exponent of f.
frexp [Common] |
from_fun [Core_lazy] | `from_fun f` is the same as `lazy (f ())` but slightly more efficient.
from_val [Core_lazy] | `from_val v` returns an already-forced suspension of `v` This is for special purposes only and should not be confused with `lazy (v)`.
front_index [Deque] | `front_index t` return the index of the front item in `t`.
front_index_exn [Deque] | `front_index_exn t` throws an exception if `t` is empty, otherwise returns the index of the front item in `t`
fst3 [Common] | triple handling
full_init [Core_random] | Same as `Random.init` but takes more data as seed.
full_major [Core_gc] | Do a minor collection, finish the current major collection cycle, and perform a complete new cycle.
G
gather_conjuncts [Blang] | `gather_conjuncts t` gathers up all toplevel conjuncts in `t`.
gather_disjuncts [Blang] | `gather_disjuncts t` gathers up all toplevel disjuncts in `t`.
general [Memo] | Returns memoized version of any function with a single argument.
get [Union_find] | `get t` returns the value of the class of `t`.
get [Set_once] |
get [Ref.Permissioned] |
get [Pool_intf.S] | `get t pointer slot` gets `slot` of the tuple pointed to by `pointer` in pool `t`.
get [Obj_array] | `get t i` and `unsafe_get t i` return the object at index `i`.
get [Flat_queue] | These functions get and set individual slots of flat tuple `i` in queue `t`.
get [Flat_array_debug.Debug] |
get [Flat_array] | These functions get and set individual slots of flat tuple `i` in array `t`.
get [Deque] | `get t i` return the element at index `i`.
get [Core_weak] |
get [Core_string] |
get [Core_queue] | `get t i` returns the `i`'th element in `t`, where the 0'th element is at the front of `t` and the `length t - 1` element is at the back.
get [Core_gc] | Return the current values of the GC parameters in a `control` record.
get [Core_array.Permissioned] |
get [Core_array] | `Array.get a n` returns the element number `n` of array `a`.
get [Blit_intf.Sequence] |
get [Binary_searchable_intf.Indexable1] |
get [Binary_searchable_intf.Indexable] |
get [Bigstring] | `get t pos` returns the character at `pos`
get [Backtrace] |
get1 [Tuple.T3] |
get1 [Tuple.T2] |
get2 [Tuple.T3] |
get2 [Tuple.T2] |
get3 [Tuple.T3] |
get_all_slots [Flat_queue] | `get_all_slots t i` allocates a new ordinary OCaml tuple whose components are equal to the slots of the flat tuple at index `i` of `t`.
get_all_slots [Flat_array_debug.Debug] |
get_all_slots [Flat_array] | `get_all_slots t i` allocates a new ordinary OCaml tuple whose components are equal to the slots of the flat tuple at index `i` of `t`.
get_backtrace [Core_printexc] |
get_digit [Core_char] | Return `Some i` if `is_digit c` and `None` otherwise.
get_digit_exn [Core_char] | Return `i` if `is_digit c`.
get_exn [Set_once] |
get_opt [Deque] | `get_opt t i` return the element at index `i`.
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_state [Core_random] | OCaml's `Random.get_state` makes a copy of the default state, which is almost certainly not what you want.
get_tail_padded_fixed_string [Bigstring] | similar to `Binary_packing.unpack_tail_padded_fixed_string` and `.pack_tail_padded_fixed_string`.
get_tuple [Pool_intf.S] | `get_tuple t pointer` allocates an OCaml tuple isomorphic to the pool `t`'s tuple pointed to by `pointer`.
gigabytes [Byte_units] |
group [Core_list] | `group l ~break` returns a list of lists (i.e., groups) whose concatenation is equal to the original list.
group [Core_hashtbl_intf.Creators] |
group_by [Core_set_intf.Accessors2_with_comparator] |
group_by [Core_set_intf.Accessors2] |
group_by [Core_set_intf.Accessors1] |
group_by [Core_set_intf.Accessors0] |
group_by [Core_set_intf.Accessors_generic] |
group_by [Core_set] | if `equiv` is an equivalence predicate, then `group_by set ~equiv` produces a list of equivalence classes (i.e., a set-theoretic quotient).
groupi [Core_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.
grow [Pool_intf.S] | `grow t ~capacity` returns a new pool `t'` with the supplied capacity.
H
handle_uncaught [Exn] | `handle_uncaught ~exit f` catches an exception escaping `f` and prints an error message to stderr.
handle_uncaught_and_exit [Exn] | `handle_uncaught_and_exit f` returns `f ()`, unless that raises, in which case it prints the exception and exits nonzero.
hash [Type_equal.Id] | accessors
hash [Hashable.S_binable] |
hash [Hashable.S] |
hash [Core_string] | slightly faster hash function on strings
hash [Core_hashtbl_intf.Hashtbl] |
hash [Core_hashtbl_intf.Key] | Values returned by `hash` must be non-negative.
hash [Core_hashtbl_intf.Hashable] |
hash_param [Core_hashtbl_intf.Hashtbl] |
hash_param [Core_hashtbl_intf.Hashable] |
hashable [Hashable.S_binable] |
hashable [Hashable.S] |
hashable [Hashable.Make_binable] |
hashable [Hashable.Make] |
hashable [Core_hashtbl_intf.Hashtbl.Poly] |
hashable [Core_hashtbl_intf.S] |
hd [Sequence] |
hd [Core_list] |
hd_exn [Sequence] |
hd_exn [Core_list] | Return the first element of the given list.
heap_chunks [Core_gc.Stat.Fields] |
heap_chunks [Core_gc.Stat] |
heap_chunks [Core_gc] |
heap_words [Core_gc.Stat.Fields] |
heap_words [Core_gc.Stat] |
heap_words [Core_gc] |
here [Validated_intf.Raw] | `here` will appear in validation-failure error messages.
host [Host_and_port] |
hour [Time_ns.Span] |
I
id [Fn] | The identity function
id_of_pointer [Pool_intf.S] | `id_of_pointer t pointer` returns an id that is unique for the lifetime of `pointer`'s tuple.
ident [Common] |
ieee_exponent [Float_intf.S] |
ieee_mantissa [Float_intf.S] |
ieee_negative [Float_intf.S] |
if_ [Blang] | `if_ if then else`
ifprintf [Core_printf] |
ignore [Result] |
ignore [Or_error] |
ignore [Force_once] | `ignore ()` = create (fun () -> ())
ignore [Fn] | `ignore` is the same as `Pervasives.ignore`.
ignore_m [Monad_intf.S2] |
ignore_m [Monad_intf.S] | `ignore_m t` is `map t ~f:(fun _ -> ())`.
immutable_of_sexp [Perms.Export] |
in_channel_length [Common] |
incr [Int_intf.S] |
incr [Core_hashtbl_intf.Accessors] |
increase_min_allowed_key [Timing_wheel_intf.Timing_wheel.Priority_queue] | `increase_min_allowed_key t ~key ~handle_removed` increases the minimum allowed key in `t` to `key`, and removes all elements with keys less than `key`, applying `handle_removed` to each element that is removed.
index [Core_string.Escaping] | `index s ~escape_char char` find the first literal (not escaped) instance of char in s starting from 0.
index [Core_string.Search_pattern] | `pos < 0` or `pos >= length string` result in no match (hence `index` returns `None` and `index_exn` raises).
index [Core_string] |
index_all [Core_string.Search_pattern] | `may_overlap` determines whether after a successful match, `index_all` should start looking for another one at the very next position (`~may_overlap:true`), or jump to the end of that match and continue from there (`~may_overlap:false`), e.g.:
index_exn [Core_string.Escaping] |
index_exn [Core_string.Search_pattern] |
index_exn [Core_string] |
index_from [Core_string.Escaping] | `index_from s ~escape_char pos char` find the first literal (not escaped) instance of char in s starting from pos and proceeding towards the end of s.
index_from [Core_string] |
index_from_exn [Core_string.Escaping] |
index_from_exn [Core_string] |
infinity [Float_intf.S] |
infinity [Common] |
init [Sequence] | `init n ~f` is `[(f 0); (f 1); ...; (f (n-1))]`.
init [Pid] |
init [Core_string] |
init [Core_list] | `init n ~f` is `[(f 0); (f 1); ...; (f (n-1))]`.
init [Core_array.Permissioned] |
init [Core_array] | `init n ~f` creates an array of length `n` where the `i`th element is initialized with `f i` (starting at zero)
init [Bigstring] | `init n ~f` creates a bigstring `t` of length `n`, with `t.{i} = f i`
init [Core_random] | Initialize the generator, using the argument as a seed.
input [In_channel] |
input_all [In_channel] |
input_binary_int [In_channel] |
input_byte [In_channel] |
input_char [In_channel] |
input_line [In_channel] | `input_line ?fix_win_eol t` reads a line from `t` and returns it, without the newline ("\n") character at the end, and, if `fix_win_eol` the trailing "\r\n" is dropped.
input_lines [In_channel] | 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_delimiter_every ~chars_per_delimiter:3`
insert_delimiter_every [Int_conversions] | utility for defining to_string_hum on numeric types -- takes a string matching (-|+)?`0-9a-fA-F`+ and puts `delimiter` every `chars_per_delimiter` characters starting from the right.
insert_first [Doubly_linked] |
insert_last [Doubly_linked] |
insert_underscores [Int_conversions] | `insert_delimiter ~delimiter:'_'`
inspect [Raw_quickcheck_generator] | `inspect t` produces a concrete representation of the outermost constructor of `t`.
int [Type_immediacy.Always] |
int [Quickcheck_observer] |
int [Quickcheck_generator] |
int [Core_random.State] |
int [Core_random] | `Random.int bound` returns a random integer between 0 (inclusive) and `bound` (exclusive).
int32 [Type_immediacy.Never] |
int32 [Core_random.State] |
int32 [Core_random] | `Random.int32 bound` returns a random integer between 0 (inclusive) and `bound` (exclusive).
int32_positive_overflow_bounds [Pow_overflow_bounds] |
int32_to_int [Int_conversions] |
int32_to_int64 [Int_conversions] |
int32_to_int_exn [Int_conversions] |
int32_to_nativeint [Int_conversions] |
int63_round_nearest_exn [Float_intf.S] |
int64 [Type_immediacy.Never] |
int64 [Core_random.State] |
int64 [Core_random] | `Random.int64 bound` returns a random integer between 0 (inclusive) and `bound` (exclusive).
int64_negative_overflow_bounds [Pow_overflow_bounds] |
int64_positive_overflow_bounds [Pow_overflow_bounds] |
int64_pow [Int_math] |
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_as_value [Type_immediacy.Sometimes] |
int_as_value [Type_immediacy.Always] |
int_as_value [Type_immediacy] |
int_as_value_exn [Type_immediacy.Sometimes] |
int_as_value_exn [Type_immediacy.Always] |
int_as_value_exn [Type_immediacy] |
int_between [Quickcheck_observer] | `int_between ~lower_bound ~upper_bound` observes integers within the given bounds.
int_between [Quickcheck_generator] | `int_between ~lower_bound ~upper_bound` produces integers within the given bounds.
int_is_value [Type_immediacy.Sometimes] |
int_is_value [Type_immediacy.Always] |
int_is_value [Type_immediacy] |
int_middle_bits [Quickcheck_unit_tests.Test] |
int_of_float [Common] |
int_positive_overflow_bounds [Pow_overflow_bounds] |
int_pow [Int_math] |
int_to_int32 [Int_conversions] | Ocaml has the following integer types, with the following bit widths on 32-bit and 64-bit architectures.
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.Accessors2_with_comparator] |
inter [Core_set_intf.Accessors2] |
inter [Core_set_intf.Accessors1] |
inter [Core_set_intf.Accessors0] |
inter [Core_set_intf.Accessors_generic] |
inter [Core_set] | `inter t1 t2` computes the intersection of sets `t1` and `t2`.
interleave [Sequence] | `interleave tt` produces each element of the inner sequences of `tt` eventually, even if any or all of the inner sequences are infinite.
interleaved_cartesian_product [Sequence] | Returns a sequence that eventually reaches every possible pair of elements of the inputs, even if either or both are infinite.
intersect [Flags_intf.S] | bitwise and
intersperse [Sequence] | `intersperse xs ~sep` produces `sep` between adjacent elements of `xs`.
intersperse [Core_list] | `intersperse xs ~sep` places `sep` between adjacent elements of `xs`.
interval_num [Timing_wheel_intf.Timing_wheel.Alarm] |
interval_num [Timing_wheel_intf.Timing_wheel] | `interval_num t time` returns the number of the interval that `time` is in, where `0` is the interval that starts at `start`.
interval_num_start [Timing_wheel_intf.Timing_wheel] | `interval_num_start t n` is the start of the `n`'th interval in `t`, i.e.:
interval_start [Timing_wheel_intf.Timing_wheel] |
invalid_argf [Core_printf] | raises Invalid_arg
invalid_argf [Common] |
invariant [Univ_map_intf.S1] |
invariant [Timing_wheel_intf.Timing_wheel.Priority_queue.Elt] |
invariant [Unpack_buffer] |
invariant [Stack_unit_tests.Test] |
invariant [Stack_unit_tests.Debug] |
invariant [Invariant_intf.Invariant] | `invariant here t sexp_of_t f` runs `f ()`, and if `f` raises, wraps the exception in an `Error.t` that states "invariant failed" and includes both the exception raised by `f`, as well as `sexp_of_t t`.
invariant [Invariant_intf.S3] |
invariant [Invariant_intf.S2] |
invariant [Invariant_intf.S1] |
invariant [Invariant_intf.S] |
invariant [Hash_queue.S] | `invariant t` checks the invariants of the queue.
invariant [Hash_queue.Make] |
invariant [Flat_array_debug.Debug] |
invariant [Doubly_linked] |
invariant [Core_hashtbl_intf.Accessors] |
invariant [Blang] |
invariant [Bag] |
invariant [Avltree] | check invariants, raise an exception if any invariants fail
invariants [Core_set_intf.Accessors2_with_comparator] |
invariants [Core_set_intf.Accessors2] |
invariants [Core_set_intf.Accessors1] |
invariants [Core_set_intf.Accessors0] |
invariants [Core_set_intf.Accessors_generic] |
invariants [Core_set] | Tests internal invariants of the set data structure.
invariants [Core_map_intf.Accessors3_with_comparator] |
invariants [Core_map_intf.Accessors3] |
invariants [Core_map_intf.Accessors2] |
invariants [Core_map_intf.Accessors1] |
invariants [Core_map_intf.Accessors_generic] |
invariants [Core_map] | Test if invariants of internal AVL search tree hold.
inverse [Core_list.Assoc] |
iround [Float_intf.S] |
iround_down [Float_intf.S] |
iround_down_exn [Float_intf.S] |
iround_exn [Float_intf.S] |
iround_lbound [Float_intf.S] | If `f <= iround_lbound || f >= iround_ubound`, then `iround*` functions will refuse to round `f`, returning `None` or raising as appropriate.
iround_nearest [Float_intf.S] |
iround_nearest_exn [Float_intf.S] |
iround_towards_zero [Float_intf.S] |
iround_towards_zero_exn [Float_intf.S] |
iround_ubound [Float_intf.S] |
iround_up [Float_intf.S] |
iround_up_exn [Float_intf.S] |
is_alpha [Core_char] | 'a' - 'z' or 'A' - 'Z'
is_alphanum [Core_char] | 'a' - 'z' or 'A' - 'Z' or '0' - '9'
is_char_escaped [Core_string.Escaping] | `is_char_escaped s ~escape_char pos` return true if the char at `pos` is escaped, false otherwise.
is_char_escaping [Core_string.Escaping] | Any char in an escaped string is either escaping, escaped or literal.
is_char_literal [Core_string.Escaping] | `is_literal s ~escape_char pos` return true if the char at `pos` is not escaped or escaping.
is_digit [Core_char] | '0' - '9'
is_empty [Univ_map_intf.S1] |
is_empty [Univ_map_intf.S] |
is_empty [Timing_wheel_intf.Timing_wheel.Priority_queue] | `is_empty t` is `length t = 0`
is_empty [Timing_wheel_intf.Timing_wheel] | One can think of a timing wheel as a set of alarms.
is_empty [Unpack_buffer] | `is_empty t` returns `true` if `t` has no unconsumed bytes, and `false` if it does.
is_empty [Stack_unit_tests.Test] |
is_empty [Stack_unit_tests.Debug] |
is_empty [Hash_queue.Make] |
is_empty [Fqueue] |
is_empty [Flat_queue] |
is_empty [Flags_intf.S] |
is_empty [Core_string] | `is_empty s` returns `true` iff `s` is empty (i.e.
is_empty [Core_set] | `is_empty t` is `true` iff `t` is empty.
is_empty [Core_map_intf.Accessors3_with_comparator] |
is_empty [Core_map_intf.Accessors3] |
is_empty [Core_map_intf.Accessors2] |
is_empty [Core_map_intf.Accessors1] |
is_empty [Core_map_intf.Accessors_generic] |
is_empty [Core_map] | Test whether a map is empty or not.
is_empty [Core_hashtbl_intf.Accessors] |
is_empty [Core_array.Permissioned] |
is_empty [Container_unit_tests.Test_generic] |
is_empty [Container_intf.Container] | Generic definitions of container operations in terms of `iter`.
is_empty [Container_intf.Generic_phantom] |
is_empty [Container_intf.Generic] |
is_empty [Container_intf.S1_permissions] |
is_empty [Container_intf.S1_phantom_invariant] |
is_empty [Container_intf.S1] |
is_empty [Container_intf.S0_phantom] |
is_empty [Container_intf.S0] |
is_error [Stack_unit_tests] |
is_error [Result.Export] |
is_error [Result] |
is_finite [Float_intf.S] | `is_finite t` returns `true` iff `classify t` is in `Normal; Subnormal; Zero;`.
is_first [Either_intf.S] |
is_first [Doubly_linked] |
is_full [Pool_intf.S] | `is_full t` returns `true` if no more tuples can be allocated in `t`.
is_inf [Percent] |
is_inf [Float_intf.S] | includes positive and negative Float.infinity
is_init [Flat_array_debug.Debug] |
is_init [Flat_array] | `is_init t i` returns `true` iff flat tuple `i`'s slots are identical to those of the `init` supplied to `create`.
is_last [Doubly_linked] |
is_lowercase [Core_char] | 'a' - 'z'
is_mmapped [Bigstring] | `is_mmapped bstr`
is_nan [Percent] |
is_nan [Float_intf.S] |
is_negative [Comparable_intf.With_zero] |
is_non_negative [Comparable_intf.With_zero] |
is_non_positive [Comparable_intf.With_zero] |
is_none [Option] | `is_none t` returns true iff t = None.
is_none [Core_weak] |
is_none [Common] |
is_null [Pool_intf.S.Pointer] |
is_ok [Stack_unit_tests] |
is_ok [Result.Export] |
is_ok [Result] |
is_positive [Comparable_intf.With_zero] |
is_pow2 [Int_pow2] |
is_pow2 [Core_int] | `is_pow2 x` returns true iff `x` is a power of 2.
is_prefix [Core_string] | `is_prefix s ~prefix` returns `true` if `s` starts with `prefix`.
is_prefix [Core_list] | `is_prefix xs ~prefix` returns `true` if `xs` starts with `prefix`.
is_print [Core_char] | ' ' - '~'
is_second [Either_intf.S] |
is_some [Option] | `is_some t` returns true iff t = Some x.
is_some [Core_weak] |
is_some [Common] |
is_sorted [Core_list] | `is_sorted t ~compare` returns `true` iff forall adjacent `a1; a2` in `t`, `compare a1 a2 <= 0`.
is_sorted [Core_array.Permissioned] |
is_sorted [Core_array] |
is_sorted_strictly [Core_list] |
is_sorted_strictly [Core_array.Permissioned] |
is_sorted_strictly [Core_array] | `is_sorted_strictly xs ~cmp` iff `is_sorted xs ~cmp` and no two consecutive elements in `xs` are equal according to `cmp`
is_substring [Core_string] | `is_substring ~substring:"bar" "foo bar baz"` is true
is_suffix [Core_string] | `is_suffix s ~suffix` returns `true` if `s` ends with `suffix`.
is_sun_or_sat [Day_of_week] |
is_uppercase [Core_char] | 'A' - 'Z'
is_val [Core_lazy] | `is_val x` returns `true` if `x` has already been forced and did not raise an exception.
is_whitespace [Core_char] | ' ' or '\t' or '\r' or '\n'
is_zero [Percent] |
iso_8601_weekday_number [Day_of_week] | As per ISO 8601, Mon->1, Tue->2, ...
iter [Timing_wheel_intf.Timing_wheel.Priority_queue] |
iter [Timing_wheel_intf.Timing_wheel] |
iter [Total_map] |
iter [Stack_unit_tests.Debug] |
iter [Result] |
iter [Quickcheck_intf.Quickcheck] | `iter ~seed ~trials ~attempts gen ~f` runs `f` on up to `trials` different values generated by `gen`.
iter [Hash_queue.Make] |
iter [Hash_heap.S] |
iter [Hash_heap.Make] |
iter [Flat_queue] |
iter [Either_intf.S] |
iter [Core_set] | `iter t ~f` calls `f` on every element of `t`, going in order from the smallest to largest.
iter [Core_map_intf.Accessors3_with_comparator] |
iter [Core_map_intf.Accessors3] |
iter [Core_map_intf.Accessors2] |
iter [Core_map_intf.Accessors1] |
iter [Core_map_intf.Accessors_generic] |
iter [Core_map] | iterator for map
iter [Core_hashtbl_intf.Accessors] |
iter [Core_gc.Control.Fields.Direct] |
iter [Core_gc.Control.Fields] |
iter [Core_gc.Stat.Fields.Direct] |
iter [Core_gc.Stat.Fields] |
iter [Container_unit_tests.Test_generic] |
iter [Container_intf.Container] |
iter [Container_intf.Make_arg] | The `iter` argument to `Container.Make` says how to implement the container's `iter` function.
iter [Container_intf.Generic_phantom] |
iter [Container_intf.Generic] |
iter [Container_intf.S1_permissions] |
iter [Container_intf.S1_phantom_invariant] |
iter [Container_intf.S1] |
iter [Container_intf.S0_phantom] |
iter [Container_intf.S0] | `iter` must allow exceptions raised in `f` to escape, terminating the iteration cleanly.
iter [Bounded_int_table] |
iter [Avltree] | iterate over the tree
iter' [Deque] | `iter' t ~f` iter over the elements of `t`.
iter2 [Total_map] |
iter2 [Core_set_intf.Accessors2_with_comparator] |
iter2 [Core_set_intf.Accessors2] |
iter2 [Core_set_intf.Accessors1] |
iter2 [Core_set_intf.Accessors0] |
iter2 [Core_set_intf.Accessors_generic] |
iter2 [Core_set] | Iterate two sets side by side.
iter2 [Core_map_intf.Accessors3_with_comparator] |
iter2 [Core_map_intf.Accessors3] |
iter2 [Core_map_intf.Accessors2] |
iter2 [Core_map_intf.Accessors1] |
iter2 [Core_map_intf.Accessors_generic] |
iter2 [Core_map] | Iterate two maps side by side.
iter2_exn [Core_list] | `List.iter2_exn [a1; ...; an] [b1; ...; bn] ~f` calls in turn `f a1 b1; ...; f an bn`.
iter2_exn [Core_array.Permissioned] |
iter2_exn [Core_array] | Functions with 2 suffix raise an exception if the lengths aren't the same.
iter_elt [Doubly_linked] |
iter_elt [Bag] |
iter_error [Result] |
iter_lines [In_channel] | `iter_lines ?fix_win_eol t ~f` applies `f` to each line read from `t` using `input_line`.
iter_vals [Hash_heap.S] | Returns the list of all (key, value) pairs for given `Hash_heap`.
iter_vals [Hash_heap.Make] |
iter_vals [Core_hashtbl_intf.Accessors] | `iter_vals t ~f` is like iter, except it only supplies the value to f, not the key.
iter_vals [Bounded_int_table] |
iteri [Sequence] | `iteri` is just like `iter`, but it also passes in the index of each element to `f`.
iteri [Hash_queue.S] | `iter t ~f` applies f to each key and element of the queue.
iteri [Hash_queue.Make] |
iteri [Deque] | `iteri t ~f` iter over the elements of t ``front_to_back` passing in the index.
iteri [Core_list] | iteri is just like iter, but it also passes in the index of each element as the first argument to the iter'd function.
iteri [Core_array.Permissioned] |
iteri [Core_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.
iteri' [Deque] | `iteri' t ~f` as `iter`, but also passes in the index of the current element.
J
join [Monad_intf.S2] |
join [Monad_intf.S] | `join t` is `t >>= (fun t' -> t')`.
K
kbprintf [Core_printf] |
keep_alive [Core_gc] |
key [Timing_wheel_intf.Timing_wheel.Priority_queue.Elt] |
keys [Hash_queue.S] | `keys t` returns the keys in the order of the queue.
keys [Hash_queue.Make] |
keys [Core_map_intf.Accessors3_with_comparator] |
keys [Core_map_intf.Accessors3] |
keys [Core_map_intf.Accessors2] |
keys [Core_map_intf.Accessors1] |
keys [Core_map_intf.Accessors_generic] |
keys [Core_map] | 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 [Core_printf] |
kilobytes [Byte_units] |
known [Flags_intf.Make_arg] | An entry `flag, name` in `known` means that the bit(s) in `flag` is (are) called `name`; i.e.
ksprintf [Std_internal] |
ksprintf [Core_printf] |
L
largest_free [Core_gc.Stat.Fields] |
largest_free [Core_gc.Stat] |
last [Doubly_linked] |
last [Core_list] | The final element of a list.
last [Core_array.Permissioned] |
last [Core_array] |
last [Avltree] |
last_elt [Doubly_linked] |
last_exn [Core_list] |
ldexp [Float_intf.S] | `ldexp x n` returns `x *. 2 ** n`
ldexp [Common] |
length [Timing_wheel_intf.Timing_wheel.Priority_queue] | `length t` returns the number of elements in the timing wheel.
length [Timing_wheel_intf.Timing_wheel] |
length [Thread_safe_queue] |
length [Stack_unit_tests.Debug] |
length [Pool_intf.S] | `length` returns the number of tuples currently in the pool.
length [Out_channel] |
length [Obj_array] |
length [Substring_intf.S] |
length [Make_substring.Base] |
length [Make_substring.F] |
length [In_channel] |
length [Hash_queue.Make] |
length [Hash_heap.S] |
length [Hash_heap.Make] |
length [Fqueue] | complexity: O(1)
length [Flat_queue] |
length [Flat_array_debug.Debug] |
length [Flat_array] | accessors
length [Core_weak] |
length [Core_string] |
length [Core_set] | Returns the number of elements in the set.
length [Core_map_intf.Accessors3_with_comparator] |
length [Core_map_intf.Accessors3] |
length [Core_map_intf.Accessors2] |
length [Core_map_intf.Accessors1] |
length [Core_map_intf.Accessors_generic] |
length [Core_map] | `length map`
length [Core_hashtbl_intf.Accessors] |
length [Core_bytes] |
length [Core_array.Permissioned] |
length [Container_unit_tests.Test_generic] |
length [Container_intf.Container] |
length [Container_intf.Generic_phantom] |
length [Container_intf.Generic] |
length [Container_intf.S1_permissions] |
length [Container_intf.S1_phantom_invariant] |
length [Container_intf.S1] |
length [Container_intf.S0_phantom] |
length [Container_intf.S0] |
length [Bounded_int_table] |
length [Blit_intf.Sequence] |
length [Binary_searchable_intf.Indexable1] |
length [Binary_searchable_intf.Indexable] |
length [Bigstring] | `length bstr`
length [Bigbuffer] | Return the number of characters currently contained in the buffer.
length_is_bounded_by [Sequence] | `length_is_bounded_by ~min ~max t` returns true if `min <= length t` and `length t <= max` When `min` or `max` are not provided, the check for that bound is omitted.
level [Bucket.S] |
level [Bucket.Make] |
level_bits [Timing_wheel_intf.Timing_wheel.Config] |
lexicographic [Comparable] | `lexicographic cmps x y` compares `x` and `y` lexicographically using functions in the list `cmps`.
lfindi [Core_string] | `lfindi ?pos t ~f` returns the smallest `i >= pos` such that `f i t.[i]`, if there is such an `i`.
lift [Type_equal.Lift3] |
lift [Type_equal.Lift2] |
lift [Type_equal.Lift] |
list [Validate] | Validates a list, naming each element using a user-defined function for computing the name
list [Type_immediacy.Sometimes] |
list [Quickcheck_observer] |
list [Quickcheck_generator] | Generator for lists of a given type.
list_indexed [Validate] | Validates a list, naming each element by its position in the list (where the first position is 1, not 0)
live_blocks [Core_gc.Stat.Fields] |
live_blocks [Core_gc.Stat] |
live_words [Core_gc.Stat.Fields] |
live_words [Core_gc.Stat] |
lookup [Hash_queue.S] | `lookup t k` returns 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 [Core_string] |
lowercase [Core_char] | Convert the given character to its equivalent lowercase character.
lsplit2 [Core_string.Escaping] | `lsplit2 s on escape_char` splits s into a pair on the first literal instance of `on` (meaning the first unescaped instance) starting from the left.
lsplit2 [Core_string] | `lsplit2 line ~on` optionally returns `line` split into two strings around the first appearance of `on` from the left
lsplit2_exn [Core_string.Escaping] |
lsplit2_exn [Core_string] | If the string `s` contains the character `on`, then `lsplit2_exn s ~on` returns a pair containing `s` split around the first appearance of `on` (from the left).
lstrip [Core_string] | `lstrip ?drop s` returns a string with consecutive chars satisfying `drop` (by default white space, e.g.
M
major [Core_gc] | Do a minor collection and finish the current major collection cycle.
major_collections [Core_gc.Stat.Fields] |
major_collections [Core_gc.Stat] |
major_collections [Core_gc] |
major_heap_increment [Core_gc.Control.Fields] |
major_heap_increment [Core_gc.Control] |
major_plus_minor_words [Core_gc] | This function returns `major_words () + minor_words ()`.
major_slice [Core_gc] | Do a minor collection and a slice of major collection.
major_words [Core_gc.Stat.Fields] |
major_words [Core_gc.Stat] |
major_words [Core_gc] |
make [Core_string] |
make [Core_random.State] | Create a new state and initialize it with the given seed.
make_creator [Core_gc.Control.Fields] |
make_creator [Core_gc.Stat.Fields] |
make_matrix [Core_array.Permissioned] |
make_matrix [Core_array] | `Array.make_matrix dimx dimy e` returns a two-dimensional array (an array of arrays) with first dimension `dimx` and second dimension `dimy`.
make_self_init [Core_random.State] | Create a new state and initialize it with a system-dependent low-entropy seed.
map [Unpack_buffer.Unpack_one] |
map [Total_map] |
map [Result] |
map [Monad_intf.S2] |
map [Monad_intf.Basic2] |
map [Monad_intf.S] | `map t ~f` is t >>| f.
map [Monad_intf.Basic] | The `map` argument to `Monad.Make` says how to implement the monad's `map` function.
map [Linked_queue] |
map [Stable_module_types.S2] |
map [Either_intf.S] |
map [Core_string] | `map f s` applies `f` to each character in `s`, and returns the resulting string.
map [Core_set_intf.Creators2_with_comparator] |
map [Core_set_intf.Creators2] |
map [Core_set_intf.Creators1] |
map [Core_set_intf.Creators0] |
map [Core_set_intf.Creators_generic] | The types of `map` and `filter_map` are subtle.
map [Core_set] | `map ~comparator t ~f` returns a new set created by applying `f` to every element in `t`.
map [Core_queue] |
map [Core_map_intf.Accessors3_with_comparator] |
map [Core_map_intf.Accessors3] |
map [Core_map_intf.Accessors2] |
map [Core_map_intf.Accessors1] |
map [Core_map_intf.Accessors_generic] |
map [Core_map] | returns new map with bound values replaced by f applied to the bound values
map [Core_list.Assoc] | Bijectivity is not guaranteed because we allow a key to appear more than once.
map [Core_list] | `List.map f [a1; ...; an]` applies function `f` to `a1, ..., an`, and builds the list `[f a1; ...; f an]` with the results returned by `f`.
map [Stable_module_types.S1] |
map [Core_hashtbl_intf.Accessors] | `map t f` returns new table with bound values replaced by `f` applied to the bound values
map [Core_gc.Control.Fields] |
map [Core_gc.Stat.Fields] |
map [Core_array.Permissioned] |
map [Core_array] | `Array.map ~f a` applies function `f` to all the elements of `a`, and builds an array with the results returned by `f`: `[| f a.(0); f a.(1); ...; f a.(Array.length a - 1) |]`.
map [Bounded_int_table] |
map [Applicative_intf.S2] |
map [Applicative_intf.Basic2] |
map [Applicative_intf.S] |
map [Applicative_intf.Basic] | The `map` argument to `Applicative.Make` says how to implement the applicative's `map` function.
map1 [Tuple.T3] |
map1 [Tuple.T2] |
map2 [Tuple.T3] |
map2 [Tuple.T2] |
map2 [Total_map] |
map2 [Option] | `map2 o f` map 'a option and 'b option to a 'c option using ~f
map2 [Applicative_intf.S2] |
map2 [Applicative_intf.S] |
map2_exn [Core_list] | `List.map2_exn [a1; ...; an] [b1; ...; bn] ~f` is `[f a1 b1; ...; f an bn]`.
map2_exn [Core_array.Permissioned] |
map2_exn [Core_array] |
map3 [Tuple.T3] |
map3 [Applicative_intf.S2] |
map3 [Applicative_intf.S] |
map3_exn [Core_list] |
mapN [Applicative_intf.Args2] |
mapN [Applicative_intf.Args] |
map_error [Result] |
map_file [Bigstring] | `map_file shared fd n` memory-maps `n` characters of the data associated with descriptor `fd` to a bigstring.
map_poly [Core_gc.Control.Fields] |
map_poly [Core_gc.Stat.Fields] |
mapi [Total_map] |
mapi [Sequence] |
mapi [Core_string] | `mapi f s` applies `f` to each character in `s` and its index, and returns the resulting string.
mapi [Core_map_intf.Accessors3_with_comparator] |
mapi [Core_map_intf.Accessors3] |
mapi [Core_map_intf.Accessors2] |
mapi [Core_map_intf.Accessors1] |
mapi [Core_map_intf.Accessors_generic] |
mapi [Core_map] | like `map`, but function takes both key and data as arguments
mapi [Core_list] | mapi is just like map, but it also passes in the index of each element as the first argument to the mapped function.
mapi [Core_hashtbl_intf.Accessors] | like `map`, but function takes both key and data as arguments
mapi [Core_array.Permissioned] |
mapi [Core_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] | marshals value `_` to a new bigstring.
marshal_blit [Bigstring_marshal] | marshals value `_` to the bigstring at most `len` bytes.
marshal_data_size [Bigstring_marshal] | the length of marshalled data in the bigstring
match_ [Univ] | `match_ t id` returns `Some v` if `t` was created by `create id v`, and returns `None` otherwise.
match_exn [Univ] |
max [Timing_wheel_intf.Interval_num.Span] |
max [Timing_wheel_intf.Interval_num] |
max [Polymorphic_compare] |
max [No_polymorphic_compare] |
max [Int_set] | `max t` the biggest number in the set (if it exists)
max [Polymorphic_compare_intf.S] |
max_allowed_key [Timing_wheel_intf.Timing_wheel.Priority_queue] | `max_allowed_key t` is the maximum allowed key that can be stored in `t`.
max_capacity [Pool_intf.S] | `max_capacity` returns the maximum capacity allowed when creating a pool.
max_elt [Stack_unit_tests.Test] |
max_elt [Stack_unit_tests.Debug] |
max_elt [Heap_intf.S] |
max_elt [Hash_queue.Make] |
max_elt [Fheap] |
max_elt [Core_set_intf.Accessors2_with_comparator] |
max_elt [Core_set_intf.Accessors2] |
max_elt [Core_set_intf.Accessors1] |
max_elt [Core_set_intf.Accessors0] |
max_elt [Core_set_intf.Accessors_generic] |
max_elt [Core_set] | Returns the largest element of the set.
max_elt [Core_map_intf.Accessors3_with_comparator] |
max_elt [Core_map_intf.Accessors3] |
max_elt [Core_map_intf.Accessors2] |
max_elt [Core_map_intf.Accessors1] |
max_elt [Core_map_intf.Accessors_generic] |
max_elt [Core_map] | `max_elt map`
max_elt [Container_unit_tests.Test_generic] |
max_elt [Container_intf.Container] |
max_elt [Container_intf.Generic_phantom] |
max_elt [Container_intf.Generic] |
max_elt [Container_intf.S1_permissions] |
max_elt [Container_intf.S1_phantom_invariant] |
max_elt [Container_intf.S1] |
max_elt [Container_intf.S0_phantom] |
max_elt [Container_intf.S0] |
max_elt_exn [Core_set_intf.Accessors2_with_comparator] |
max_elt_exn [Core_set_intf.Accessors2] |
max_elt_exn [Core_set_intf.Accessors1] |
max_elt_exn [Core_set_intf.Accessors0] |
max_elt_exn [Core_set_intf.Accessors_generic] |
max_elt_exn [Core_set] |
max_elt_exn [Core_map_intf.Accessors3_with_comparator] |
max_elt_exn [Core_map_intf.Accessors3] |
max_elt_exn [Core_map_intf.Accessors2] |
max_elt_exn [Core_map_intf.Accessors1] |
max_elt_exn [Core_map_intf.Accessors_generic] |
max_elt_exn [Core_map] |
max_finite_value [Float_intf.S] |
max_float [Common] |
max_inan [Float_intf.S] |
max_int [Common] |
max_length [Core_string] | Maximum length of a string.
max_length [Core_array] | Maximum length of a normal array.
max_num_bits [Timing_wheel_intf.Timing_wheel.Level_bits] | `max_num_bits` is how many bits in a key the timing wheel can use, i.e.
max_overhead [Core_gc.Control.Fields] |
max_overhead [Core_gc.Control] |
max_representable [Timing_wheel_intf.Interval_num] | To avoid issues with arithmetic overflow, the implementation restricts interval numbers to be `<= max_representable`, where:
max_value [Timing_wheel_intf.Interval_num] |
max_value [Time_ns.Span] |
max_value [Time_ns] |
max_value [Int_intf.S] | The largest representable integer
max_value [Float_intf.S] | equal to `infinity`
max_value [Core_char] |
maybe_raise [Validate] | If the result contains any errors, then raises an exception with a formatted error message containing a message for every error.
me_of_sexp [Perms.Stable.V1] |
me_of_sexp [Perms] |
megabytes [Byte_units] |
mem [Univ_map_intf.S1] |
mem [Univ_map_intf.S] |
mem [Timing_wheel_intf.Timing_wheel.Priority_queue] |
mem [Timing_wheel_intf.Timing_wheel] |
mem [Stack_unit_tests.Debug] |
mem [Int_set] | `mem t i` test whether `i` is a member of the set
mem [Hash_set_intf.Accessors] | override `Container.Generic.mem`
mem [Hash_queue.S] | `mem q k` returns true iff there is some (k, v) in the queue.
mem [Hash_queue.Make] |
mem [Hash_heap.S] |
mem [Hash_heap.Make] |
mem [Core_set_intf.Accessors2_with_comparator] |
mem [Core_set_intf.Accessors2] |
mem [Core_set_intf.Accessors1] |
mem [Core_set_intf.Accessors0] |
mem [Core_set_intf.Accessors_generic] | override `Container`'s `mem`
mem [Core_set] | `mem t a` returns `true` iff `a` is in `t`.
mem [Core_map_intf.Accessors3_with_comparator] |
mem [Core_map_intf.Accessors3] |
mem [Core_map_intf.Accessors2] |
mem [Core_map_intf.Accessors1] |
mem [Core_map_intf.Accessors_generic] |
mem [Core_map] | `mem map key` tests whether `map` contains a binding for `key`
mem [Core_list.Assoc] |
mem [Core_hashtbl_intf.Accessors] |
mem [Container_unit_tests.Test_generic] |
mem [Container_intf.Generic_phantom] |
mem [Container_intf.Generic] |
mem [Container_intf.S1_permissions] | Checks whether the provided element is there, using polymorphic compare if `equal` is not provided
mem [Container_intf.S1_phantom_invariant] | Checks whether the provided element is there, using polymorphic compare if `equal` is not provided
mem [Container_intf.S1] | Checks whether the provided element is there, using polymorphic compare if `equal` is not provided
mem [Container_intf.S0_phantom] | Checks whether the provided element is there using the default equality test, using the provided `equal` function if it is not
mem [Container_intf.S0] | Checks whether the provided element is there using the default equality test, using the provided `equal` function if it is not
mem [Bounded_int_table] |
mem [Avltree] | return true if key is present in the tree, otherwise return false.
memoize [Sequence] | `memoize t` produces each element of `t`, but also memoizes them so that if you consume the same element multiple times it is only computed once.
merge [Sequence] | `merge t1 t2 ~cmp` produces the interleaved elements of `t1` and `t2`, always picking the smallest of the two available elements from `t1` and `t2`, according to `cmp`.
merge [Option] | `merge a b ~f` merges together the values from `a` and `b` using `f`.
merge [Core_map_intf.Accessors3_with_comparator] |
merge [Core_map_intf.Accessors3] |
merge [Core_map_intf.Accessors2] |
merge [Core_map_intf.Accessors1] |
merge [Core_map_intf.Accessors_generic] |
merge [Core_map] | merges two maps
merge [Core_list] | Merge two lists: assuming that `l1` and `l2` are sorted according to the comparison function `cmp`, `merge cmp l1 l2` will return a sorted list containing all the elements of `l1` and `l2`.
merge [Core_hashtbl_intf.Accessors] | Merge two hashtables.
merge_into [Core_hashtbl_intf.Accessors] | Merge one hashtable into another.
microsecond [Time_ns.Span] |
millisecond [Time_ns.Span] |
min [Timing_wheel_intf.Interval_num] |
min [Polymorphic_compare] |
min [No_polymorphic_compare] |
min [Int_set] | `min t` the smallest number in the set (if it exists)
min [Polymorphic_compare_intf.S] |
min_allowed_key [Timing_wheel_intf.Timing_wheel.Priority_queue] | `min_allowed_key t` is the minimum key that can be stored in `t`.
min_elt [Timing_wheel_intf.Timing_wheel.Priority_queue] | `min_elt t` returns an element in `t` that has the minimum key, if `t` is nonempty.
min_elt [Stack_unit_tests.Test] |
min_elt [Stack_unit_tests.Debug] |
min_elt [Heap_intf.S] | Even though these two functions are part of Container.S1, they are documented separately to make sure there is no confusion.
min_elt [Hash_queue.Make] |
min_elt [Fheap] | The comparison function in `min_elt` and `max_elt` are independent of that used to order the heap.
min_elt [Core_set_intf.Accessors2_with_comparator] |
min_elt [Core_set_intf.Accessors2] |
min_elt [Core_set_intf.Accessors1] |
min_elt [Core_set_intf.Accessors0] |
min_elt [Core_set_intf.Accessors_generic] |
min_elt [Core_set] | Returns the smallest element of the set.
min_elt [Core_map_intf.Accessors3_with_comparator] |
min_elt [Core_map_intf.Accessors3] |
min_elt [Core_map_intf.Accessors2] |
min_elt [Core_map_intf.Accessors1] |
min_elt [Core_map_intf.Accessors_generic] |
min_elt [Core_map] | `min_elt map`
min_elt [Container_unit_tests.Test_generic] |
min_elt [Container_intf.Container] |
min_elt [Container_intf.Generic_phantom] |
min_elt [Container_intf.Generic] |
min_elt [Container_intf.S1_permissions] | Returns a min (resp max) element from the collection using the provided `cmp` function.
min_elt [Container_intf.S1_phantom_invariant] | Returns a min (resp max) element from the collection using the provided `cmp` function.
min_elt [Container_intf.S1] | Returns a minimum (resp maximum) element from the collection using the provided `cmp` function, or `None` if the collection is empty.
min_elt [Container_intf.S0_phantom] | Returns a min (resp max) element from the collection using the provided `cmp` function, or `None` if the collection is empty.
min_elt [Container_intf.S0] | Returns a min (resp max) element from the collection using the provided `cmp` function.
min_elt_exn [Core_set_intf.Accessors2_with_comparator] |
min_elt_exn [Core_set_intf.Accessors2] |
min_elt_exn [Core_set_intf.Accessors1] |
min_elt_exn [Core_set_intf.Accessors0] |
min_elt_exn [Core_set_intf.Accessors_generic] |
min_elt_exn [Core_set] |
min_elt_exn [Core_map_intf.Accessors3_with_comparator] |
min_elt_exn [Core_map_intf.Accessors3] |
min_elt_exn [Core_map_intf.Accessors2] |
min_elt_exn [Core_map_intf.Accessors1] |
min_elt_exn [Core_map_intf.Accessors_generic] |
min_elt_exn [Core_map] |
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_key [Timing_wheel_intf.Timing_wheel.Priority_queue] |
min_positive_normal_value [Float_intf.S] |
min_positive_subnormal_value [Float_intf.S] | `min_positive_subnormal_value = 2 ** -1074` `min_positive_normal_value = 2 ** -1022`
min_value [Timing_wheel_intf.Interval_num] |
min_value [Time_ns.Span] | The limits of `t` are chosen to allow conversion to and from `float` spans with microsecond precision.
min_value [Time_ns] |
min_value [Int_intf.S] |
min_value [Float_intf.S] | equal to `neg_infinity`
min_value [Core_char] |
minor [Core_gc] | Trigger a minor collection.
minor_collections [Core_gc.Stat.Fields] |
minor_collections [Core_gc.Stat] |
minor_collections [Core_gc] |
minor_heap_size [Core_gc.Control.Fields] |
minor_heap_size [Core_gc.Control] |
minor_words [Core_gc.Stat.Fields] |
minor_words [Core_gc.Stat] |
minor_words [Core_gc] | The following functions return the same as `(Gc.quick_stat ()).Stat.f`, avoiding any allocation (of the `stat` record or a float).
minus_one [Int_intf.S] |
minus_one [Float_intf.S] |
minute [Time_ns.Span] |
mod_float [Float_intf.S] | `mod_float x y` returns a result with the same sign as `x`.
mod_float [Common] |
modf [Float_intf.S] |
modf [Common] |
most_recent [Backtrace.Exn] | `most_recent ()` returns a string containing the stack that was unwound by the most recently raised exception.
move_after [Doubly_linked] |
move_before [Doubly_linked] |
move_to_back [Doubly_linked] |
move_to_front [Doubly_linked] | constant-time move of an element from and to positions in the same list.
N
name [Validate] | extend location path by one name
name [Type_equal.Id] |
name_list [Validate] |
names [Core_gc.Control.Fields] |
names [Core_gc.Stat.Fields] |
nan [Float_intf.S] |
nan [Common] |
nanosecond [Time_ns.Span] |
nativeint [Type_immediacy.Never] |
nativeint [Core_random.State] |
nativeint [Core_random] | `Random.nativeint bound` returns a random integer between 0 (inclusive) and `bound` (exclusive).
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 [Time_ns.Span] |
neg [Percent] |
neg [Int_math.T] |
neg [Int_intf.S.O] |
neg [Int_intf.S] | Negation
neg [Float_intf.S.O] |
neg [Float_intf.S] |
neg_infinity [Float_intf.S] |
neg_infinity [Common] |
never_returns [Never_returns] |
never_returns [Common] |
new1 [Pool_intf.S] | `new<N> t a0 ... a<N-1>` returns a new tuple from the pool, with the tuple's slots initialized to `a0` ...
new10 [Pool_intf.S] |
new11 [Pool_intf.S] |
new12 [Pool_intf.S] |
new2 [Pool_intf.S] |
new3 [Pool_intf.S] |
new4 [Pool_intf.S] |
new5 [Pool_intf.S] |
new6 [Pool_intf.S] |
new7 [Pool_intf.S] |
new8 [Pool_intf.S] |
new9 [Pool_intf.S] |
newline [Out_channel] |
next [Sequence] | `next` returns the next element of a sequence and the next tail if the sequence is not finished.
next [Doubly_linked] | constant-time retrieval of next or previous element.
next_alarm_fires_at [Timing_wheel_intf.Timing_wheel] | `next_alarm_fires_at t` returns the minimum time to which the clock can be advanced such that an alarm will fire, or `None` if `t` has no alarms.
next_multiple [Time_ns] | `next_multiple ~base ~after ~interval` returns the smallest `time` of the form:
nget [Core_string] | `nget s i` Gets the char at normalized position `i` in `s`.
nget [Core_array.Permissioned] |
nget [Core_array] | Array access with `normalize`d index.
nil [Applicative_intf.Args2] |
nil [Applicative_intf.Args] | the empty argument list *
no_raise_of_sexp [Core_sexp] | `no_raise` is the identity, but by using `'a no_raise` in a sexpable type, the resulting use `sexp_of_no_raise` protects the conversion of `'a` to a sexp so that if it fails, one gets a sexp with an error message about the failure, rather than an exception being raised.
nobody_of_sexp [Perms.Stable.V1] |
nobody_of_sexp [Perms] |
non [Fn] | Negates a function
normalize [Ordered_collection_common] |
normalize [Core_array.Permissioned] |
normalize [Core_array] | `normalize array index` returns a new index into the array such that if index is less than zero, the returned index will "wrap around" -- i.e.
not_ [Blang] |
now [Timing_wheel_intf.Timing_wheel] |
now [Time_ns] |
now_interval_num [Timing_wheel_intf.Timing_wheel] |
nset [Core_string] | `nset s i c` Sets the char at normalized position `i` to `c`.
nset [Core_array.Permissioned] |
nset [Core_array] | Array modification with `normalize`d index.
nth [Sequence] | return the nth element
nth [Core_map_intf.Accessors3_with_comparator] |
nth [Core_map_intf.Accessors3] |
nth [Core_map_intf.Accessors2] |
nth [Core_map_intf.Accessors1] |
nth [Core_map_intf.Accessors_generic] |
nth [Core_map] | `nth t n` finds the (key, value) pair of rank n (i.e.
nth [Core_list] |
nth [Bigbuffer] | get the (zero-based) n-th character of the buffer.
nth_exn [Sequence] |
nth_exn [Core_list] | Return the `n`-th element of the given list.
null [Timing_wheel_intf.Timing_wheel.Alarm] | `null ()` returns an alarm `t` such that `not (mem timing_wheel t)` for all `timing_wheel`s.
null [Pool_intf.S.Pointer] | The `null` pointer is a distinct pointer that does not correspond to a tuple in the pool.
num_bits [Timing_wheel_intf.Timing_wheel.Level_bits] | `num_bits t` is the sum of the `b_i` in `t`.
num_bits [Word_size] |
num_bits [Int_intf.S] | The number of bits available in this integer type.
num_bits_int [Int_conversions] |
num_bits_int32 [Int_conversions] |
num_bits_int64 [Int_conversions] |
num_bits_nativeint [Int_conversions] |
num_days [Day_of_week] | `num_days ~from ~to_` gives the number of days that must elapse from a `from` to get to a `to_`, i.e.
O
observe [Raw_quickcheck_observer] | `observe t gen ~sexp_of_rng ~branching_factor` constructs a generator for a function type using `t` to observe the domain and `gen` to generate the range.
of_alist [Core_map_intf.Creators3_with_comparator] |
of_alist [Core_map_intf.Creators2] |
of_alist [Core_map_intf.Creators1] |
of_alist [Core_map_intf.Creators_generic] |
of_alist [Core_map] | creates map from association list with unique keys
of_alist [Core_hashtbl_intf.Creators] |
of_alist [Bounded_int_table.With_key] | `of_alist` returns a table whose maximum allowed key is the maximum key in the input list.
of_alist_exn [Core_map_intf.Creators3_with_comparator] |
of_alist_exn [Core_map_intf.Creators2] |
of_alist_exn [Core_map_intf.Creators1] |
of_alist_exn [Core_map_intf.Creators_generic] |
of_alist_exn [Core_map] | 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.Creators3_with_comparator] |
of_alist_fold [Core_map_intf.Creators2] |
of_alist_fold [Core_map_intf.Creators1] |
of_alist_fold [Core_map_intf.Creators_generic] |
of_alist_fold [Core_map] | combines an association list into a map, folding together bound values with common keys
of_alist_multi [Core_map_intf.Creators3_with_comparator] |
of_alist_multi [Core_map_intf.Creators2] |
of_alist_multi [Core_map_intf.Creators1] |
of_alist_multi [Core_map_intf.Creators_generic] |
of_alist_multi [Core_map] | creates map from association list with possibly repeated keys.
of_alist_multi [Core_hashtbl_intf.Creators] |
of_alist_or_error [Core_map_intf.Creators3_with_comparator] |
of_alist_or_error [Core_map_intf.Creators2] |
of_alist_or_error [Core_map_intf.Creators1] |
of_alist_or_error [Core_map_intf.Creators_generic] |
of_alist_or_error [Core_map] | creates map from association list with unique keys.
of_alist_or_error [Core_hashtbl_intf.Creators] |
of_alist_reduce [Core_map_intf.Creators3_with_comparator] |
of_alist_reduce [Core_map_intf.Creators2] |
of_alist_reduce [Core_map_intf.Creators1] |
of_alist_reduce [Core_map_intf.Creators_generic] |
of_alist_reduce [Core_map] | combines an association list into a map, reducing together bound values with common keys
of_alist_report_all_dups [Core_hashtbl_intf.Creators] |
of_array [Linked_queue] |
of_array [Heap_intf.S] | `min_size` (see `create`) will be set to the size of the input array or list.
of_array [Fheap] |
of_array [Core_set_intf.Creators2_with_comparator] |
of_array [Core_set_intf.Creators2] |
of_array [Core_set_intf.Creators1] |
of_array [Core_set_intf.Creators0] |
of_array [Core_set_intf.Creators_generic] |
of_array [Core_set] |
of_array [Core_queue] |
of_array [Binary_searchable_intf.Indexable1.For_test] |
of_array [Binary_searchable_intf.Indexable.For_test] |
of_array_id [Core_array.Permissioned] | `of_array_id` and `to_array_id` return the same underlying array.
of_bigstring [Substring_intf.S] | Conversion to substrings.
of_bigstring [Make_substring.Base] |
of_bigstring [Make_substring.F] |
of_bigstring [Binable0] |
of_bigstring [Binable] |
of_bool [Blit_intf.Elt] |
of_bp [Percent] | `of_bp 5.` is 5bp = 0.05% = 0.0005x
of_bp_int [Percent] |
of_char [Core_string] |
of_char_list [Core_string] |
of_day [Time_ns.Span] |
of_error [Validate] |
of_error_opt [Validate] |
of_exn [Or_error] | `of_exn exn` is `Error (Error.of_exn exn)`.
of_exn [Info] | `of_exn` and `to_exn` are primarily used with `Error`, but their definitions have to be here because they refer to the underlying representation.
of_exn_result [Or_error] | `of_exn_result (Ok a) = Ok a`, `of_exn_result (Error exn) = of_exn exn`
of_float [Floatable.S] |
of_float [Float_intf.S.O] |
of_float [Core_int64] |
of_fun [Raw_quickcheck_observer] | `of_fun f` produces an observer that lazily applies `f`.
of_fun [Raw_quickcheck_generator] | `of_fun f` produces a generator that lazily applies `f`.
of_hashtbl_keys [Hash_set_intf.Accessors] |
of_hr [Time_ns.Span] |
of_info [Error] |
of_int [Timing_wheel_intf.Interval_num.Span] |
of_int [Timing_wheel_intf.Interval_num] |
of_int [Pid] |
of_int [Ordering] | `of_int n` is:
of_int [Month] | `of_int i` returns i'th month if `i` is in 1,2,...,12.
of_int [Float_intf.S.O] |
of_int [Float_intf.S] |
of_int [Flags_intf.S] |
of_int [Day_of_week] |
of_int [Core_nativeint] |
of_int [Core_int64] |
of_int [Core_int63] |
of_int [Core_int32] |
of_int [Core_int] |
of_int [Core_char] | Return the character with the given ASCII code or `None` is the argument is outside the range 0 to 255.
of_int32 [Core_nativeint] |
of_int32 [Core_int64] |
of_int32 [Core_int32] |
of_int32 [Core_int] |
of_int32_exn [Int_intf.S] |
of_int63 [Timing_wheel_intf.Interval_num.Span] |
of_int63 [Timing_wheel_intf.Interval_num] |
of_int63 [Pool_intf.S.Pointer.Id] |
of_int63_ns [Time_ns.Span] |
of_int63_ns_since_epoch [Time_ns] |
of_int64 [Float_intf.S] |
of_int64 [Core_nativeint] |
of_int64 [Core_int64] |
of_int64 [Core_int32] |
of_int64 [Core_int] |
of_int64_exn [Int_intf.S] |
of_int64_exn [Core_int] |
of_int64_preserve_order [Float_intf.S] |
of_int_exn [Month] |
of_int_exn [Intable.S] |
of_int_exn [Int_math.T] |
of_int_exn [Int_intf.S.O] |
of_int_exn [Day_of_week] | These use the same mapping as `Unix.tm_wday`: 0 <-> Sun, ...
of_int_exn [Core_char] | Return the character with the given ASCII code.
of_int_ns [Time_ns.Span] |
of_int_ns_since_epoch [Time_ns] |
of_int_sec [Time_ns.Span] |
of_int_style [Core_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 [Validate] | combine multiple results, merging errors
of_list [Stack_unit_tests.Test] |
of_list [Stack_unit_tests.Debug] |
of_list [Stack_intf.S] | `of_list l` returns a stack whose top is the first element of `l` and bottom is the last element of `l`.
of_list [Sequence] |
of_list [Quickcheck_observer] | `of_list list ~equal` maps values in `list` to separate buckets, and compares observed values to the elements of `list` using `equal`.
of_list [Quickcheck_generator] | Produce any of the given values, weighted equally.
of_list [Linked_queue] | `of_list list` returns a queue `t` with the elements of `list` in the same order as the elements of `list` (i.e.
of_list [Info] | Combine multiple infos into one
of_list [Heap_intf.S] |
of_list [Hash_set_intf.Creators] |
of_list [Fheap] |
of_list [Fdeque.Back_to_front] |
of_list [Fdeque.Front_to_back] |
of_list [Fdeque] | `of_list` returns a deque with elements in the same front-to-back order as the list.
of_list [Doubly_linked] | `of_list l` returns a doubly-linked list `t` with the same elements as `l` and in the same order (i.e.
of_list [Core_set_intf.Creators2_with_comparator] |
of_list [Core_set_intf.Creators2] |
of_list [Core_set_intf.Creators1] |
of_list [Core_set_intf.Creators0] |
of_list [Core_set_intf.Creators_generic] |
of_list [Core_set] | The list or array given to `of_list` and `of_array` need not be sorted.
of_list [Core_queue] | `of_list list` returns a queue `t` with the elements of `list` in the same order as the elements of `list` (i.e.
of_list [Core_list] | `of_list` is the identity function.
of_list [Core_array.Permissioned] |
of_list [Core_array] | `Array.of_list l` returns a fresh array containing the elements of `l`.
of_list [Bag] |
of_list_map [Core_array.Permissioned] |
of_list_map [Core_array] | `of_list_map l ~f` is the same as `of_list (List.map l ~f)`
of_list_rev [Core_array.Permissioned] |
of_list_rev [Core_array] | `of_list_rev l` converts from list then reverses in place
of_list_rev_map [Core_array.Permissioned] |
of_list_rev_map [Core_array] | `of_list_rev_map l ~f` is the same as `rev_inplace (of_list_map l ~f)`
of_map_keys [Core_set_intf.Creators2_with_comparator] |
of_map_keys [Core_set_intf.Creators2] |
of_map_keys [Core_set_intf.Creators1] |
of_map_keys [Core_set_intf.Creators0] |
of_map_keys [Core_set_intf.Creators_generic] | never requires a comparator because it can get one from the input `Map.t`
of_map_keys [Core_set] |
of_min [Time_ns.Span] |
of_ms [Time_ns.Span] |
of_mult [Percent] | `of_mult 5.` is 5x = 500% = 50_000bp
of_nativeint [Core_nativeint] |
of_nativeint [Core_int64] |
of_nativeint [Core_int32] |
of_nativeint [Core_int] |
of_nativeint_exn [Int_intf.S] |
of_ns [Time_ns.Span] |
of_option [Result] |
of_parts [Time_ns.Span] |
of_percentage [Percent] | `of_percentage 5.` is 5% = 0.05x = 500bp
of_predicate [Quickcheck_observer] | `of_predicate t1 t2 ~f` combines `t1` and `t2`, where `t1` observes values that satisfy `f` and `t2` observes values that do not satisfy `f`.
of_ref [Ref.Permissioned] |
of_result [Validate] | Create a validation function from a function that produces a Result.t
of_sec [Timing_wheel_intf.Timing_wheel_time.Span] |
of_sec [Time_ns.Span] |
of_sec_with_microsecond_precision [Time_ns.Span] |
of_sequence [Quickcheck_generator] | Generator for the values from a potentially infinite sequence.
of_sexp_allow_extra_fields [Core_sexp] | `of_sexp_allow_extra_fields of_sexp sexp` uses `of_sexp` to convert `sexp` to a value, but will not fail if there are any extra fields in a record (even deeply nested records).
of_sorted_array [Core_set_intf.Creators2_with_comparator] |
of_sorted_array [Core_set_intf.Creators2] |
of_sorted_array [Core_set_intf.Creators1] |
of_sorted_array [Core_set_intf.Creators0] |
of_sorted_array [Core_set_intf.Creators_generic] |
of_sorted_array [Core_set] | Create set from sorted array.
of_sorted_array [Core_map_intf.Creators3_with_comparator] |
of_sorted_array [Core_map_intf.Creators2] |
of_sorted_array [Core_map_intf.Creators1] |
of_sorted_array [Core_map_intf.Creators_generic] |
of_sorted_array [Core_map] | creates map from sorted array of key-data pairs.
of_sorted_array_unchecked [Core_set_intf.Creators2_with_comparator] |
of_sorted_array_unchecked [Core_set_intf.Creators2] |
of_sorted_array_unchecked [Core_set_intf.Creators1] |
of_sorted_array_unchecked [Core_set_intf.Creators0] |
of_sorted_array_unchecked [Core_set_intf.Creators_generic] |
of_sorted_array_unchecked [Core_set] | Similar to `of_sorted_array`, but without checking the input array.
of_sorted_array_unchecked [Core_map_intf.Creators3_with_comparator] |
of_sorted_array_unchecked [Core_map_intf.Creators2] |
of_sorted_array_unchecked [Core_map_intf.Creators1] |
of_sorted_array_unchecked [Core_map_intf.Creators_generic] |
of_sorted_array_unchecked [Core_map] | Like `of_sorted_array` except behavior is undefined when an `Error` would have been returned.
of_span_since_epoch [Time_ns] |
of_string [Sexpable.To_stringable] |
of_string [Rope] | takes O(1) time
of_string [Substring_intf.S] |
of_string [Make_substring.Base] |
of_string [Make_substring.F] |
of_string [Stringable.S] |
of_string [Info] |
of_string [Binable] |
of_string [Bigstring] | `of_string ?pos ?len str`
of_string_allow_nan_and_inf [Percent] |
of_text [Core_sexp.With_text] | Creates a `t` from the text, by first converting the text to an s-expression, and then parsing the s-expression with the provided converter.
of_thunk [Only_in_test] |
of_thunk [Info] |
of_tree [Core_set_intf.Creators2_with_comparator] |
of_tree [Core_set_intf.Creators2] |
of_tree [Core_set_intf.Creators1] |
of_tree [Core_set_intf.Creators0] |
of_tree [Core_set_intf.Creators_generic] |
of_tree [Core_set] |
of_tree [Core_map_intf.Creators3_with_comparator] |
of_tree [Core_map_intf.Creators2] |
of_tree [Core_map_intf.Creators1] |
of_tree [Core_map_intf.Creators_generic] |
of_tree [Core_map] | Creates a `t` from a `Tree.t` and a `Comparator.t`.
of_typerep [Type_immediacy.Never] |
of_typerep [Type_immediacy.Sometimes] |
of_typerep [Type_immediacy.Always] |
of_typerep [Type_immediacy] |
of_us [Time_ns.Span] |
of_value [Core_sexp.With_text] | Generates a `t` from the value by creating the text automatically using the provided s-expression converter.
ok [Result] |
ok_exn [Result] | `ok_exn t` returns `x` if `t = Ok x`, and raises `exn` if `t = Error exn`
ok_exn [Or_error] | `ok_exn t` throws an exception if `t` is an `Error`, and otherwise returns the contents of the `Ok` constructor.
ok_exn [Common] | `Or_error.ok_exn`
ok_fst [Result] | `ok_fst` is useful with `List.partition_map`.
ok_if_true [Result] | `ok_if_true` returns `Ok ()` if `bool` is true, and `Error error` if it is false
ok_or_failwith [Result] | raises `Failure` in the `Error` case
ok_unit [Result] | `ok_unit = Ok ()`, used to avoid allocation as a performance hack
on_grow [Pooled_hashtbl] | `on_grow ~before ~after` allows you to connect higher level loggers to the point where these hashtbls grow.
one [Timing_wheel_intf.Interval_num.Span] |
one [Timing_wheel_intf.Interval_num] |
one [Int_intf.S] |
one [Float_intf.S] |
one_ulp [Float_intf.S] | The next or previous representable float.
option [Type_immediacy.Sometimes] |
option [Quickcheck_observer] |
option [Quickcheck_generator] |
or_ [Blang] | n-ary `Or`
original_gen [Raw_quickcheck_generator.Choice] | `original_gen t` produces the original generator from which `t` was constructed, unmodified.
out_channel_length [Common] |
outer_of_sexp [Float_intf.S] |
output [Out_channel] |
output_binary_int [Out_channel] |
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] |
overflow_bound_max_int32_value [Pow_overflow_bounds] |
overflow_bound_max_int64_value [Pow_overflow_bounds] |
overflow_bound_max_int_value [Pow_overflow_bounds] |
P
pack_float [Binary_packing] |
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_int_big_endian [Binary_packing] |
pack_signed_64_int_little_endian [Binary_packing] |
pack_signed_64_little_endian [Binary_packing] |
pack_signed_8 [Binary_packing] |
pack_tail_padded_fixed_string [Binary_packing] | Encode and pack the given string as a tail padded fixed length string having length `len`.
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] |
pair [Validate] | Validation functions for particular data types.
partial_iter [Linked_queue] | `partial_iter t ~f` iterates through t until f returns `Stop
partition_map [Core_list] | `partition_map t ~f` partitions `t` according to `f`.
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.Accessors2_with_comparator] |
partition_tf [Core_set_intf.Accessors2] |
partition_tf [Core_set_intf.Accessors1] |
partition_tf [Core_set_intf.Accessors0] |
partition_tf [Core_set_intf.Accessors_generic] |
partition_tf [Core_set] | if `a, b = partition_tf set ~f` then `a` is the elements on which `f` produced `true`, and `b` is the elements on which `f` produces `false`.
partition_tf [Core_list] | `partition_tf l ~f` returns a pair of lists `(l1, l2)`, where `l1` is the list of all the elements of `l` that satisfy the predicate `p`, and `l2` is the list of all the elements of `l` that do not satisfy `p`.
partition_tf [Core_hashtbl_intf.Accessors] |
partition_tf [Core_array.Permissioned] |
partition_tf [Core_array] |
partitioni_tf [Core_hashtbl_intf.Accessors] |
partitioni_tf [Core_array.Permissioned] |
partitioni_tf [Core_array] |
pass [Validate] | A result containing no errors
pass_bool [Validate] | Check for unconditionally passing a bool
pass_unit [Validate] | Check for unconditionally passing a unit
peek [Linked_queue] | `peek t` returns `None` if `t` is empty, otherwise it returns `Some x` where `x` is the front of `t`.
peek [Fdeque] | `peek t side` produces `Some` of the element at the `side` of `t`, or `None` if `t` is empty.
peek [Deque] | `peek t back_or_front` return the value at the back or front of the dequeue without removing it.
peek [Core_queue] |
peek_back [Fdeque] |
peek_back [Deque] |
peek_back_exn [Fdeque] |
peek_back_exn [Deque] |
peek_exn [Linked_queue] |
peek_exn [Fdeque] |
peek_exn [Core_queue] |
peek_front [Fdeque] |
peek_front [Deque] |
peek_front_exn [Fdeque] |
peek_front_exn [Deque] |
perms_of_sexp [Perms.Export] |
permute [Quickcheck_generator] | `permute list` generates all permutations of `list`.
permute [Core_list] | `permute ?random_state t` returns a permutation of `t`.
permute [Core_array.Permissioned] |
permute [Core_array] | `permute ?random_state t` randomly permutes `t` in place.
permute [Array_permute] | randomly permute an array.
phys_compare [Pool_intf.S.Pointer] |
phys_equal [Pool_intf.S.Pointer] |
phys_equal [Common] | We disable `==` and `!=` and replace them with the longer and more mnemonic `phys_equal` because they too easily lead to mistakes (for example they don't even work right on Int64 or Float).
phys_same [Common] | `phys_same` is like `phys_equal`, but with a more general type.
pointer_is_valid [Pool_intf.S] | `pointer_is_valid t pointer` returns `true` iff `pointer` points to a live tuple in `t`, i.e.
pointer_of_id_exn [Pool_intf.S] | `pointer_of_id_exn t id` returns the pointer corresponding to `id`.
poly [Core_hashtbl_intf.Hashable] |
pop [Stack_unit_tests.Test] |
pop [Stack_unit_tests.Debug] |
pop [Stack_intf.S] | `pop t` removes and returns the top element of `t` as `Some a`, or returns `None` if `t` is empty.
pop [Heap_intf.S] | This removes and returns the top (i.e.
pop [Hash_heap.S] |
pop [Hash_heap.Make] |
pop [Fheap] | This removes and returns the top (i.e.
pop_exn [Stack_unit_tests.Test] |
pop_exn [Stack_unit_tests.Debug] |
pop_exn [Stack_intf.S] |
pop_exn [Heap_intf.S] |
pop_exn [Hash_heap.S] |
pop_exn [Hash_heap.Make] |
pop_exn [Fheap] |
pop_if [Heap_intf.S] | `pop_if t cond` returns `Some top_element` of `t` if it satisfies condition `cond`, removing it, or `None` in any other case.
pop_if [Hash_heap.S] |
pop_if [Hash_heap.Make] |
pop_if [Fheap] | `pop_if t cond` returns `Some (top_element, rest_of_heap)` if `t` is not empty and its top element satisfies condition `cond`, or `None` in any other case.
pop_if_with_key [Hash_heap.S] |
pop_if_with_key [Hash_heap.Make] |
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] |
pow [Int_intf.S] | `pow base exponent` returns `base` raised to the power of `exponent`.
pp [Pretty_printer.S] |
pp [Info] |
pred [Timing_wheel_intf.Interval_num.Span] |
pred [Timing_wheel_intf.Interval_num] |
pred [Int_intf.S] |
prefix [Substring_intf.S] |
prefix [Make_substring.F] |
prefix [Core_string] | `prefix s n` returns the longest prefix of `s` of length less than or equal to `n`
prepend [With_return] | `prepend a ~f` returns a value `x` such that each call to `x.return` first applies `f` before applying `a.return`.
prev [Doubly_linked] |
print [Core_printexc] |
print_backtrace [Core_printexc] |
print_stat [Core_gc] | Print the current values of the memory management counters (in human-readable form) into the channel argument.
printf [Std_internal] |
printf [Core_printf] |
promoted_words [Core_gc.Stat.Fields] |
promoted_words [Core_gc.Stat] |
promoted_words [Core_gc] |
protect [Validate] | `protect f x` applies the validation `f` to `x`, catching any exceptions and returning them as errors.
protect [Exn] |
protect [Common] | See exn.mli
protectx [Exn] | Executes `f` and afterwards executes `finally`, whether `f` throws an exception or not.
protectx [Common] |
push [Stack_unit_tests.Test] |
push [Stack_unit_tests.Debug] |
push [Stack_intf.S] | `push t a` adds `a` to the top of stack `t`.
push [Hash_heap.S] |
push [Hash_heap.Make] |
push_exn [Hash_heap.S] |
push_exn [Hash_heap.Make] |
Q
quick_stat [Core_gc] | Same as `stat` except that `live_words`, `live_blocks`, `free_words`, `free_blocks`, `largest_free`, and `fragments` are set to 0.
R
raise [Error] | Note that the exception raised by this function maintains a reference to the `t` passed in.
raise_without_backtrace [Exn] | Same as `raise`, except that the backtrace is not recorded.
random [Core_int63] | `random ~state bound` returns a random integer between 0 (inclusive) and `bound` (exclusive).
random_sequence [Quickcheck_intf.Quickcheck] | `random_sequence ~seed gen` produces a sequence of values chosen from `gen`.
random_state_of_seed [Quickcheck_intf.Quickcheck] | `random_state_of_seed` constructs initial random states for a given seed.
random_value [Quickcheck_intf.Quickcheck] | `random_value ~seed gen` produces a single value chosen from `gen` using `seed`.
range [Sequence] | `range ?stride ?start ?stop start_i stop_i` is the sequence of integers from `start_i` to `stop_i`, stepping by `stride`.
range [Core_list] | `range ?stride ?start ?stop start_i stop_i` is the list of integers from `start_i` to `stop_i`, stepping by `stride`.
range_to_alist [Core_map_intf.Accessors3_with_comparator] |
range_to_alist [Core_map_intf.Accessors3] |
range_to_alist [Core_map_intf.Accessors2] |
range_to_alist [Core_map_intf.Accessors1] |
range_to_alist [Core_map_intf.Accessors_generic] |
range_to_alist [Core_map] | `range_to_alist t ~min ~max` returns an associative list of the elements whose keys lie in `min, max` (inclusive), with the smallest key being at the head of the list.
ranges [Int_set] | `ranges t` return a list of all ranges that make up the set
rank [Core_map_intf.Accessors3_with_comparator] |
rank [Core_map_intf.Accessors3] |
rank [Core_map_intf.Accessors2] |
rank [Core_map_intf.Accessors1] |
rank [Core_map_intf.Accessors_generic] |
rank [Core_map] | `rank t k` if k is in t, returns the number of keys strictly less than k in t, otherwise None
raw [Validated_intf.S] |
raw [Validated_intf.Validated] |
read_all [In_channel] | `read_all filename` Opens filename, reads all input, and closes the file.
read_bin_prot [Bigstring] | The `read_bin_prot*` functions read from the region of `t` starting at `pos` of length `len`.
read_bin_prot_verbose_errors [Bigstring] |
read_lines [In_channel] | `read_lines filename` Opens filename, reads all lines, and closes the file.
read_of_sexp [Perms.Export] |
read_only [Ref.Permissioned] |
read_write_of_sexp [Perms.Export] |
really_input [In_channel] |
record_backtrace [Core_printexc] |
recursive [Quickcheck_observer] | Fixed point observer; use `recursive` to create observers for recursive types.
recursive [Quickcheck_generator] | Fixed-point generator.
reduce [Sequence] |
reduce [Core_list] |
reduce [Core_array.Permissioned] |
reduce [Core_array] | `reduce f [a1; ...; an]` is `Some (f (... (f (f a1 a2) a3) ...) an)`.
reduce_balanced [Core_list] | `reduce_balanced` returns the same value as `reduce` when `f` is associative, but differs in that the tree of nested applications of `f` has logarithmic depth.
reduce_balanced_exn [Core_list] |
reduce_exn [Sequence] | `reduce_exn f [a1; ...; an]` is `f (... (f (f a1 a2) a3) ...) an`.
reduce_exn [Core_list] | `reduce_exn [a1; ...; an] ~f` is `f (... (f (f a1 a2) a3) ...) an`.
reduce_exn [Core_array.Permissioned] |
reduce_exn [Core_array] |
ref_ [Type_immediacy.Never] |
refl [Type_equal] | `refl`, `sym`, and `trans` construct proofs that type equality is reflexive, symmetric, and transitive.
register [Pretty_printer] | `register name` adds `name` to the list of pretty printers.
rem [Timing_wheel_intf.Interval_num] |
rem [Int_math.T] |
rem [Int_intf.S] |
remove [Timing_wheel_intf.Timing_wheel.Priority_queue] | `remove t elt` removes `elt` from `t`.
remove [Timing_wheel_intf.Timing_wheel] | `remove t alarm` removes `alarm` from `t`.
remove [Hash_set_intf.Accessors] |
remove [Hash_queue.S] |
remove [Hash_queue.Make] |
remove [Hash_heap.S] |
remove [Hash_heap.Make] |
remove [Heap.Removable] | If `t` and `token` are mismatched then behavior is undefined.
remove [Doubly_linked] | constant-time removal of an element.
remove [Core_set_intf.Accessors2_with_comparator] |
remove [Core_set_intf.Accessors2] |
remove [Core_set_intf.Accessors1] |
remove [Core_set_intf.Accessors0] |
remove [Core_set_intf.Accessors_generic] |
remove [Core_set] | `remove t a` returns a new set with `a` removed from `t` if `mem t a`, or returns `t` otherwise.
remove [Core_map_intf.Accessors3_with_comparator] |
remove [Core_map_intf.Accessors3] |
remove [Core_map_intf.Accessors2] |
remove [Core_map_intf.Accessors1] |
remove [Core_map_intf.Accessors_generic] |
remove [Core_map] | returns a new map with any binding for the key in question removed
remove [Core_list.Assoc] |
remove [Core_hashtbl_intf.Accessors] |
remove [Bounded_int_table] |
remove [Bag] | `remove t elt` removes `elt` from the bag `t`, raising an exception if `elt` is not in the bag.
remove [Avltree] | remove key destructively from the tree if it exists, return the new root node.
remove_consecutive_duplicates [Sequence] | The same sequence with consecutive duplicates removed.
remove_consecutive_duplicates [Core_list] | `remove_consecutive_duplicates`.
remove_exn [Hash_queue.S] |
remove_exn [Hash_queue.Make] |
remove_first [Doubly_linked] |
remove_index [Core_set_intf.Accessors2_with_comparator] |
remove_index [Core_set_intf.Accessors2] |
remove_index [Core_set_intf.Accessors1] |
remove_index [Core_set_intf.Accessors0] |
remove_index [Core_set_intf.Accessors_generic] |
remove_index [Core_set] | `remove_index t i` returns a version of `t` with the `i`th smallest element removed, in `O(log n)` time.
remove_last [Doubly_linked] |
remove_multi [Core_hashtbl_intf.Accessors] | `remove_multi t key` updates the table, removing the head of the list bound to `key`.
remove_one [Core_hashtbl_intf.Accessors] |
remove_one [Bag] | `remove_one t` removes some element from the bag, and returns its value.
remove_top [Heap_intf.S] | `remove_top t` does nothing if `t` is empty
remove_top [Fheap] | `remove_top t` returns the new heap after a remove.
remove_zero_flags [Flags_intf.Make_arg] | If `remove_zero_flags`, then all flags with value zero will be automatically removed from `known`.
repeat [Sequence] | `repeat a` repeats `a` forever.
replace [Ref.Permissioned] |
replace [Ref] | `replace t f` is `t := f !t`
replace [Hash_queue.S] | `replace q k v` changes the value of key k in the queue to v.
replace [Hash_queue.Make] |
replace [Hash_heap.S] |
replace [Hash_heap.Make] |
replace [Core_hashtbl_intf.Accessors] |
replace [Core_array.Permissioned] |
replace [Core_array] | `replace t i ~f` = `t.(i) <- f (t.(i))`.
replace_all [Core_string.Search_pattern] |
replace_all [Core_array.Permissioned] |
replace_all [Core_array] | modifies an array in place -- `ar.(i)` will be set to `f(ar.(i))`
replace_exn [Hash_queue.S] |
replace_exn [Hash_queue.Make] |
replace_first [Core_string.Search_pattern] | Note that the result of `replace_all pattern ~in_:text ~with_:r` may still contain `pattern`, e.g.
reraise [Exn] |
reraise_uncaught [Exn] | Traces exceptions passing through.
reraisef [Exn] | Types with `format4` are hard to read, so here's an example.
reschedule [Timing_wheel_intf.Timing_wheel] | `reschedule t alarm ~at` mutates `alarm` so that it will fire at `at`, i.e.
reschedule_at_interval_num [Timing_wheel_intf.Timing_wheel] |
reset [Caml_modify] | `reset ()` reset the counter to `0`.
reset [Bigbuffer] | Empty the buffer and deallocate the internal string holding the buffer contents, replacing it with the initial internal string of length `n` that was allocated by `Bigbuffer.create` `n`.
resize [Pooled_hashtbl] | `resize t size` ensures that `t` can hold at least `size` entries without resizing (again), provided that `t` has growth enabled.
resize [Bigbuffer_internal] |
result [Validate] |
return [Monad_intf.S2] |
return [Monad_intf.Basic2] |
return [Monad_intf.S] | `return v` returns the (trivial) computation that returns v.
return [Monad_intf.Basic] | The following identities ought to hold (for some value of =):
return [Applicative_intf.S2] |
return [Applicative_intf.Basic2] |
return [Applicative_intf.S] |
return [Applicative_intf.Basic] |
rev [Fdeque] | `rev t` returns `t`, reversed.
rev [Core_string] | `rev t` returns `t` in reverse order.
rev [Core_list] | List reversal.
rev_append [Core_list] | `List.rev_append l1 l2` reverses `l1` and concatenates it to `l2`.
rev_filter [Core_list] | Like `filter`, but reverses the order of the input list
rev_filter_map [Core_list] | `rev_filter_map l ~f` is the reversed sublist of `l` containing only elements for which `f` returns `Some e`.
rev_filter_mapi [Core_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 [Core_array.Permissioned] |
rev_inplace [Core_array] | `rev_inplace t` reverses `t` in place
rev_map [Core_list] | `List.rev_map l ~f` gives the same result as `List.rev``(``ListLabels.map` `f l)`, but is more efficient.
rev_map2_exn [Core_list] | `List.rev_map2_exn l1 l2 ~f` gives the same result as `List.rev (List.map2_exn l1 l2 ~f)`, but is more efficient.
rev_map3_exn [Core_list] |
rev_map_append [Core_list] | `rev_map_append l1 l2 ~f` reverses `l1` mapping `f` over each element, and appends the result to the front of `l2`.
rev_mapi [Core_list] |
rfindi [Core_string] | `rfindi ?pos t ~f` returns the largest `i <= pos` such that `f i t.[i]`, if there is such an `i`.
rindex [Core_string.Escaping] | `rindex s ~escape_char char` find the first literal (not escaped) instance of char in s starting from the end of s and proceeding towards 0.
rindex [Core_string] |
rindex_exn [Core_string.Escaping] |
rindex_exn [Core_string] |
rindex_from [Core_string.Escaping] | `rindex_from s ~escape_char pos char` find the first literal (not escaped) instance of char in s starting from pos and towards 0.
rindex_from [Core_string] |
rindex_from_exn [Core_string.Escaping] |
rindex_from_exn [Core_string] |
robust_comparison_tolerance [Float_robust_compare.S] | intended to be a tolerance on human-entered floats
robust_comparison_tolerance [Float_intf.S] | See `Robust_compare`
robustly_compare [Robustly_comparable.S] |
round [Std_internal] |
round [Int_intf.Round] |
round [Float_intf.S] | `round` rounds a float to an integer float.
round_down [Int_intf.Round] |
round_down [Float_intf.S] |
round_nearest [Int_intf.Round] |
round_nearest [Float_intf.S] |
round_towards_zero [Int_intf.Round] |
round_towards_zero [Float_intf.S] |
round_up [Int_intf.Round] |
round_up [Float_intf.S] |
rsplit2 [Core_string.Escaping] | `rsplit2 s on escape_char` splits `s` into a pair on the first literal instance of `on` (meaning the first unescaped instance) starting from the right.
rsplit2 [Core_string] | `rsplit2 line ~on` optionally returns `line` split into two strings around the first appearance of `on` from the right
rsplit2_exn [Core_string.Escaping] |
rsplit2_exn [Core_string] | If the string `s` contains the character `on`, then `rsplit2_exn s ~on` returns a pair containing `s` split around the first appearance of `on` (from the right).
rstrip [Core_string] | `rstrip ?drop s` returns a string with consecutive chars satisfying `drop` (by default white space, e.g.
run [Sequence.Generator] |
S
same [Type_equal.Id] | `same_witness t1 t2` and `same_witness_exn t1 t2` return a type equality proof iff the two identifiers are the same (i.e.
same_class [Union_find] | `same_class t1 t2` returns true iff `t1` and `t2` are in the same equivalence class.
same_witness [Type_equal.Id] |
same_witness_exn [Type_equal.Id] |
scale [Timing_wheel_intf.Timing_wheel_time.Span] |
scale [Time_ns.Span] |
scale [Percent] | `scale t x` scales the percent `t` by `x`, returning a new `t`
scale [Float_intf.S] |
scale [Byte_units] | `scale t mul` scale the measure `t` by `mul`
scale_int [Timing_wheel_intf.Interval_num.Span] |
scale_int [Time_ns.Span] |
scale_int63 [Time_ns.Span] |
second [Time_ns.Span] |
second [Either_intf.S] |
seek [Out_channel] |
seek [In_channel] |
seek_in [Common] |
seek_out [Common] |
self_init [Core_random] | Initialize the generator with a more-or-less random seed chosen in a system-dependent way.
set [Univ_map_intf.S1] |
set [Univ_map_intf.S] |
set [Univ_map.Multi] |
set [Univ_map.With_fold] | reset the accumulator
set [Univ_map.With_default] |
set [Union_find] | `set t v` sets the value of the class of `t` to `v`.
set [Total_map] |
set [Set_once] |
set [Ref.Permissioned] | `set` and `(:=)` are two names for the same function.
set [Pool_intf.S] |
set [Obj_array] |
set [Flat_queue] |
set [Flat_array_debug.Debug] |
set [Flat_array] |
set [Core_weak] |
set [Core_string] |
set [Core_queue] |
set [Core_hashtbl_intf.Accessors] |
set [Core_gc] | `set r` changes the GC parameters according to the `control` record `r`.
set [Core_array.Permissioned] |
set [Core_array] | `Array.set a n x` modifies array `a` in place, replacing element number `n` with `x`.
set [Bounded_int_table] |
set [Blit_intf.Sequence] |
set [Bigstring] | `set t pos` sets the character at `pos`
set_all_mutable_fields [Core_gc.Control.Fields.Direct] |
set_all_mutable_fields [Core_gc.Stat.Fields.Direct] |
set_all_slots [Flat_queue] |
set_all_slots [Flat_array_debug.Debug] |
set_all_slots [Flat_array] |
set_allocation_policy [Core_gc.Control] |
set_binary_mode [Out_channel] |
set_binary_mode [In_channel] |
set_capacity [Flat_queue] | `set_capacity t capacity` sets the length of the array backing `t` to as small as value as possible that is not less than `max capacity (length t)`.
set_capacity [Core_stack] | `set_capacity t capacity` sets the length of the array backing `t` to `max capacity (length t)`.
set_capacity [Core_queue] | `set_capacity t capacity` sets the capacity of `t`'s backing array to at least `max capacity (length t)`.
set_exn [Set_once] |
set_exn [Deque] | `set_exn t i v` mutate the element at `i`.
set_major_heap_increment [Core_gc.Control] |
set_max_overhead [Core_gc.Control] |
set_minor_heap_size [Core_gc.Control] |
set_recording [Backtrace.Exn] |
set_space_overhead [Core_gc.Control] |
set_stack_limit [Core_gc.Control] |
set_state [Core_random] | Set the state of the generator used by the basic functions.
set_tail_padded_fixed_string [Bigstring] |
set_to_init [Flat_array_debug.Debug] |
set_to_init [Flat_array] | `set_to_init t i` sets flat tuple `i` to the `init` that was supplied to `create`.
set_verbose [Core_gc.Control] |
sexp [Unpack_buffer.Unpack_one] |
sexp [Quickcheck_observer] |
sexp [Quickcheck_generator] |
sexp_of_decimal [Std_kernel] |
sexp_of_exn [Std_internal] |
sexp_of_fn_with_sexp [Quickcheck_generator] |
sexp_of_immutable [Perms.Export] |
sexp_of_int_style [Int_conversions] | global ref affecting whether the `sexp_of_t` returned by `Make` is consistent with the `to_string` input or the `to_string_hum` output
sexp_of_key [Core_hashtbl_intf.Accessors] |
sexp_of_me [Perms.Stable.V1] |
sexp_of_me [Perms] |
sexp_of_never_returns [Never_returns] |
sexp_of_never_returns [Common] |
sexp_of_no_raise [Core_sexp] |
sexp_of_nobody [Perms.Stable.V1] |
sexp_of_nobody [Perms] |
sexp_of_outer [Float_intf.S] |
sexp_of_perms [Perms.Export] |
sexp_of_read [Perms.Export] |
sexp_of_read_write [Perms.Export] |
sexp_of_t [Validated_intf.Validated] |
sexp_of_t [Validated_intf.Raw] |
sexp_of_t [Univ_map_intf.S1] |
sexp_of_t [Univ_map_intf.S] |
sexp_of_t [Timing_wheel_intf.Timing_wheel.Priority_queue.Elt] |
sexp_of_t [Timing_wheel_intf.Timing_wheel.Priority_queue] |
sexp_of_t [Timing_wheel_intf.Timing_wheel.Config] |
sexp_of_t [Timing_wheel_intf.Timing_wheel.Level_bits] |
sexp_of_t [Timing_wheel_intf.Timing_wheel.Alarm] |
sexp_of_t [Timing_wheel_intf.Timing_wheel] |
sexp_of_t [Timing_wheel_intf.Interval_num.Span] |
sexp_of_t [Timing_wheel_intf.Interval_num] |
sexp_of_t [Timing_wheel_intf.Timing_wheel_time.Span] |
sexp_of_t [Timing_wheel_intf.Timing_wheel_time] |
sexp_of_t [Unpack_buffer] |
sexp_of_t [Univ] |
sexp_of_t [Unique_id_intf.Id] |
sexp_of_t [Type_equal.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 [Total_map.Key] |
sexp_of_t [Total_map.S] |
sexp_of_t [Thread_safe_queue] |
sexp_of_t [String_id.S.Stable.V1] |
sexp_of_t [Time_ns.Alternate_sexp] |
sexp_of_t [Time_ns.Span.Alternate_sexp] |
sexp_of_t [Time_ns.Span.Parts] |
sexp_of_t [Stack_unit_tests.Debug] |
sexp_of_t [Stack_intf.S] |
sexp_of_t [Stable_unit_test_intf.Unordered_container_arg] |
sexp_of_t [Stable_containers.Hashable.V1.S.Hash_set] |
sexp_of_t [Stable_containers.Hashable.V1.S.Table] |
sexp_of_t [Source_code_position0.Stable.V1] |
sexp_of_t [Source_code_position] |
sexp_of_t [Sexpable.S3] |
sexp_of_t [Sexpable.S2] |
sexp_of_t [Sexpable.S1] |
sexp_of_t [Sexpable.Of_stringable] |
sexp_of_t [Sexpable.Of_sexpable1] |
sexp_of_t [Sexpable.Of_sexpable] |
sexp_of_t [Set_once] |
sexp_of_t [Sequence.Step] |
sexp_of_t [Sequence] |
sexp_of_t [Stable_unit_test_intf.Arg] | `tests` is a list of (value, sexp-representation, bin-io-representation) triples.
sexp_of_t [Result] |
sexp_of_t [Ref.Permissioned] |
sexp_of_t [Ref] |
sexp_of_t [Pool_intf.S.Pointer.Id] |
sexp_of_t [Pool_intf.S.Pointer] |
sexp_of_t [Pool_intf.S] |
sexp_of_t [Pid] |
sexp_of_t [Perms.Stable.V1.Upper_bound] |
sexp_of_t [Perms.Stable.V1.Read_write] |
sexp_of_t [Perms.Stable.V1.Immutable] |
sexp_of_t [Perms.Stable.V1.Write] |
sexp_of_t [Perms.Stable.V1.Read] |
sexp_of_t [Perms.Upper_bound] |
sexp_of_t [Perms.Read_write] |
sexp_of_t [Perms.Immutable] |
sexp_of_t [Perms.Write] |
sexp_of_t [Perms.Read] |
sexp_of_t [Percent.Stable.V1] |
sexp_of_t [Ordering] |
sexp_of_t [Or_error] |
sexp_of_t [Option] |
sexp_of_t [Obj_array] |
sexp_of_t [Nothing0] |
sexp_of_t [Nothing.Stable.V1] |
sexp_of_t [Month.Stable.V1] |
sexp_of_t [Month] |
sexp_of_t [Linked_queue] |
sexp_of_t [Stable_module_types.S2] |
sexp_of_t [Sexpable.S] |
sexp_of_t [Int_intf.S] |
sexp_of_t [Int_intf.Hexable.Hex] |
sexp_of_t [Int_conversions.Make] |
sexp_of_t [Stable_module_types.S0] |
sexp_of_t [Info] |
sexp_of_t [Identifiable.S] |
sexp_of_t [Host_and_port.Stable.V1] |
sexp_of_t [Heap_intf.S] |
sexp_of_t [Heap_block] |
sexp_of_t [Hash_set_intf.S] |
sexp_of_t [Hash_set.Poly] |
sexp_of_t [Hash_set] |
sexp_of_t [Hash_queue.S] |
sexp_of_t [Hash_queue.Make] |
sexp_of_t [Heap.Removable.Elt] |
sexp_of_t [Fqueue.Stable.V1] |
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 [Flat_queue] |
sexp_of_t [Flat_array_debug.Debug] |
sexp_of_t [Tuple_type_intf.Slot] |
sexp_of_t [Tuple_type_intf.Slots] |
sexp_of_t [Flat_array] |
sexp_of_t [Flags_intf.S] |
sexp_of_t [Fheap] |
sexp_of_t [Fdeque.Stable.V1] |
sexp_of_t [Fdeque] |
sexp_of_t [Exn] |
sexp_of_t [Either_intf.S] |
sexp_of_t [Doubly_linked.Elt] |
sexp_of_t [Doubly_linked] |
sexp_of_t [Deque] |
sexp_of_t [Decimal] |
sexp_of_t [Day_of_week.Stable.V1] |
sexp_of_t [Day_of_week] |
sexp_of_t [Core_weak] |
sexp_of_t [Core_string.Search_pattern] |
sexp_of_t [Core_string] |
sexp_of_t [Core_sexp.With_text] |
sexp_of_t [Core_sexp.Sexp_maybe] |
sexp_of_t [Core_sexp] |
sexp_of_t [Core_set_intf.S0.Tree] |
sexp_of_t [Core_set_intf.S0.Elt] |
sexp_of_t [Core_set_intf.S0] |
sexp_of_t [Core_set_intf.Elt_binable] |
sexp_of_t [Core_set_intf.Elt] |
sexp_of_t [Core_set.Poly.Tree] |
sexp_of_t [Core_set.Poly] |
sexp_of_t [Core_set.Tree] |
sexp_of_t [Core_queue] |
sexp_of_t [Core_map_intf.S.Tree] |
sexp_of_t [Core_map_intf.S] |
sexp_of_t [Core_map_intf.Key_binable] |
sexp_of_t [Core_map_intf.Key] |
sexp_of_t [Core_map.Poly.Tree] |
sexp_of_t [Core_map.Poly] |
sexp_of_t [Core_map.Tree] |
sexp_of_t [Core_list.Assoc] |
sexp_of_t [Core_list] |
sexp_of_t [Stable_module_types.S1] |
sexp_of_t [Core_lazy.T_unforcing] |
sexp_of_t [Core_lazy] |
sexp_of_t [Core_hashtbl_intf.Hashtbl.Poly] |
sexp_of_t [Core_hashtbl_intf.Hashtbl] |
sexp_of_t [Core_hashtbl_intf.S] |
sexp_of_t [Core_hashtbl_intf.Key] |
sexp_of_t [Core_gc.Expert.Alarm] |
sexp_of_t [Core_gc.Control] |
sexp_of_t [Core_gc.Stat] |
sexp_of_t [Core_char] |
sexp_of_t [Core_array.Permissioned.Float] |
sexp_of_t [Core_array.Permissioned.Int] |
sexp_of_t [Core_array.Permissioned] |
sexp_of_t [Core_array.Float] |
sexp_of_t [Core_array.Int] |
sexp_of_t [Core_array] |
sexp_of_t [Container_unit_tests.Test_generic] |
sexp_of_t [Constrained_float.S] |
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 [Blit_intf.Sequence] |
sexp_of_t [Blang.Stable.V1] |
sexp_of_t [Blang] |
sexp_of_t [Bigstring] |
sexp_of_t [Bigbuffer_internal] |
sexp_of_t [Bag.Elt] |
sexp_of_t [Bag] |
sexp_of_t [Backtrace] |
sexp_of_t1 [Tuple_type_intf.Slots] |
sexp_of_t10 [Tuple_type_intf.Slots] |
sexp_of_t11 [Tuple_type_intf.Slots] |
sexp_of_t12 [Tuple_type_intf.Slots] |
sexp_of_t2 [Tuple_type_intf.Slots] |
sexp_of_t3 [Tuple_type_intf.Slots] |
sexp_of_t4 [Tuple_type_intf.Slots] |
sexp_of_t5 [Tuple_type_intf.Slots] |
sexp_of_t6 [Tuple_type_intf.Slots] |
sexp_of_t7 [Tuple_type_intf.Slots] |
sexp_of_t8 [Tuple_type_intf.Slots] |
sexp_of_t9 [Tuple_type_intf.Slots] |
sexp_of_t_hum [Source_code_position0] |
sexp_of_t_hum [Source_code_position] |
sexp_of_t_now [Timing_wheel_intf.Timing_wheel] | `<:sexp_of< _ t_now >>` displays only `now t`, not all the alarms.
sexp_of_write [Perms.Export] |
shift [Month] | `shift t i` goes forward (or backward) the specified number of months
shift [Day_of_week] | This goes forward (or backward) the specified number of weekdays
shift_left [Sequence] | `shift_left t n` is a synonym for `drop t n`.
shift_left [Int_intf.S] | shifts left, filling in with zeroes
shift_right [Sequence] | `shift_right t a` produces `a` and then produces each element of `t`.
shift_right [Int_intf.S] | shifts right, filling in with zeroes, which will not preserve the sign of the input
shift_right_logical [Int_intf.S] |
shift_right_with_list [Sequence] | `shift_right_with_list t l` produces the elements of `l`, then produces the elements of `t`.
should_print_error [Flags_intf.Make_arg] | `should_print_error` says whether to print an error message if there is an error in the known flags.
show_messages [Pool_intf.Pool.Debug] |
show_messages [Flat_queue_debug.Debug] |
show_messages [Debug.Make] | If true, you get a message on stderr every time `debug` is called
show_messages [Core_queue_debug.Debug] |
sign [Float_intf.S] |
similar [Core_hashtbl_intf.Accessors] |
since_unix_epoch [Time_ns.Span] |
singleton [Sequence] | `singleton a` produces `a` exactly once.
singleton [Raw_quickcheck_observer] | maps all values to a single bucket.
singleton [Raw_quickcheck_generator] | Constant generator.
singleton [Quickcheck_generator] |
singleton [Obj_array] |
singleton [Linked_queue] |
singleton [Fqueue] |
singleton [Fdeque] | A one-element deque.
singleton [Core_set_intf.Creators2_with_comparator] |
singleton [Core_set_intf.Creators2] |
singleton [Core_set_intf.Creators1] |
singleton [Core_set_intf.Creators0] |
singleton [Core_set_intf.Creators_generic] |
singleton [Core_set] | Creates a set based on the provided comparator that contains only the provided element.
singleton [Core_queue] |
singleton [Core_map_intf.Creators3_with_comparator] |
singleton [Core_map_intf.Creators2] |
singleton [Core_map_intf.Creators1] |
singleton [Core_map_intf.Creators_generic] |
singleton [Core_map] | map with one key, data pair
size [Quickcheck_generator] | `size` produces a geometric distribution (think "radioactive decay") starting at 0 and increasing with probability 0.25.
size [Bucket.S] |
size [Bucket.Make] |
skip [Bigstring_marshal] |
slice [Ordered_collection_common] |
slice [Core_string] | `slice s start stop` gets a slice of `s` between `start` and `stop`.
slice [Core_list] | `slice l start stop` returns a new list including elements `l.(start)` through `l.(stop-1)`, normalized python-style.
slice [Core_array.Permissioned] |
slice [Core_array] | `slice array start stop` returns a fresh array including elements `array.(start)` through `array.(stop-1)` with the small tweak that the start and stop positions are normalized and a stop index of 0 means the same thing a stop index of `Array.length array`.
slots [Flat_array_debug.Debug] |
slots [Flat_array] |
slots_per_tuple [Tuple_type_intf.Slots] |
small [Binary_searchable_intf.Indexable.For_test] |
snd3 [Common] |
some [Option] |
some_if [Option] |
sort [Core_list] | Sort a list in increasing order according to a comparison function.
sort [Core_array.Permissioned] |
sort [Core_array] | `sort` uses constant heap space.
sort_and_align [Core_arg] | Like `align`, except that the specification list is also sorted by key
sorted_copy [Core_array.Permissioned] |
sorted_copy [Core_array] | `sorted_copy ar cmp` returns a shallow copy of `ar` that is sorted.
space_overhead [Core_gc.Control.Fields] |
space_overhead [Core_gc.Control] |
specialize [Blang] | `specialize t f` partially evaluates `t` according to a perhaps-incomplete assignment `f` of the values of base propositions.
split [Core_string.Escaping] | `split s ~escape_char ~on`
split [Core_string] | `split s ~on`
split [Core_set_intf.Accessors2_with_comparator] |
split [Core_set_intf.Accessors2] |
split [Core_set_intf.Accessors1] |
split [Core_set_intf.Accessors0] |
split [Core_set_intf.Accessors_generic] |
split [Core_set] | `split t x` produces a triple `(t1, maybe_x, t2)` where `t1` is the set of elements strictly less than `x`, `maybe_x` is the member (if any) of `t` which compares equal to `x`, and `t2` is the set of elements strictly larger than `x`.
split [Core_map_intf.Accessors3_with_comparator] |
split [Core_map_intf.Accessors3] |
split [Core_map_intf.Accessors2] |
split [Core_map_intf.Accessors1] |
split [Core_map_intf.Accessors_generic] |
split [Core_map] | `split t key` returns a map of keys strictly less than `key`, the mapping of `key` if any, and a map of keys strictly greater than `key`.
split [Core_array.Permissioned] |
split [Core_array] | `split ar` splits an array of pairs into two arrays of single elements.
split_lines [Core_string] | `split_lines t` returns the list of lines that comprise `t`.
split_n [Core_list] | `split_n n [e1; ...; em]` is `([e1; ...; en], [en+1; ...; em])`.
split_n_eagerly [Sequence] | `split_n_eagerly t n` immediately consumes the first `n` elements of `t` and returns the consumed prefix, as a new stream, along with the unevaluated tail of `t`.
split_on_chars [Core_string.Escaping] | `split_on_chars s ~on`
split_on_chars [Core_string] | `split_on_chars s ~on`
split_while [Core_list] | `split_while xs ~f = (take_while xs ~f, drop_while xs ~f)`
sprintf [Std_internal] |
sprintf [Core_printf] |
stable_dedup [Std_internal.List] | `stable_dedup` Same as `dedup` but 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_list [Core_set_intf.Creators2_with_comparator] |
stable_dedup_list [Core_set_intf.Creators2] |
stable_dedup_list [Core_set_intf.Creators1] |
stable_dedup_list [Core_set_intf.Creators0] |
stable_dedup_list [Core_set_intf.Creators_generic] |
stable_dedup_list [Core_set] | `stable_dedup_list` is here rather than in the `List` module because the implementation relies crucially on sets, and because doing so allows one to avoid uses of polymorphic comparison by instantiating the functor at a different implementation of `Comparator` and using the resulting `stable_dedup_list`.
stable_dedup_staged [Std_internal.List] |
stable_sort [Core_list] | Same as sort, but guaranteed to be stable
stable_sort [Core_array.Permissioned] |
stable_sort [Core_array] |
stack_limit [Core_gc.Control.Fields] |
stack_limit [Core_gc.Control] |
stack_size [Core_gc.Stat.Fields] |
stack_size [Core_gc.Stat] |
stage [Staged] |
stage [Common] | See `module : Staged` for documentation
start [Timing_wheel_intf.Timing_wheel] |
stat [Core_gc] | Return the current values of the memory management counters in a `stat` record.
stderr [Out_channel] |
stdin [In_channel] |
stdout [Out_channel] |
step [Applicative_intf.Args2] |
step [Applicative_intf.Args] | Transform argument values in some way.
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 [Type_immediacy.Never] |
string [Quickcheck_observer] |
string [Quickcheck_generator] |
string_bigstring [Make_substring.Blit] |
string_of [Quickcheck_generator] |
string_of_float [Common] |
string_string [Make_substring.Blit] |
strip [Type_equal.Injective2] |
strip [Type_equal.Injective] |
strip [Core_string] | `strip ?drop s` returns a string with consecutive chars satisfying `drop` (by default white space, e.g.
sub [Timing_wheel_intf.Interval_num] |
sub [Timing_wheel_intf.Timing_wheel_time] |
sub [Time_ns] |
sub [Sequence] | `sub t ~pos ~len` is the `len`-element subsequence of `t`, starting at `pos`.
sub [Float_intf.S] |
sub [Flat_array_debug.Debug] |
sub [Core_list] | `sub pos len l` is the `len`-element sublist of `l`, starting at `pos`.
sub [Blit_intf.S_distinct] |
sub [Blit_intf.S1_permissions] |
sub [Blit_intf.S1] |
sub [Blit_intf.S_permissions] |
sub [Blit_intf.S] |
sub_shared [Bigstring] | `sub_shared ?pos ?len bstr`
subo [Flat_array_debug.Debug] |
subo [Blit_intf.S_distinct] |
subo [Blit_intf.S1_permissions] |
subo [Blit_intf.S1] |
subo [Blit_intf.S_permissions] |
subo [Blit_intf.S] |
subset [Core_set_intf.Accessors2_with_comparator] |
subset [Core_set_intf.Accessors2] |
subset [Core_set_intf.Accessors1] |
subset [Core_set_intf.Accessors0] |
subset [Core_set_intf.Accessors_generic] |
subset [Core_set] | `subset t1 t2` returns true iff `t1` is a subset of `t2`.
substr_index [Core_string] | Substring search and replace convenience functions.
substr_index_all [Core_string] |
substr_index_exn [Core_string] |
substr_replace_all [Core_string] |
substr_replace_first [Core_string] | As with `Search_pattern.replace_all`, the result may still contain `pattern`.
succ [Timing_wheel_intf.Interval_num.Span] |
succ [Timing_wheel_intf.Interval_num] |
succ [Int_intf.S] |
suffix [Substring_intf.S] |
suffix [Make_substring.F] |
suffix [Core_string] | `suffix s n` returns the longest suffix of `s` of length less than or equal to `n`
sum [Stack_unit_tests.Debug] |
sum [Hash_queue.Make] |
sum [Core_set] | `sum t` returns the sum of `f t` for each `t` in the set.
sum [Container_unit_tests.Test_generic] |
sum [Container_intf.Container] |
sum [Container_intf.Generic_phantom] |
sum [Container_intf.Generic] |
sum [Container_intf.S1_permissions] | Returns the sum of `f i` for i in the container
sum [Container_intf.S1_phantom_invariant] | Returns the sum of `f i` for i in the container
sum [Container_intf.S1] | Returns the sum of `f i` for i in the container
sum [Container_intf.S0_phantom] | Returns the sum of `f i` for i in the container
sum [Container_intf.S0] | Returns the sum of `f i` for i in the container
swap [Tuple.T2] |
swap [Ref.Permissioned] |
swap [Ref] | `swap t1 t2` swaps the values in `t1` and `t2`.
swap [Either_intf.S] |
swap [Core_array.Permissioned] |
swap [Core_array] | `swap arr i j` swaps the value at index `i` with that at index `j`.
swap [Array_permute] |
sym [Type_equal] |
symmetric_diff [Core_set_intf.Accessors2_with_comparator] |
symmetric_diff [Core_set_intf.Accessors2] |
symmetric_diff [Core_set_intf.Accessors1] |
symmetric_diff [Core_set_intf.Accessors0] |
symmetric_diff [Core_set_intf.Accessors_generic] |
symmetric_diff [Core_set] | `symmetric_diff t1 t2` returns a sequence of changes between `t1` and `t2`.
symmetric_diff [Core_map_intf.Accessors3_with_comparator] |
symmetric_diff [Core_map_intf.Accessors3] |
symmetric_diff [Core_map_intf.Accessors2] |
symmetric_diff [Core_map_intf.Accessors1] |
symmetric_diff [Core_map_intf.Accessors_generic] |
symmetric_diff [Core_map] | `symmetric_diff t1 t2 ~data_equal` returns a list of changes between `t1` and `t2`.
T
t0 [Tuple_type_intf.Slot] |
t1 [Tuple_type_intf.Slot] |
t1 [Tuple_type_intf.Slots] |
t10 [Tuple_type_intf.Slot] |
t10 [Tuple_type_intf.Slots] |
t11 [Tuple_type_intf.Slot] |
t11 [Tuple_type_intf.Slots] |
t12 [Tuple_type_intf.Slots] |
t2 [Tuple_type_intf.Slot] |
t2 [Tuple_type_intf.Slots] |
t3 [Tuple_type_intf.Slot] |
t3 [Tuple_type_intf.Slots] |
t4 [Tuple_type_intf.Slot] |
t4 [Tuple_type_intf.Slots] |
t5 [Tuple_type_intf.Slot] |
t5 [Tuple_type_intf.Slots] |
t6 [Tuple_type_intf.Slot] |
t6 [Tuple_type_intf.Slots] |
t7 [Tuple_type_intf.Slot] |
t7 [Tuple_type_intf.Slots] |
t8 [Tuple_type_intf.Slot] |
t8 [Tuple_type_intf.Slots] |
t9 [Tuple_type_intf.Slot] |
t9 [Tuple_type_intf.Slots] |
t_of_sexp [Validated_intf.Validated] |
t_of_sexp [Validated_intf.Raw] |
t_of_sexp [Timing_wheel_intf.Timing_wheel.Config] |
t_of_sexp [Timing_wheel_intf.Timing_wheel.Level_bits] |
t_of_sexp [Timing_wheel_intf.Interval_num.Span] |
t_of_sexp [Timing_wheel_intf.Interval_num] |
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 [Total_map.Key] |
t_of_sexp [Total_map.S] |
t_of_sexp [String_id.S.Stable.V1] |
t_of_sexp [Time_ns.Alternate_sexp] |
t_of_sexp [Time_ns.Span.Alternate_sexp] |
t_of_sexp [Time_ns.Span.Parts] |
t_of_sexp [Stack_unit_tests.Debug] |
t_of_sexp [Stack_intf.S] |
t_of_sexp [Stable_unit_test_intf.Unordered_container_arg] |
t_of_sexp [Stable_containers.Hashable.V1.S.Hash_set] |
t_of_sexp [Stable_containers.Hashable.V1.S.Table] |
t_of_sexp [Source_code_position0.Stable.V1] |
t_of_sexp [Source_code_position] |
t_of_sexp [Sexpable.S3] |
t_of_sexp [Sexpable.S2] |
t_of_sexp [Sexpable.S1] |
t_of_sexp [Sexpable.Of_stringable] |
t_of_sexp [Sexpable.Of_sexpable1] |
t_of_sexp [Sexpable.Of_sexpable] |
t_of_sexp [Set_once] |
t_of_sexp [Stable_unit_test_intf.Arg] |
t_of_sexp [Result] |
t_of_sexp [Ref.Permissioned] |
t_of_sexp [Ref] |
t_of_sexp [Pool_intf.S.Pointer.Id] |
t_of_sexp [Pid] |
t_of_sexp [Perms.Stable.V1.Upper_bound] |
t_of_sexp [Perms.Stable.V1.Read_write] |
t_of_sexp [Perms.Stable.V1.Immutable] |
t_of_sexp [Perms.Stable.V1.Write] |
t_of_sexp [Perms.Stable.V1.Read] |
t_of_sexp [Perms.Upper_bound] |
t_of_sexp [Perms.Read_write] |
t_of_sexp [Perms.Immutable] |
t_of_sexp [Perms.Write] |
t_of_sexp [Perms.Read] |
t_of_sexp [Percent.Stable.V1] |
t_of_sexp [Ordering] |
t_of_sexp [Or_error] |
t_of_sexp [Option] |
t_of_sexp [Nothing0] |
t_of_sexp [Nothing.Stable.V1] |
t_of_sexp [Month.Stable.V1] |
t_of_sexp [Month] |
t_of_sexp [Linked_queue] |
t_of_sexp [Stable_module_types.S2] |
t_of_sexp [Sexpable.S] |
t_of_sexp [Int_intf.S] |
t_of_sexp [Int_intf.Hexable.Hex] |
t_of_sexp [Stable_module_types.S0] |
t_of_sexp [Info] |
t_of_sexp [Identifiable.S] |
t_of_sexp [Host_and_port.Stable.V1] |
t_of_sexp [Hash_set_intf.S] |
t_of_sexp [Hash_set.Poly] |
t_of_sexp [Fqueue.Stable.V1] |
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 [Flags_intf.S] |
t_of_sexp [Fdeque.Stable.V1] |
t_of_sexp [Fdeque] |
t_of_sexp [Either_intf.S] |
t_of_sexp [Doubly_linked] |
t_of_sexp [Deque] |
t_of_sexp [Decimal] |
t_of_sexp [Day_of_week.Stable.V1] |
t_of_sexp [Day_of_week] |
t_of_sexp [Core_string] |
t_of_sexp [Core_sexp.With_text] |
t_of_sexp [Core_sexp.Sexp_maybe] |
t_of_sexp [Core_sexp] |
t_of_sexp [Core_set_intf.S0.Tree] |
t_of_sexp [Core_set_intf.S0.Elt] |
t_of_sexp [Core_set_intf.S0] |
t_of_sexp [Core_set_intf.Elt_binable] |
t_of_sexp [Core_set_intf.Elt] |
t_of_sexp [Core_set.Poly.Tree] |
t_of_sexp [Core_set.Poly] |
t_of_sexp [Core_queue] |
t_of_sexp [Core_map_intf.S.Tree] |
t_of_sexp [Core_map_intf.S] |
t_of_sexp [Core_map_intf.Key_binable] |
t_of_sexp [Core_map_intf.Key] |
t_of_sexp [Core_map.Poly.Tree] |
t_of_sexp [Core_map.Poly] |
t_of_sexp [Core_list.Assoc] |
t_of_sexp [Core_list] |
t_of_sexp [Stable_module_types.S1] |
t_of_sexp [Core_lazy] |
t_of_sexp [Core_hashtbl_intf.Hashtbl.Poly] |
t_of_sexp [Core_hashtbl_intf.S] |
t_of_sexp [Core_hashtbl_intf.Key] |
t_of_sexp [Core_gc.Control] |
t_of_sexp [Core_gc.Stat] |
t_of_sexp [Core_char] |
t_of_sexp [Core_array.Permissioned.Float] |
t_of_sexp [Core_array.Permissioned.Int] |
t_of_sexp [Core_array.Permissioned] |
t_of_sexp [Core_array.Float] |
t_of_sexp [Core_array.Int] |
t_of_sexp [Core_array] |
t_of_sexp [Container_unit_tests.Test_generic] |
t_of_sexp [Constrained_float.S] |
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 [Bag] |
t_of_sexp_allow_nan_and_inf [Percent] |
tag [Or_error] | `tag t string` is `Result.map_error t ~f:(fun e -> Error.tag e string)`.
tag [Info] | Add a string to the front.
tag_arg [Or_error] |
tag_arg [Info] | Add a string and some other data in the form of an s-expression at the front.
take [Sequence] | `take t n` produces the first `n` elements of `t`.
take [Core_list] | `take l n` is `fst (split_n n l)`.
take [Bucket.S] |
take [Bucket.Make] |
take_at_most [Bucket.S] |
take_at_most [Bucket.Make] |
take_while [Sequence] | `take_while t ~f` produces the longest prefix of `t` for which `f` applied to each element is `true`.
take_while [Core_list] | `take_while l ~f` returns the longest prefix of `l` for which `f` is `true`.
test [Quickcheck_intf.Quickcheck] | `test ~seed ~trials ~attempts ~sexp_of ~examples gen ~f` is like `iter`, with optional concrete `examples` that are tested before values from `gen`, and additional information provided on failure.
test [Binary_packing] |
test_can_generate [Quickcheck_intf.Quickcheck] | `test_can_generate ~seed ~trials ~attempts ~sexp_of gen ~f` is useful for testing `Generator.t` values, to make sure they can generate useful examples.
test_no_duplicates [Quickcheck_intf.Quickcheck] | `test_no_duplicates ~seed ~trials ~attempts ~sexp_of gen ~by` is useful for testing `Generator.t` values, to make sure they do not create duplicate values.
tests [Stable_unit_test_intf.Unordered_container_arg] |
tests [Stable_unit_test_intf.Arg] |
text [Core_sexp.With_text] |
tl [Sequence] | `tl t` and `tl_eagerly_exn t` immediately evaluate the first element of `t` and return the unevaluated tail.
tl [Core_list] |
tl_eagerly_exn [Sequence] |
tl_exn [Core_list] | Return the given list without its first element.
to_alist [Univ_map_intf.S1] |
to_alist [Univ_map_intf.S] |
to_alist [Total_map] |
to_alist [Hash_heap.S] |
to_alist [Hash_heap.Make] |
to_alist [Core_map_intf.Accessors3_with_comparator] |
to_alist [Core_map_intf.Accessors3] |
to_alist [Core_map_intf.Accessors2] |
to_alist [Core_map_intf.Accessors1] |
to_alist [Core_map_intf.Accessors_generic] |
to_alist [Core_map] | 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 [Stack_unit_tests.Debug] |
to_array [Linked_queue] |
to_array [Hash_queue.Make] |
to_array [Core_set] |
to_array [Container_unit_tests.Test_generic] |
to_array [Container_intf.Container] |
to_array [Container_intf.Generic_phantom] |
to_array [Container_intf.Generic] |
to_array [Container_intf.S1_permissions] |
to_array [Container_intf.S1_phantom_invariant] |
to_array [Container_intf.S1] |
to_array [Container_intf.S0_phantom] |
to_array [Container_intf.S0] |
to_array_id [Core_array.Permissioned] |
to_bigstring [Substring_intf.S] | these two functions perform a copy
to_bigstring [Make_substring.F] |
to_bigstring [Binable0] |
to_bigstring [Binable] |
to_bp [Percent] |
to_bp_int [Percent] | rounds down
to_day [Time_ns.Span] |
to_exn [Info] |
to_float [Floatable.S] |
to_float [Core_int64] |
to_hr [Time_ns.Span] |
to_info [Error] |
to_int [Pid] |
to_int [Month] | `to_int t` returns an int in 1,2,...12.
to_int [Float_intf.S] |
to_int [Day_of_week] |
to_int [Core_nativeint] |
to_int [Core_int64] |
to_int [Core_int63] |
to_int [Core_int32] |
to_int [Core_int] |
to_int [Core_char] | Return the ASCII code of the argument.
to_int32 [Core_nativeint] |
to_int32 [Core_int64] |
to_int32 [Core_int32] |
to_int32 [Core_int] |
to_int32_exn [Int_intf.S] |
to_int32_exn [Core_nativeint] |
to_int63 [Timing_wheel_intf.Interval_num.Span] |
to_int63 [Timing_wheel_intf.Interval_num] |
to_int63 [Pool_intf.S.Pointer.Id] |
to_int63_ns [Time_ns.Span] | Fast, implemented as the identity function.
to_int63_ns_since_epoch [Time_ns] |
to_int64 [Int_intf.S] |
to_int64 [Float_intf.S] |
to_int64_preserve_order [Float_intf.S] | An order-preserving bijection between all floats except for nans, and all int64s with absolute value smaller than or equal to `2**63 - 2**52`.
to_int64_preserve_order_exn [Float_intf.S] | returns `nan` if the absolute value of the argument is too large
to_int_exn [Timing_wheel_intf.Interval_num.Span] |
to_int_exn [Timing_wheel_intf.Interval_num] |
to_int_exn [Intable.S] |
to_int_exn [Flags_intf.S] |
to_int_exn [Core_nativeint] |
to_int_ns [Time_ns.Span] | Will raise on 32-bit platforms.
to_int_ns_since_epoch [Time_ns] | Will raise on 32-bit platforms.
to_int_sec [Time_ns.Span] |
to_list [Stack_unit_tests.Debug] |
to_list [Sequence] |
to_list [Linked_queue] |
to_list [Hash_queue.Make] |
to_list [Fqueue] | `to_list t` returns a list of the elements in `t` in order from least-recently-added (at the head) to most-recently added (at the tail).
to_list [Fheap] | The elements of `to_list t` are not in any particular order.
to_list [Core_set] | `to_list` and `to_array` produce sequences sorted in ascending order according to the comparator.
to_list [Core_gc.Control.Fields] |
to_list [Core_gc.Stat.Fields] |
to_list [Container_unit_tests.Test_generic] |
to_list [Container_intf.Container] |
to_list [Container_intf.Generic_phantom] |
to_list [Container_intf.Generic] |
to_list [Container_intf.S1_permissions] |
to_list [Container_intf.S1_phantom_invariant] |
to_list [Container_intf.S1] |
to_list [Container_intf.S0_phantom] |
to_list [Container_intf.S0] |
to_list_rev [Sequence] | `to_list_rev t` returns a list of the elements of `t`, in reverse order.
to_list_rev [Core_string] | Returns the reversed list of characters contained in a list.
to_map [Total_map] |
to_map [Core_set_intf.Accessors2_with_comparator] |
to_map [Core_set_intf.Accessors2] |
to_map [Core_set_intf.Accessors1] |
to_map [Core_set_intf.Accessors0] |
to_map [Core_set_intf.Accessors_generic] |
to_map [Core_set] | Convert a set to or from a map.
to_min [Time_ns.Span] |
to_ms [Time_ns.Span] |
to_mult [Percent] |
to_nativeint [Core_nativeint] |
to_nativeint [Core_int64] |
to_nativeint [Core_int32] |
to_nativeint [Core_int] |
to_nativeint_exn [Int_intf.S] |
to_ns [Time_ns.Span] |
to_option [Either_intf.Focused] |
to_padded_compact_string [Float_intf.S] | Produce a lossy compact string representation of the float.
to_parts [Time_ns.Span] |
to_percentage [Percent] |
to_ref [Ref.Permissioned] |
to_sec [Time_ns.Span] |
to_sequence [Fheap] | `to_sequence t` is a sequence of the elements of `t` in ascending order.
to_sequence [Doubly_linked] |
to_sequence [Core_set_intf.Accessors2_with_comparator] |
to_sequence [Core_set_intf.Accessors2] |
to_sequence [Core_set_intf.Accessors1] |
to_sequence [Core_set_intf.Accessors0] |
to_sequence [Core_set_intf.Accessors_generic] |
to_sequence [Core_set] | `to_sequence t` converts the set `t` to a sequence of the elements between `greater_or_equal_to` and `less_or_equal_to` inclusive in the order indicated by `order`.
to_sequence [Core_map_intf.Accessors3_with_comparator] |
to_sequence [Core_map_intf.Accessors3] |
to_sequence [Core_map_intf.Accessors2] |
to_sequence [Core_map_intf.Accessors1] |
to_sequence [Core_map_intf.Accessors_generic] |
to_sequence [Core_map] | `to_sequence ?order ?keys_greater_or_equal_to ?keys_less_or_equal_to t` gives a sequence of key-value pairs between `keys_less_or_equal_to` and `keys_greater_or_equal_to` inclusive, presented in `order`.
to_sequence [Core_array.Permissioned] |
to_sequence [Core_array] | `to_sequence t` converts `t` to a sequence.
to_sequence_immutable [Core_array.Permissioned] | `to_sequence_immutable t` converts `t` to a sequence.
to_sequence_mutable [Core_array.Permissioned] |
to_sequence_mutable [Core_array] | `to_sequence_mutable t` converts `t` to a sequence.
to_sexp [Type_equal.Id] |
to_span_since_epoch [Time_ns] |
to_string [Source_code_position0] |
to_string [Source_code_position] | `to_string t` converts `t` to the form `"FILE:LINE:COL"`.
to_string [Sexpable.To_stringable] |
to_string [Rope] | takes time proportional to `n+m` where `n` is the total size of the result and `m` is the number of strings being concatenated
to_string [Substring_intf.S] |
to_string [Make_substring.F] |
to_string [Stringable.S] |
to_string [Int_set] |
to_string [Exn] |
to_string [Core_printexc] |
to_string [Core_list] |
to_string [Core_bin_prot.Writer] |
to_string [Binable] |
to_string [Bigstring] | `to_string ?pos ?len bstr`
to_string [Backtrace] |
to_string_hum [Int_intf.S] | `delimiter` is underscore by default
to_string_hum [Int_intf.Hexable.Hex] |
to_string_hum [Int_conversions.Make] |
to_string_hum [Info] | `to_string_hum` forces the lazy message, which 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 [Byte_units] | `to_string_hum ?measure t` returns a string representation of `t`.
to_string_hum_deprecated [Info] | old version (pre 109.61) of `to_string_hum` that some applications rely on.
to_string_long [Day_of_week] | Capitalized full day names rather than all-caps 3-letter abbreviations
to_string_mach [Info] | `to_string_mach t` outputs `t` as a sexp on a single-line.
to_string_mach [Exn] |
to_string_round_trippable [Float_intf.S] | Like `to_string`, but guaranteed to be round-trippable.
to_tree [Core_set_intf.Accessors2_with_comparator] |
to_tree [Core_set_intf.Accessors2] |
to_tree [Core_set_intf.Accessors1] |
to_tree [Core_set_intf.Accessors0] |
to_tree [Core_set_intf.Accessors_generic] |
to_tree [Core_set] |
to_tree [Core_map_intf.Accessors3_with_comparator] |
to_tree [Core_map_intf.Accessors3] |
to_tree [Core_map_intf.Accessors2] |
to_tree [Core_map_intf.Accessors1] |
to_tree [Core_map_intf.Accessors_generic] |
to_tree [Core_map] |
to_us [Time_ns.Span] |
top [Stack_unit_tests.Test] |
top [Stack_unit_tests.Debug] |
top [Stack_intf.S] | `top t` returns `Some a`, where `a` is the top of `t`, unless `is_empty t`, in which case `top` returns `None`.
top [Heap_intf.S] | returns the top (i.e., smallest) element of the heap
top [Hash_heap.S] |
top [Hash_heap.Make] |
top [Fqueue] | like `top_exn`, but returns result optionally, without exception, Complexity: O(1)
top [Fheap] | This returns the top (i.e.
top_exn [Stack_unit_tests.Test] |
top_exn [Stack_unit_tests.Debug] |
top_exn [Stack_intf.S] |
top_exn [Heap_intf.S] |
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 [Fheap] |
top_heap_words [Core_gc.Stat.Fields] |
top_heap_words [Core_gc.Stat] |
top_heap_words [Core_gc] |
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 [Core_string] | `tr target replacement s` replaces every instance of `target` in `s` with `replacement`.
tr_inplace [Core_string] | `tr_inplace target replacement s` destructively modifies s (in place!) replacing every instance of `target` in `s` with `replacement`.
trans [Type_equal] |
transfer [Linked_queue] | `transfer ~src ~dst` adds all of the elements of `src` to the end of `dst`, then clears `src`.
transfer [Doubly_linked] | `transfer ~src ~dst` has the same behavior as `iter src ~f:(insert_last dst); clear src` except that it runs in constant time.
transfer [Bag] | `transfer ~src ~dst` moves all of the elements from `src` to `dst` in constant time.
transpose [Core_list] | `transpose m` transposes the rows and columns of the matrix `m`, considered as either a row of column lists or (dually) a column of row lists.
transpose_exn [Core_list] | `transpose_exn` transposes the rows and columns of its argument, throwing an exception if the list is not rectangular.
trd3 [Common] |
true_ [Blang] |
truncate [Obj_array] | `truncate t ~len` shortens `t`'s length to `len`.
truncate [Core_array.Permissioned] |
truncate [Core_array] | `truncate t ~len` drops `length t - len` elements from the end of `t`, changing `t` so that `length t = len` afterwards.
truncate [Common] |
try_with [Result] |
try_with [Or_error] | `try_with f` catches exceptions thrown by `f` and returns them in the Result.t as an Error.t.
try_with [Option] | `try_with f` returns `Some x` if `f` returns `x` and `None` if `f` raises an exception.
try_with_join [Or_error] |
tune [Core_gc] | Adjust the specified GC parameters.
tuple [Host_and_port] |
tuple2 [Type_immediacy.Never] |
tuple2 [Type_equal] |
tuple2 [Raw_quickcheck_observer] |
tuple2 [Quickcheck_generator] |
tuple3 [Type_immediacy.Never] |
tuple3 [Raw_quickcheck_observer] |
tuple3 [Quickcheck_generator] |
tuple4 [Type_immediacy.Never] |
tuple4 [Raw_quickcheck_observer] |
tuple4 [Quickcheck_generator] |
tuple5 [Type_immediacy.Never] |
tuple5 [Raw_quickcheck_observer] |
tuple5 [Quickcheck_generator] |
tuple6 [Raw_quickcheck_observer] |
tuple6 [Quickcheck_generator] |
type_id_name [Univ] |
type_id_uid [Univ] |
typename_of_outer [Float_intf.S] |
typename_of_sexp_array [Std_internal] |
typename_of_sexp_bool [Std_internal] |
typename_of_sexp_list [Std_internal] |
typename_of_sexp_opaque [Std_internal] |
typename_of_sexp_option [Std_internal] |
typename_of_t [Unit] |
typename_of_t [Tuple.T3] |
typename_of_t [Tuple.T2] |
typename_of_t [Time_ns.Span] |
typename_of_t [Time_ns] |
typename_of_t [Ref] |
typename_of_t [Option] |
typename_of_t [Int_intf.S] |
typename_of_t [Int_intf.Hexable.Hex] |
typename_of_t [Float_intf.S] |
typename_of_t [Flags_intf.S] |
typename_of_t [Either_intf.S] |
typename_of_t [Core_string] |
typename_of_t [Core_list] |
typename_of_t [Core_lazy] |
typename_of_t [Core_char] |
typename_of_t [Core_array] |
typename_of_t [Bool] |
typerep_of_outer [Float_intf.S] |
typerep_of_sexp_array [Std_internal] |
typerep_of_sexp_bool [Std_internal] |
typerep_of_sexp_list [Std_internal] |
typerep_of_sexp_opaque [Std_internal] |
typerep_of_sexp_option [Std_internal] |
typerep_of_t [Unit] |
typerep_of_t [Tuple.T3] |
typerep_of_t [Tuple.T2] |
typerep_of_t [Time_ns.Span] |
typerep_of_t [Time_ns] |
typerep_of_t [Ref] |
typerep_of_t [Option] |
typerep_of_t [Int_intf.S] |
typerep_of_t [Int_intf.Hexable.Hex] |
typerep_of_t [Float_intf.S] |
typerep_of_t [Flags_intf.S] |
typerep_of_t [Either_intf.S] |
typerep_of_t [Core_string] |
typerep_of_t [Core_list] |
typerep_of_t [Core_lazy] |
typerep_of_t [Core_char] |
typerep_of_t [Core_array] |
typerep_of_t [Bool] |
U
uid [Type_equal.Id] |
uncapitalize [Core_string] |
unchecked_iter [Doubly_linked] | `unchecked_iter t ~f` behaves like `iter t ~f` except that `f` is allowed to modify `t`.
unchecked_iter [Bag] | `unchecked_iter t ~f` behaves like `iter t ~f` except that `f` is allowed to modify `t`.
uncurry [Tuple.T3] |
uncurry [Tuple.T2] |
unescape [Core_string.Escaping] | `unescape ~escape_char` is defined as `unescape_gen_exn ~map:[] ~escape_char`
unescape_gen [Core_string.Escaping] |
unescape_gen_exn [Core_string.Escaping] | `unescape_gen_exn` is the inverse operation of `escape_gen_exn`.
unfold [Sequence] | `unfold ~init f` is a simplified version of `unfold_step` that does not allow `Skip`.
unfold_step [Sequence] | `unfold_step ~init ~f` constructs a sequence by giving an initial state `init` and a function `f` explaining how to continue the next step from a given state.
unfold_with [Sequence] | `unfold_with t ~init ~f` folds a state through the sequence `t` to create a new sequence
unfold_with_and_finish [Sequence] | `unfold_with_and_finish t ~init ~running_step ~inner_finished ~finishing_step` folds a state through the sequence `t` to create a new sequence.
unimplemented [Or_error] | For marking a given value as unimplemented.
union [Union_find] | `union t1 t2` makes the class of `t1` and the class of `t2` be the same (if they are already equal, then nothing changes).
union [Quickcheck_generator] | Combine arbitary generators, weighted equally.
union [Core_set_intf.Accessors2_with_comparator] |
union [Core_set_intf.Accessors2] |
union [Core_set_intf.Accessors1] |
union [Core_set_intf.Accessors0] |
union [Core_set_intf.Accessors_generic] |
union [Core_set] | `union t1 t2` returns the union of the two sets.
union_list [Core_set_intf.Creators2_with_comparator] |
union_list [Core_set_intf.Creators2] |
union_list [Core_set_intf.Creators1] |
union_list [Core_set_intf.Creators0] |
union_list [Core_set_intf.Creators_generic] |
union_list [Core_set] | `union ~comparator list` returns the union of all the sets in `list`.
unit [Type_immediacy.Always] |
unit [Quickcheck_observer] | Observers for basic types.
unit [Quickcheck_generator] |
unit [Memo] | efficient special case for argument type `unit`
unmap [Raw_quickcheck_observer] | `unmap t ~f ~f_sexp` applies `f` to values before observing them using `t`.
unmarshal [Bigstring_marshal] | unmarshals a value from the bigstring and/or returns the index of the byte in the bigstring right after the unmarshalled value.
unmarshal_next [Bigstring_marshal] |
unordered_append [Core_list] | `List.unordered_append l1 l2` has the same elements as `l1 @ l2`, but in some unspecified order.
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_into [Unpack_buffer] | `unpack_into t q` unpacks all the values that it can from `t` and enqueues them in `q`.
unpack_iter [Unpack_buffer] | `unpack_iter t ~f` unpacks all the values that it can from `t`, calling `f` on each value as it's unpacked.
unpack_signed_16 [Binary_packing] | The functions ending with `_big_endian` or `_little_endian` are faster than the ones with explicit `byte_order` argument:
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_int_big_endian [Binary_packing] |
unpack_signed_64_int_little_endian [Binary_packing] |
unpack_signed_64_little_endian [Binary_packing] |
unpack_signed_8 [Binary_packing] |
unpack_tail_padded_fixed_string [Binary_packing] | Decode the fixed length tail padded string having length `len` from `buf` starting at `pos`.
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] |
unreachable_code [Nothing] | Because there are no values of type `Nothing.t`, a piece of code that has a value of type `Nothing.t` must be unreachable.
unsafe_blit [Flat_array_debug.Debug] |
unsafe_blit [Core_array.Permissioned.Float] |
unsafe_blit [Core_array.Permissioned.Int] |
unsafe_blit [Core_array.Float] |
unsafe_blit [Core_array.Int] |
unsafe_blit [Blit_intf.S_distinct] |
unsafe_blit [Blit_intf.S1_permissions] |
unsafe_blit [Blit_intf.S1] |
unsafe_blit [Blit_intf.S_permissions] |
unsafe_blit [Blit_intf.S] |
unsafe_clear_if_pointer [Obj_array] | `unsafe_clear_if_pointer t i` prevents `t.(i)` from pointing to anything to prevent space leaks.
unsafe_destroy [Bigstring] | `unsafe_destroy bstr` destroys the bigstring by deallocating its associated data or, if memory-mapped, unmapping the corresponding file, and setting all dimensions to zero.
unsafe_free [Pool_intf.S] | `unsafe_free t pointer` frees the tuple pointed to by `pointer` without checking `pointer_is_valid`
unsafe_get [Pool_intf.S] |
unsafe_get [Obj_array] |
unsafe_get [Flat_queue] |
unsafe_get [Flat_array_debug.Debug] |
unsafe_get [Flat_array] |
unsafe_get [Core_string] |
unsafe_get [Core_array.Permissioned] |
unsafe_get [Core_array] | Unsafe version of `get`.
unsafe_get_int16_be [Bigstring] |
unsafe_get_int16_le [Bigstring] | 16 bit methods
unsafe_get_int32_be [Bigstring] |
unsafe_get_int32_le [Bigstring] | 32 bit methods
unsafe_get_int32_t_be [Bigstring] |
unsafe_get_int32_t_le [Bigstring] | 32 bit methods w/ full precision
unsafe_get_int64_be_exn [Bigstring] |
unsafe_get_int64_be_trunc [Bigstring] |
unsafe_get_int64_le_exn [Bigstring] |
unsafe_get_int64_le_trunc [Bigstring] |
unsafe_get_int64_t_be [Bigstring] |
unsafe_get_int64_t_le [Bigstring] | 64 bit methods w/ full precision
unsafe_get_int8 [Bigstring] |
unsafe_get_uint16_be [Bigstring] |
unsafe_get_uint16_le [Bigstring] |
unsafe_get_uint32_be [Bigstring] |
unsafe_get_uint32_le [Bigstring] |
unsafe_get_uint8 [Bigstring] |
unsafe_input_value [In_channel] |
unsafe_of_int [Core_char] |
unsafe_set [Pool_intf.S] |
unsafe_set [Obj_array] |
unsafe_set [Flat_queue] |
unsafe_set [Flat_array_debug.Debug] |
unsafe_set [Flat_array] |
unsafe_set [Core_string] |
unsafe_set [Core_array.Permissioned] |
unsafe_set [Core_array] | Unsafe version of `set`.
unsafe_set_assuming_currently_int [Obj_array] | `unsafe_set_assuming_currently_int t i obj` sets index `i` of `t` to `obj`, but only works correctly if `Obj.is_int (get t i)`.
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_int8 [Bigstring] |
unsafe_set_int_assuming_currently_int [Obj_array] |
unsafe_set_uint16_be [Bigstring] |
unsafe_set_uint16_le [Bigstring] |
unsafe_set_uint32_be [Bigstring] |
unsafe_set_uint32_le [Bigstring] |
unsafe_set_uint8 [Bigstring] |
unstage [Staged] |
unstage [Common] |
until_empty [Stack_unit_tests.Test] |
until_empty [Stack_unit_tests.Debug] |
until_empty [Stack_intf.S] | `until_empty t f` repeatedly pops an element `a` off of `t` and runs `f a`, until `t` becomes empty.
until_empty [Bag] | `until_empty t f` repeatedly removes a value `v` from `t` and runs `f v`, continuing until `t` is empty.
unzip [Core_list] | Transform a list of pairs into a pair of lists: `unzip [(a1,b1); ...; (an,bn)]` is `([a1; ...; an], [b1; ...; bn])`.
update [Heap.Removable] | `update t token v` is shorthand for `remove t token; add_removable t v`
updated_gen [Raw_quickcheck_generator.Choice] | `updated_gen t ~keep` produces a generator representing a subset of the probability distribution from which `t` was constructed.
uppercase [Core_string] |
uppercase [Core_char] | Convert the given character to its equivalent uppercase character.
uw [Common] | Option handling
V
valid_or_error [Validate] | Returns an error if validation fails.
validate [Validated_intf.Raw] |
validate [Percent] |
validate [Option] |
validate [Core_map_intf.Accessors3_with_comparator] |
validate [Core_map_intf.Accessors3] |
validate [Core_map_intf.Accessors2] |
validate [Core_map_intf.Accessors1] |
validate [Core_map_intf.Accessors_generic] |
validate [Core_map] |
validate [Core_hashtbl_intf.Accessors] |
validate_binio_deserialization [Validated_intf.Raw_binable] | `validate_binio_deserialization` controls whether when the binio representation of a value is deserialized, the resulting value is validated.
validate_bound [Comparable_intf.Validate] |
validate_lbound [Comparable_intf.Validate] |
validate_negative [Comparable_intf.With_zero] |
validate_non_negative [Comparable_intf.With_zero] |
validate_non_positive [Comparable_intf.With_zero] |
validate_ordinary [Float_intf.S] | `validate_ordinary` fails if class is `Nan` or `Infinite`.
validate_positive [Comparable_intf.With_zero] |
validate_ubound [Comparable_intf.Validate] |
value [Timing_wheel_intf.Timing_wheel.Priority_queue.Elt] |
value [Timing_wheel_intf.Timing_wheel.Alarm] |
value [Raw_quickcheck_generator.Choice] | `value t` produces the value chosen from `original_gen t`.
value [Option] | `value None ~default` = `default` `value (Some x) ~default` = `x`
value [Heap_block] | `value t` returns the value that is physically equal to `t`
value [Either_intf.S] |
value [Either_intf.Focused] |
value [Doubly_linked.Elt] |
value [Core_sexp.With_text] |
value [Bag.Elt] |
value_as_int [Type_immediacy.Sometimes] |
value_as_int [Type_immediacy.Always] |
value_as_int [Type_immediacy] |
value_as_int_exn [Type_immediacy.Sometimes] |
value_as_int_exn [Type_immediacy] |
value_exn [Option] | `value_exn (Some x)` = `x`.
value_exn [Heap.Removable.Elt] | `value_exn t` return the value in the heap controlled by this token if the value is still in the heap.
value_is_int [Type_immediacy.Sometimes] |
value_is_int [Type_immediacy] |
value_map [Option] | `value_map ~default ~f` is the same as `function Some x -> f x | None -> default`
value_map [Either_intf.S] |
values [Blang] | `values t` forms the list containing every `v` for which `Base v` is a subexpression of `t`
variant2 [Raw_quickcheck_observer] |
variant2 [Quickcheck_generator] |
variant3 [Quickcheck_observer] |
variant3 [Quickcheck_generator] |
variant4 [Quickcheck_observer] |
variant4 [Quickcheck_generator] |
variant5 [Quickcheck_observer] |
variant5 [Quickcheck_generator] |
variant6 [Quickcheck_observer] |
variant6 [Quickcheck_generator] |
verbose [Core_gc.Control.Fields] |
verbose [Core_gc.Control] |
view [Univ] | `view t` provides access to the GADT representation of `t`.
volatile_contents [Bigbuffer] | Return the actual underlying bigstring used by this bigbuffer.
W
weekdays [Day_of_week] | `Mon; Tue; Wed; Thu; Fri`
weekends [Day_of_week] | `Sat; Sun`
weighted_union [Raw_quickcheck_observer] | Nondeterministic observer.
weighted_union [Raw_quickcheck_generator] | `weighted_union alist` produces a generator that combines the distributions of each `t` in `alist` with the associated weights, which must be finite positive floating point values.
with_file [Out_channel] |
with_file [In_channel] | `with_file ~f fname` executes `~f` on the open channel from `fname`, and closes it afterwards.
with_return [With_return] |
with_return [Either_intf.Focused] |
with_return [Common] |
with_return_option [With_return] | Note that `with_return_option` allocates ~5 words more than equivalent `with_return` call
with_return_option [Common] |
witness [Type_immediacy.Never.For_all_parameters_S5] |
witness [Type_immediacy.Never.For_all_parameters_S4] |
witness [Type_immediacy.Never.For_all_parameters_S3] |
witness [Type_immediacy.Never.For_all_parameters_S2] |
witness [Type_immediacy.Never.For_all_parameters_S1] |
witness [Type_immediacy.Sometimes.For_all_parameters_S5] |
witness [Type_immediacy.Sometimes.For_all_parameters_S4] |
witness [Type_immediacy.Sometimes.For_all_parameters_S3] |
witness [Type_immediacy.Sometimes.For_all_parameters_S2] |
witness [Type_immediacy.Sometimes.For_all_parameters_S1] |
witness [Type_immediacy.Always.For_all_parameters_S5] |
witness [Type_immediacy.Always.For_all_parameters_S4] |
witness [Type_immediacy.Always.For_all_parameters_S3] |
witness [Type_immediacy.Always.For_all_parameters_S2] |
witness [Type_immediacy.Always.For_all_parameters_S1] |
word_size [Word_size] | Returns the word size of this program, not necessarily of the OS
words [Byte_units] |
write_all [Out_channel] |
write_bin_prot [Bigstring] | `write_bin_prot t writer a` writes `a` to `t` starting at `pos`, and returns the index in `t` immediately after the last byte written.
write_lines [Out_channel] | The first argument of these is the file name to write to.
write_of_sexp [Perms.Export] |
Y
yield [Sequence.Generator] |
Z
zero [Timing_wheel_intf.Interval_num.Span] |
zero [Timing_wheel_intf.Interval_num] |
zero [Time_ns.Span] |
zero [Int_math.T] |
zero [Int_intf.S.O] |
zero [Int_intf.S] |
zero [Float_intf.S.O] |
zero [Float_intf.S] |
zero [Commutative_group.S] |
zero [Bucket.Contents] |
zip [Sequence] | Transforms a pair of sequences into a sequence of pairs.
zip [Core_list] | Transform a pair of lists into an (optional) list of pairs: `zip [a1; ...; an] [b1; ...; bn]` is `[(a1,b1); ...; (an,bn)]`.
zip_exn [Core_list] |
zip_full [Sequence] | `zip_full` is like `zip`, but if one sequence ends before the other, then it keeps producing elements from the other sequence until it has ended as well.