core_kernel

API

Library core_kernel

• Core_kernel

Library core_kernel.ansi_kernel

• Ansi_kernel Common ANSI display attribute definitions.

Library core_kernel.balanced_reducer

• Balanced_reducer A Balanced_reducer.t stores a mutable fixed-length sequence of optional values, and incrementally maintains the result of folding an associative operation (reduce) over the sequence as its elements change.

Library core_kernel.binary_packing

• Binary_packing Packs and unpacks various types of integers into and from strings.

Library core_kernel.bounded_int_table

• Bounded_int_table A Bounded_int_table is a table whose keys can be mapped to integers in a fixed range, 0 ... num_keys - 1, where num_keys is specified at table-creation time. The purpose of Bounded_int_table is to be faster than Hashtbl in situations where one is willing to pay a space cost for the speed.

Library core_kernel.bus

• Bus A Bus is a publisher/subscriber system within the memory space of the program. A bus has a mutable set of subscribers, which can be modified using subscribe_exn and unsubscribe.

Library core_kernel.caml_threads

• Caml_threads

Library core_kernel.caml_unix

• Caml_unix

Library core_kernel.composition_infix

• Composition_infix Infix composition operators.

Library core_kernel.enum

• Enum

Library core_kernel.fheap

• Fheap Functional heaps (implemented as pairing heaps).

Library core_kernel.flags

• Flags

Library core_kernel.force_once

• Force_once A "force_once" is a thunk that can only be forced once. Subsequent forces will raise an exception.

Library core_kernel.hash_heap

• Hash_heap A hash-heap is a combination of a heap and a hashtable that supports constant time lookup, and log(n) time removal and replacement of elements in addition to the normal heap operations.

Library core_kernel.int_set

• Int_set An implementation of compressed integer sets using lists of integer ranges. Operations such as adding and membership are O(n) where n is the number of contiguous ranges in the set. For data that is mostly serial, n should remain very small.

Library core_kernel.iobuf

• Iobuf A non-moving (in the GC sense) contiguous range of bytes, useful for I/O operations.

Library core_kernel.limiter

• Limiter Implements a token-bucket-based throttling rate limiter. This module is useful for limiting network clients to a sensible query rate, or in any case where you have jobs that consume a scarce but replenishable resource.

Library core_kernel.moption

• Moption A Moption is a mutable option, like 'a option ref, but with a more efficient implementation; in particular, set_some does not allocate.

Library core_kernel.nonempty_list

• Nonempty_list

Library core_kernel.pairing_heap

• Pairing_heap Heap implementation based on a pairing-heap.

Library core_kernel.pooled_hashtbl

• Pooled_hashtbl A polymorphic hashtbl that uses Pool to avoid allocation.

Library core_kernel.reversed_list

• Reversed_list

Library core_kernel.sexp_hidden_in_test

• Sexp_hidden_in_test

Library core_kernel.thread_pool_cpu_affinity

• Thread_pool_cpu_affinity

Library core_kernel.thread_safe_queue

• Thread_safe_queue A thread-safe non-blocking queue of unbounded size.

Library core_kernel.timing_wheel

• Timing_wheel

Library core_kernel.total_map

• Total_map A map that includes an entry for every possible value of the key type.

Library core_kernel.tuple_pool

• Tuple_pool

Library core_kernel.univ

• Univ An extensible "universal" variant type.

Library core_kernel.unpack_buffer

• Unpack_buffer A buffer for incremental decoding of an input stream.

Library core_kernel.uopt

• Uopt Uopt.t is an unboxed option: an option-like type that incurs no allocation, without requiring a reserved value in the underlying type.

Library core_kernel.uuid

• Uuid Thread-safe generation of random identifiers in the UUID format.

Library core_kernel.vec

• Vec

Library core_kernel.version_util

• Version_util This module gives access to the same version/build information returned by Command-based executables when called with the -version or -build-info flags by $0 version (-build-info | -version) or $0 (-build-info | -version).

Library core_kernel.weak_array

• Weak_array Module for dealing with weak pointers, i.e., pointers that don't prevent garbage collection of what they point to.

Library core_kernel.weak_hashtbl

• Weak_hashtbl A hashtable that keeps a weak pointer to each key's data and uses a finalizer to detect when the data is no longer referenced (by any non-weak pointers).

Library core_kernel.weak_pointer

• Weak_pointer A weak pointer is a pointer to a heap block that does not cause the heap block to remain live during garbage collection.