Module MoreLabels.Map

Association tables over ordered types.

This module implements applicative association tables, also known as finite maps or dictionaries, given a total ordering function over the keys. All operations over maps are purely applicative (no side-effects). The implementation uses balanced binary trees, and therefore searching and insertion take time logarithmic in the size of the map.

For instance:

  module IntPairs =
    struct
      type t = int * int
      let compare (x0,y0) (x1,y1) =
        match Stdlib.compare x0 x1 with
            0 -> Stdlib.compare y0 y1
          | c -> c
    end

  module PairsMap = Map.Make(IntPairs)

  let m = PairsMap.(empty |> add (0,1) "hello" |> add (1,0) "world")

module IntPairs = {
  type t = (int, int);
  let compare = ((x0, y0), (x1, y1)) =>
    switch (Stdlib.compare(x0, x1)) {
    | 0 => Stdlib.compare(y0, y1)
    | c => c
    };
};

module PairsMap = Map.Make(IntPairs);

let m = PairsMap.(empty |> add((0, 1), "hello") |> add((1, 0), "world"));

This creates a new module PairsMap, with a new type 'a PairsMap.tPairsMap.t('a) of maps from int * int(int, int) to 'a. In this example, m contains string values so its type is string PairsMap.t.

module type OrderedType = sig ... end

module type OrderedType = { ... };

Input signature of the functor Make.

module type S = sig ... end

module type S = { ... };

Output signature of the functor Make.

module Make
  (Ord : OrderedType) : 
  S with type key = Ord.t and type 'a t = 'a Map.Make(Ord).t

module Make: 
   (Ord: OrderedType) =>
  S with type key = Ord.t and type t('a) = Map.Make(Ord).t('a);

Functor building an implementation of the map structure given a totally ordered type.