package core_kernel

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

core_kernel v0.14.2

Libraries

This package provides the following libraries (via ocamlobjinfo):

core_kernel

Documentation:

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

core_kernel.ansi_kernel

Documentation:

core_kernel.balanced_reducer

Documentation:

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

core_kernel.base_for_tests

Documentation:

core_kernel.binary_packing

Documentation:

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

core_kernel.bounded_int_table

Documentation:

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

core_kernel.bus

Documentation:

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

core_kernel.caml_unix

Documentation:

core_kernel.composition_infix

Documentation:

core_kernel.enum

Documentation:

core_kernel.fheap

Documentation:

core_kernel.flags

Documentation:

core_kernel.force_once

Documentation:

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

core_kernel.hash_heap

Documentation:

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

core_kernel.int_set

Documentation:

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

core_kernel.iobuf

Documentation:

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

core_kernel.limiter

Documentation:

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

core_kernel.linked_stack

Documentation:

core_kernel.moption

Documentation:

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

core_kernel.pairing_heap

Documentation:

core_kernel.pooled_hashtbl

Documentation:

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

core_kernel.rope

Documentation:

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

core_kernel.sexp_hidden_in_test

Documentation:

core_kernel.thread_pool_cpu_affinity

Documentation:

core_kernel.thread_safe_queue

Documentation:

core_kernel.timing_wheel

Documentation:

core_kernel.total_map

Documentation:

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

core_kernel.tuple_pool

Documentation:

core_kernel.univ

Documentation:

  • Univ An extensible "universal" variant type.

core_kernel.unpack_buffer

Documentation:

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

core_kernel.uopt

Documentation:

  • 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).

core_kernel.uuid

Documentation:

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

core_kernel.version_util

Documentation:

  • 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).

core_kernel.weak_array

Documentation:

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

core_kernel.weak_hashtbl

Documentation:

  • 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).

core_kernel.weak_pointer

Documentation:

  • 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.
OCaml

Innovation. Community. Security.

GitHub Discord Twitter Peertube RSS
About
Changelog Releases Industrial Users Academic Users Why OCaml
Ecosystem
Packages Community Events OCaml Planet Jobs
Resources
Install OCaml Get Started Platform Tools Language Manual Standard Library API Books Exercises Papers OCaml Playground Logo
Policies
Carbon Footprint Governance Privacy Code of Conduct