Package core_kernel v0.9.0

core_kernel

Core_kernel
Core_kernel__
Core_kernel__BagImperative set-like data structure.
Core_kernel__BigbufferExtensible string buffers based on Bigstrings.
Core_kernel__Bigbuffer_internal
Core_kernel__BigstringString type based on Bigarray, for use in I/O and C-bindings
Core_kernel__Bigstring_marshalUtility functions for marshalling to and from bigstring.
Core_kernel__BigsubstringSubstring type based on Bigarray, for use in I/O and C-bindings
Core_kernel__BinableModule types and utilities for dealing with types that support the bin-io binary encoding.
Core_kernel__Binable0
Core_kernel__Binary_packingPacks and unpacks various types of integers into and from strings.
Core_kernel__Binary_searchable
Core_kernel__Binary_searchable_intfThis module extends the Base Binary_searchable_intf module
Core_kernel__BlangA simple boolean domain-specific language
Core_kernel__BlitThis module extends the Base Blit module
Core_kernel__Blit_intfThis module extends the Base Blit_intf module
Core_kernel__BoolThis module extends the Base Bool module
Core_kernel__Bounded_index
Core_kernel__Bounded_index_intfBounded_index creates unique index types with explicit bounds and human-readable labels. A 0-based index for the third element of five with label "thing" renders as "(thing 2 of 0 to 4)", whereas a 1-based index for the second element of twelve with label "item" renders as "(item 2 of 1 to 12)", even though both represent the index 2. Use Bounded_index to help distinguish between different index types when reading rendered values, deserializing sexps, and typechecking. Consider using Bounded_index to label fixed pools of resources such as cores in a cpu, worker processes in a parallel application, or machines in a cluster.
Core_kernel__Bounded_int_tableA 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__Bucket
Core_kernel__BusA 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__Byte_unitsConversions between units of measure based on bytes.
Core_kernel__Comparable
Core_kernel__Comparable_intf
Core_kernel__Comparator
Core_kernel__Constrained_float
Core_kernel__Container
Core_kernel__Container_intfThis module extends the Base Container_intf module
Core_kernel__Container_unit_tests
Core_kernel__Core_argINRIA's original command-line parsing library.
Core_kernel__Core_arrayThis module extends the Base Array module
Core_kernel__Core_bin_prot
Core_kernel__Core_bytesOCaml's built in bytes type, currently equal to string.
Core_kernel__Core_charThis module extends the Base Char module
Core_kernel__Core_ephemeronAn ephemeron is a pair of pointers, one to a "key" and one to "data". The key pointer is a weak pointer; the garbage collector doesn't follow it when determining liveness. The garbage collector follows an ephemeron's data pointer iff the key is alive. If the garbage collector nulls an ephemeron's weak pointer then it also nulls the data pointer. Ephemerons are more powerful than weak pointers because they express conjunction of liveness -- the data in an ephemeron is live iff both the key *and* the ephemeron are live. See "Ephemerons: A New Finalization Mechanism", Barry Hayes 1997.
Core_kernel__Core_gcMemory management control and statistics; finalized values.
Core_kernel__Core_hashtblCore_hashtbl is a reimplementation of the standard MoreLabels.Hashtbl. Its worst case time complexity is O(log(N)) for lookups and additions, unlike the standard MoreLabels.Hashtbl, which is O(N).
Core_kernel__Core_hashtbl_intf
Core_kernel__Core_intThis module extends the Base Int module
Core_kernel__Core_int32
Core_kernel__Core_int63
Core_kernel__Core_int64
Core_kernel__Core_lazy
Core_kernel__Core_listThis module extends the Base List module with bin_io and quickcheck
Core_kernel__Core_mapThis module defines the Map module for Core. We use "core_map" as the file name rather than "map" to avoid conflicts with OCaml's standard map module. In this documentation, we use Map to mean this module, not the OCaml standard one.
Core_kernel__Core_map_intfThis module defines interfaces used in Core.Map. See the documentation in core_map.mli for a description of the approach.
Core_kernel__Core_nativeint
Core_kernel__Core_pervasivesThis module has exactly the same interface and implementation as INRIA's Pervasives, except that some things are deprecated in favor of Core equivalents.
Core_kernel__Core_printexcThis module is here to ensure that we don't use the functions in Caml.Printexc inadvertently
Core_kernel__Core_printf
Core_kernel__Core_queueA queue implemented with an array. See Queue_intf for documentation of standard queue functions.
Core_kernel__Core_random
Core_kernel__Core_setThis module defines the Set module for Core. We use "core_set" as the file name rather than "set" to avoid conflicts with OCaml's standard set module.
Core_kernel__Core_set_intfThis module defines interfaces used in Core.Set. This module uses the same organizational approach as Core_map_intf. See the documentation in core_map.mli for a description of the approach.
Core_kernel__Core_sexpCode for managing s-expressions
Core_kernel__Core_stackA stack implemented with an array. See Stack_intf for documentation.
Core_kernel__Core_stringThis module extends the Base String module
Core_kernel__Core_weakModule for dealing with weak pointers, i.e., pointers that don't prevent garbage collection of what they point to.
Core_kernel__Date
Core_kernel__Date0
Core_kernel__Date0_intf
Core_kernel__Date_intf
Core_kernel__Day_of_week
Core_kernel__Day_of_week_intfFor representing a day of the week.
Core_kernel__DebugUtilities for printing debug messages.
Core_kernel__Deprecate_pipe_bang
Core_kernel__DequeA double ended queue that can shrink and expand on both ends.
Core_kernel__Deriving_hash
Core_kernel__Deriving_hash_intf
Core_kernel__Digit_string_helpersUtility functions for parsing and outputing strings containing known numbers of digits. Used primarily for building functions for reading in and writing out Time related values.
Core_kernel__Doubly_linkeddoubly-linked lists
Core_kernel__EitherThis module extends the Base Either module
Core_kernel__ErrorThis module extends the Base Error module with bin_io
Core_kernel__FdequeA simple polymorphic functional double-ended queue. Use this if you need a queue-like data structure that provides enqueue and dequeue accessors on both ends. For strictly first-in, first-out access, see Fqueue.
Core_kernel__FheapFunctional Heap implementation based on pairing-heap algorithm and immutable data structures. See more info at http://en.wikipedia.org/wiki/Pairing_heap.
Core_kernel__FlagsSee flags_intf.ml for documentation.
Core_kernel__Flags_intfmodule Flags implements Unix-style sets of flags that are represented as an int with various bits set, one bit for each flag. E.g. Linux_ext.Epoll.Flag.
Core_kernel__Float
Core_kernel__Float_with_finite_only_serializationAn alias to the Float.t type that causes the sexp and bin-io serializers to fail when provided with nan or infinity.
Core_kernel__Fn
Core_kernel__Force_once
Core_kernel__FqueueA simple polymorphic functional queue. Use this data structure for strictly first-in, first-out access to a sequence of values. For a similar data structure with enqueue and dequeue accessors on both ends of a sequence, see Fdeque.
Core_kernel__Hash_heapA hash-heap is a combination of a heap and a hashtbl that supports constant time lookup, and log(n) time removal and replacement of elements in addition to the normal heap operations.
Core_kernel__Hash_queue
Core_kernel__Hash_setA mutable set of elements
Core_kernel__Hash_set_intf
Core_kernel__Hashable
Core_kernel__HeapHeap implementation based on a pairing-heap.
Core_kernel__Heap_intf
Core_kernel__Hexdump
Core_kernel__Hexdump_intfA functor for displaying a type as a sequence of ASCII characters, printed in hexadecimal.
Core_kernel__Host_and_port
Core_kernel__Identifiablea signature for identifier types.
Core_kernel__Immediate_option
Core_kernel__Immediate_option_intf
Core_kernel__Import
Core_kernel__Info
Core_kernel__Info_intf
Core_kernel__Int_intfThis module extends the Base Int_intf module
Core_kernel__Int_replace_polymorphic_compare
Core_kernel__Int_setAn 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 contigous ranges in the set. For data that is mostly serial, n should remain very small.
Core_kernel__Interfaces
Core_kernel__LimiterImplements 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_queueThis module extends the Base.Queue module with bin_io support. As a reminder, the Base.Queue module is a wrapper around OCaml's standard Queue module that follows Base idioms and adds some functions.
Core_kernel__Linked_stackA stack implemented with a list. See Stack_intf for documentation.
Core_kernel__Make_stable
Core_kernel__Make_substring
Core_kernel__Maybe_boundThis module extends the Base Maybe_bound module with compare functions in the form of As_lower_bound and As_upper_bound modules.
Core_kernel__MemoMemoization code -- not re-entrant!
Core_kernel__Month
Core_kernel__Month_intf
Core_kernel__MoptionA Moption is a mutable option, like 'a option ref, but with a more efficient implementation; in particular, set_some does not allocate.
Core_kernel__Never_returnsnever_returns should be used as the return type of functions that don't return and might block forever, rather than 'a or _. This forces callers of such functions to have a call to never_returns at the call site, which makes it clear to readers what's going on. We do not intend to use this type for functions such as failwithf that always raise an exception.
Core_kernel__No_polymorphic_compareOpen this in modules where you don't want to accidentally use polymorphic comparison. Then, use Pervasives.(<), for example, where needed.
Core_kernel__NothingAn uninhabited type.
Core_kernel__Obj_arrayAn array of Obj.ts.
Core_kernel__Ofday
Core_kernel__Ofday_intf
Core_kernel__Only_in_testThis module can be used to safely expose functions and values in signatures that should only be used in unit tests.
Core_kernel__OptionThis module extends the Base Option module with bin_io and quickcheck
Core_kernel__Option_array'a Option_array.t is a compact representation of 'a option array: it avoids allocating heap objects representing Some x, usually representing them with x instead. It uses a special representation for None that's guaranteed to never collide with any representation of Some x.
Core_kernel__Or_errorThis module extends the Base Or_error module
Core_kernel__Ordering
Core_kernel__PercentAn abstract type of scale factors
Core_kernel__PermsThese types are intended to be used as phantom types encoding the permissions on a given type.
Core_kernel__PidProcess ID.
Core_kernel__Polymorphic_compare_intf
Core_kernel__Pool
Core_kernel__Pool_intfA manual memory manager for a set of mutable tuples.
Core_kernel__Pooled_hashtblA polymorphic hashtbl that uses Pool to avoid allocation.
Core_kernel__Queue_intf
Core_kernel__Quickcheck
Core_kernel__Quickcheck_intfFor examples see: lib/core/example/quickcheck
Core_kernel__Quickcheckable
Core_kernel__Ref
Core_kernel__Result
Core_kernel__Robustly_comparable
Core_kernel__RopeA rope is a standard data structure that represents a single string as a tree of strings, allowing concatenation to do no work up front -- a string formed by many Rope concatenations followed by a to_string needs only copy each input to the output once, whereas a string expression looking like a ^ b ^ c ^ ... ^ z must create an intermediate string for every concatenation, and will copy the original data into and out of short-lived temporary strings many times.
Core_kernel__SequenceThis module extends the Base Option module with bin_io
Core_kernel__Set_onceThis module implements an option ref that starts out as None, and may be set only once. If one tries to set it twice a run time error is generated.
Core_kernel__Sexpable
Core_kernel__SignThis module extends the Base Sign module with bin_io
Core_kernel__Source_code_position
Core_kernel__Source_code_position0
Core_kernel__Span
Core_kernel__Span_intf
Core_kernel__Splittable_randomA splittable pseudo-random number generator (SPRNG) functions like a PRNG in that it can be used as a stream of random values; it can also be "split" to produce a second, independent stream of random values. This module implements a splittable pseudo-random number generator that sacrifices cryptographic-quality randomness in favor of performance.
Core_kernel__Stable
Core_kernel__Stable_containersThe Stable versions of Hashtbl, Hash_set, Map, and Set are defined here rather than in their respective modules because:
Core_kernel__Stable_int63able
Core_kernel__Stable_internal
Core_kernel__Stable_module_types
Core_kernel__Stable_unit_testThe tests generated by these functors are run like any other unit tests: by the inline test runner when the functor is applied.
Core_kernel__Stable_unit_test_intfAn interface for creating unit tests to check stability of sexp and bin-io serializations
Core_kernel__Stack_intfAn interface for stacks that follows Core's conventions, as opposed to OCaml's standard Stack module.
Core_kernel__Std_common
Core_kernel__Std_internal
Core_kernel__Std_kernelStd_kernel defines modules exposed by Core_kernel that are not overridden by Core. It is used in core.ml to re-export these modules.
Core_kernel__String_id
Core_kernel__String_id_intfDisallows whitespace around the edges in of_string and t_of_sexp, but doesn't check when reading from bin_io.
Core_kernel__Substring
Core_kernel__Substring_intfA substring is a contiguous set of characters within a string. Creating a substring does not copy. Therefore modifying the string also modifies the substring.
Core_kernel__T
Core_kernel__Thread_safe_queueA thread-safe non-blocking queue of unbounded size.
Core_kernel__Time
Core_kernel__Time0_intf
Core_kernel__Time_float
Core_kernel__Time_float0
Core_kernel__Time_intf
Core_kernel__Time_ns
Core_kernel__Time_ns_alternate_sexp
Core_kernel__Time_ns_intf
Core_kernel__Timing_wheel_ns
Core_kernel__Timing_wheel_ns_intfA specialized priority queue for a set of time-based alarms.
Core_kernel__Total_mapA ('key, 'value, cmp) Map.t where every value of type 'key is present.
Core_kernel__TupleFunctors and signatures for dealing with modules for tuples.
Core_kernel__Tuple_typeTuple-like types used in Pool.
Core_kernel__Tuple_type_intf
Core_kernel__Type_equal
Core_kernel__Type_equal_intf
Core_kernel__Type_immediacyWitnesses that express whether a type's values are always, sometimes, or never immediate.
Core_kernel__Uniform_arraySame semantics as 'a Array.t, except it's guaranteed that the representation array is not tagged with Double_array_tag, the tag for float arrays. This means it's safer to use in the presence of Obj.magic, but it's slower than normal Array if you use it with floats.
Core_kernel__Union_findImperative data structure for representing disjoint sets.
Core_kernel__Unique_idFunctors for creating modules that mint unique identifiers.
Core_kernel__Unique_id_intfSignature for use by module : Unique_id.
Core_kernel__UnitModule for the type unit. This is mostly useful for building functor arguments.
Core_kernel__Unit_of_timeRepresents a unit of time, e.g. used by Time.Span.to_string_hum. Comparison respects Nanosecond < Microsecond < Millisecond < Second < Minute < Hour < Day.
Core_kernel__UnivAn extensible "universal" variant type.
Core_kernel__Univ_mapUniversal/heterogeneous maps.
Core_kernel__Univ_map_intf
Core_kernel__Unpack_bufferA buffer for incremental decoding of an input stream.
Core_kernel__ValidatedSee Validated_intf for documentation.
Core_kernel__Validated_intfFor making an abstract version of a type that ensures a validation check has passed.
Core_kernel__Version_utilThis 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). Here's how it works: we arrange for the build system to, at link time, include an object file that defines symbols that version_util.ml uses to get the strings that contain the information that this module provides. When building with OMake, our OMakeroot runs build_info.sh to generate *.build_info.c with the symbols and that is linked in.
Core_kernel__Weak_pointerA weak pointer is a pointer to a heap block that does not cause the heap block to remain live during garbage collection. If the block would otherwise remain live, then then the weak pointer remains pointed to the block. If the block is collected, then the weak pointer is cleared.
Core_kernel__Zone
Core_kernel__Zone_intfTime-zone handling.

base_for_tests/base_for_tests

Base_for_tests
Base_for_tests__Test_binary_searchable
Base_for_tests__Test_binary_searchable_intfProduce unit tests for binary searchable containers
Base_for_tests__Test_blit
Base_for_tests__Test_blit_intfProduce unit tests for blittable values.

Info

authors
  • Jane Street Group, LLC <opensource@janestreet.com>
change log
deps
homepage
issues
licenses
  • Apache-2.0
licenses
maintainers
  • opensource@janestreet.com
readme
versionv0.9.0