package core_kernel

You can search for identifiers within the package.

in-package search v0.2.0

Industrial strength alternative to OCaml's standard library

Install

Dune Dependency

github.com Changelog MIT License Edit opam file Versions (10)

Authors

J

Jane Street Group, LLC

Maintainers

J

Jane Street developers

Sources

sha256=fd2b8c6715794df7a810a62b226f53720f211cd344b4afc9fab0498796d6b466

doc/core_kernel.total_map/Total_map/index.html

Module `Total_map`Source

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

This is intended to be used on 'key types where there is a full enumeration of the type. In the common use case, 'key will be a simple variant type with [@@deriving compare, enumerate]. For example:

  module Arrow_key = struct
    module T = struct
      type t =
        | Up
        | Down
        | Left
        | Right
      [@@deriving sexp, bin_io, compare, enumerate]
    end
    include T
    module Total_map = Total_map.Make (T)
  end

In such a case, a t is semantically equivalent to a pure function from 'key to 'value. The differences are that it is serializable and that mapping or changing a t will produce a t using the same amount of space as the original.

However, in theory you could also modify the comparison function and enumeration, so long as the enumeration contains at least one representative of each equivalence class determined by the comparison function.

Sourcemodule Enumeration : sig ... end

Sourcetype ('key, 'a, 'cmp, 'enum) t = private ('key, 'a, 'cmp) Core.Map.t

Sourceval to_map : ('key, 'a, 'cmp, _) t -> ('key, 'a, 'cmp) Core.Map.t

Many of the functions below have types reflecting the fact that the maps are total (e.g., find does not return an option). The fact that they won't raise exceptions relies on the enumeration passed to Make being complete.

Sourceval map : ('key, 'a, 'c, 'e) t -> f:('a -> 'b) -> ('key, 'b, 'c, 'e) t

val mapi : 
  ('key, 'a, 'c, 'e) t ->
  f:(key:'key -> data:'a -> 'b) ->
  ('key, 'b, 'c, 'e) t

val map2 : 
  ('key, 'a, 'cmp, 'enum) t ->
  ('key, 'b, 'cmp, 'enum) t ->
  f:('a -> 'b -> 'c) ->
  ('key, 'c, 'cmp, 'enum) t

Sourceval iter_keys : ('key, _, _, _) t -> f:('key -> unit) -> unit

Sourceval iter : (_, 'a, _, _) t -> f:('a -> unit) -> unit

Sourceval iteri : ('key, 'a, _, _) t -> f:(key:'key -> data:'a -> unit) -> unit

val iter2 : 
  ('key, 'a, 'cmp, 'enum) t ->
  ('key, 'b, 'cmp, 'enum) t ->
  f:(key:'key -> 'a -> 'b -> unit) ->
  unit

val fold : 
  ('key, 'a, _, _) t ->
  init:'acc ->
  f:(key:'key -> data:'a -> 'acc -> 'acc) ->
  'acc

val fold_right : 
  ('key, 'a, _, _) t ->
  init:'acc ->
  f:(key:'key -> data:'a -> 'acc -> 'acc) ->
  'acc

val fold2 : 
  ('key, 'a, 'cmp, 'enum) t ->
  ('key, 'b, 'cmp, 'enum) t ->
  init:'acc ->
  f:(key:'key -> 'a -> 'b -> 'acc -> 'acc) ->
  'acc

Folds over two maps side by side, like iter2.

Sourceval set : ('key, 'a, 'cmp, 'enum) t -> 'key -> 'a -> ('key, 'a, 'cmp, 'enum) t

val to_alist : 
  ?key_order:[ `Increasing | `Decreasing ] ->
  ('key, 'a, _, _) t ->
  ('key * 'a) list

Sourceval find : ('key, 'a, _, _) t -> 'key -> 'a

val change : 
  ('key, 'a, 'c, 'e) t ->
  'key ->
  f:('a -> 'a) ->
  ('key, 'a, 'c, 'e) t

val combine_errors : 
  ('key, 'a Core.Or_error.t, 'c, 'e) t ->
  ('key, 'a, 'c, 'e) t Core.Or_error.t

Sourceval data : (_, 'a, _, _) t -> 'a list

Sourceval for_all : (_, 'a, _, _) t -> f:('a -> bool) -> bool

Sourceval for_alli : ('key, 'a, _, _) t -> f:(key:'key -> data:'a -> bool) -> bool

Sourcemodule Sequence (A : Core.Applicative) : sig ... end

Sequence a total map of computations in order of their keys resulting in computation of the total map of results.

Sourcemodule Sequence2 (A : Core.Applicative.S2) : sig ... end

Sourcemodule Sequence3 (A : Core.Applicative.S3) : sig ... end

The only reason that the Applicative interface isn't included here is that we don't have an Applicative.S4.

Sourcemodule type Key = sig ... end

Sourcemodule type Key_with_witnesses = sig ... end

Sourcemodule type S_plain = sig ... end

Sourcemodule type For_include_functor_plain = sig ... end

Sourcemodule type S = sig ... end

Sourcemodule type For_include_functor = sig ... end

Sourcemodule Make_plain (Key : sig ... end) : S_plain with module Key = Key

module Make_for_include_functor_plain
  (Key : sig ... end) : 
  For_include_functor_plain with module Total_map.Key = Key

module Make_plain_with_witnesses
  (Key : sig ... end) : 
  S_plain
    with module Key = Key
    with type comparator_witness = Key.comparator_witness
    with type enumeration_witness = Key.enumeration_witness

module Make_for_include_functor_plain_with_witnesses
  (Key : sig ... end) : 
  For_include_functor_plain
    with module Total_map.Key = Key
    with type Total_map.comparator_witness = Key.comparator_witness
    with type Total_map.enumeration_witness = Key.enumeration_witness

Sourcemodule Make (Key : Key) : S with module Key = Key

module Make_for_include_functor
  (Key : Key) : 
  For_include_functor with module Total_map.Key = Key

module Make_with_witnesses
  (Key : Key_with_witnesses) : 
  S
    with module Key = Key
    with type comparator_witness = Key.comparator_witness
    with type enumeration_witness = Key.enumeration_witness

module Make_for_include_functor_with_witnesses
  (Key : Key_with_witnesses) : 
  For_include_functor
    with module Total_map.Key = Key
    with type Total_map.comparator_witness = Key.comparator_witness
    with type Total_map.enumeration_witness = Key.enumeration_witness

Sourcemodule Stable : sig ... end