Module Total_map

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.

module Enumeration : sig ... end
type ('key, 'a, 'cmp, 'enum) t = private ('key, 'a, 'cmp) Core_kernel.Map.t
val to_map : ('key, 'a, 'cmp, _) t -> ('key, 'a, 'cmp) Core_kernel.Map.t
val 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
val iter_keys : ('key, _, _, _) t -> f:('key -> unit) -> unit
val iter : (_, 'a, _, _) t -> f:('a -> unit) -> unit
val 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.

val 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
val find : ('key, 'a, _, _) t -> 'key -> 'a
val change : ('key, 'a, 'c, 'e) t -> 'key -> f:('a -> 'a) -> ('key, 'a, 'c, 'e) t
val data : (_, 'a, _, _) t -> 'a list
val for_all : (_, 'a, _, _) t -> f:('a -> bool) -> bool
module Sequence : functor (A : Core_kernel.Applicative) -> sig ... end

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

module type Key = sig ... end
module type Key_with_witnesses = sig ... end
module type S = sig ... end
module Make : functor (Key : Key) -> S with module Key = Key
module Make_with_witnesses : functor (Key : Key_with_witnesses) -> S with module Key = Key with type comparator_witness = Key.comparator_witness with type enumeration_witness = Key.enumeration_witness
module Stable : sig ... end