package core_kernel

  1. Overview
  2. Docs
On This Page
  1. API
    1. Library core_kernel
    2. Library core_kernel.ansi_kernel
    3. Library core_kernel.balanced_reducer
    4. Library core_kernel.base_for_tests
    5. Library core_kernel.binary_packing
    6. Library core_kernel.bounded_int_table
    7. Library core_kernel.bus
    8. Library core_kernel.caml_unix
    9. Library core_kernel.composition_infix
    10. Library core_kernel.enum
    11. Library core_kernel.fheap
    12. Library core_kernel.flags
    13. Library core_kernel.force_once
    14. Library core_kernel.hash_heap
    15. Library core_kernel.int_set
    16. Library core_kernel.iobuf
    17. Library core_kernel.limiter
    18. Library core_kernel.linked_stack
    19. Library core_kernel.moption
    20. Library core_kernel.pairing_heap
    21. Library core_kernel.pooled_hashtbl
    22. Library core_kernel.rope
    23. Library core_kernel.sexp_hidden_in_test
    24. Library core_kernel.thread_pool_cpu_affinity
    25. Library core_kernel.thread_safe_queue
    26. Library core_kernel.timing_wheel
    27. Library core_kernel.total_map
    28. Library core_kernel.tuple_pool
    29. Library core_kernel.univ
    30. Library core_kernel.unpack_buffer
    31. Library core_kernel.uopt
    32. Library core_kernel.uuid
    33. Library core_kernel.version_util
    34. Library core_kernel.weak_array
    35. Library core_kernel.weak_hashtbl
    36. Library core_kernel.weak_pointer
package core_kernel
Legend:
Page
Library
Module
Module type
Parameter
Class
Class type
Source

core_kernel

API

Library core_kernel

  • Core_kernel Core_kernel greatly expands the functionality available in Base while still remaining platform-agnostic. Core_kernel changes more frequently (i.e., is less stable) than Base.

Library core_kernel.ansi_kernel

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.base_for_tests

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_unix

Library core_kernel.composition_infix

Library core_kernel.enum

Library core_kernel.fheap

Library core_kernel.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.linked_stack

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.pairing_heap

Library core_kernel.pooled_hashtbl

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

Library core_kernel.rope

  • Rope A rope is a standard data structure that represents a single string as a tree of strings, allowing concatenation to do no work up front. See the README.md file for details and motivating examples.

Library core_kernel.sexp_hidden_in_test

Library core_kernel.thread_pool_cpu_affinity

Library core_kernel.thread_safe_queue

Library core_kernel.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

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 A Uopt.t is an unboxed option. This module is tricky and potentially unsafe. It should mostly not be used, and when it is, one must keep the Uopt.t inside their module, and not expose them (not even if they are given an abstract type).

Library core_kernel.uuid

  • Uuid Implements universally unique identifiers based on version 3 of the UUID specification. Identifier generation is thread safe, and fast.

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.