# Module Core_map_intf

    module Core_map_intf: sig .. end

This module defines interfaces used in `Core.Std.Map`. See the documentation in core_map.mli for a description of the approach.

CRs and comments about `Map` functions do not belong in this file. They belong next to the appropriate function in core_map.mli.

This module defines module types `{Creators,Accessors}{1,2,3,_generic,_with_comparator}`. It uses check functors to ensure that each module types is an instance of the corresponding `_generic` one.

We must treat `Creators` and `Accessors` separately, because we sometimes need to choose different instantiations of their `options`. In particular, `Map` itself matches `Creators3_with_comparator` but `Accessors3` (without comparator).

This module defines interfaces used in `Core.Std.Map`. See the documentation in core_map.mli for a description of the approach.

CRs and comments about `Map` functions do not belong in this file. They belong next to the appropriate function in core_map.mli.

This module defines module types `{Creators,Accessors}{1,2,3,_generic,_with_comparator}`. It uses check functors to ensure that each module types is an instance of the corresponding `_generic` one.

We must treat `Creators` and `Accessors` separately, because we sometimes need to choose different instantiations of their `options`. In particular, `Map` itself matches `Creators3_with_comparator` but `Accessors3` (without comparator).

    module Binable: Binable0

    module List: Core_list

    module type Key = sig .. end

    module type Key_binable = sig .. end

    module Without_comparator: sig .. end

    module With_comparator: sig .. end

    module type Accessors_generic = sig .. end

    module type Accessors1 = sig .. end

    module type Accessors2 = sig .. end

    module type Accessors3 = sig .. end

    module type Accessors3_with_comparator = sig .. end

    module Check_accessors: functor (T : T.T3) -> functor (Tree : T.T3) -> functor (Key : T.T1) -> functor (Options : T.T3) -> functor (M : Accessors_generic
         with type ('a, 'b, 'c) options := ('a, 'b, 'c) Options.t
         with type ('a, 'b, 'c) t       := ('a, 'b, 'c) T.t
         with type ('a, 'b, 'c) tree    := ('a, 'b, 'c) Tree.t
         with type 'a key               := 'a Key.t) -> sig .. end

Consistency checks (same as in `Container`).

    module Check_accessors1: functor (M : Accessors1) -> Check_accessors(sig
    type ('a, 'b, 'c) t = 'b M.t

    end)(sig
    type ('a, 'b, 'c) t = 'b M.tree

    end)(sig
    type 'a t = M.key

    end)(Without_comparator)(M)

    module Check_accessors2: functor (M : Accessors2) -> Check_accessors(sig
    type ('a, 'b, 'c) t = ('a, 'b) M.t

    end)(sig
    type ('a, 'b, 'c) t = ('a, 'b) M.tree

    end)(sig
    type 'a t = 'a

    end)(Without_comparator)(M)

    module Check_accessors3: functor (M : Accessors3) -> Check_accessors(sig
    type ('a, 'b, 'c) t = ('a, 'b, 'c) M.t

    end)(sig
    type ('a, 'b, 'c) t = ('a, 'b, 'c) M.tree

    end)(sig
    type 'a t = 'a

    end)(Without_comparator)(M)

    module Check_accessors3_with_comparator: functor (M : Accessors3_with_comparator) -> Check_accessors(sig
    type ('a, 'b, 'c) t = ('a, 'b, 'c) M.t

    end)(sig
    type ('a, 'b, 'c) t = ('a, 'b, 'c) M.tree

    end)(sig
    type 'a t = 'a

    end)(With_comparator)(M)

    module type Creators_generic = sig .. end

    module type Creators1 = sig .. end

    module type Creators2 = sig .. end

    module type Creators3_with_comparator = sig .. end

    module Check_creators: functor (T : T.T3) -> functor (Tree : T.T3) -> functor (Key : T.T1) -> functor (Options : T.T3) -> functor (M : Creators_generic
         with type ('a, 'b, 'c) options := ('a, 'b, 'c) Options.t
         with type ('a, 'b, 'c) t       := ('a, 'b, 'c) T.t
         with type ('a, 'b, 'c) tree    := ('a, 'b, 'c) Tree.t
         with type 'a key               := 'a Key.t) -> sig .. end

    module Check_creators1: functor (M : Creators1) -> Check_creators(sig
    type ('a, 'b, 'c) t = 'b M.t

    end)(sig
    type ('a, 'b, 'c) t = 'b M.tree

    end)(sig
    type 'a t = M.key

    end)(Without_comparator)(M)

    module Check_creators2: functor (M : Creators2) -> Check_creators(sig
    type ('a, 'b, 'c) t = ('a, 'b) M.t

    end)(sig
    type ('a, 'b, 'c) t = ('a, 'b) M.tree

    end)(sig
    type 'a t = 'a

    end)(Without_comparator)(M)

    module Check_creators3_with_comparator: functor (M : Creators3_with_comparator) -> Check_creators(sig
    type ('a, 'b, 'c) t = ('a, 'b, 'c) M.t

    end)(sig
    type ('a, 'b, 'c) t = ('a, 'b, 'c) M.tree

    end)(sig
    type 'a t = 'a

    end)(With_comparator)(M)

    module type Creators_and_accessors_generic = sig .. end

    module type Creators_and_accessors1 = sig .. end

    module type Creators_and_accessors2 = sig .. end

    module type Creators_and_accessors3_with_comparator = sig .. end

    module type S = sig .. end

    module type S_binable = sig .. end

This module defines interfaces used in `Core.Std.Map`. See the documentation in core_map.mli for a description of the approach.

CRs and comments about `Map` functions do not belong in this file. They belong next to the appropriate function in core_map.mli.

This module defines module types `{Creators,Accessors}{1,2,3,_generic,_with_comparator}`. It uses check functors to ensure that each module types is an instance of the corresponding `_generic` one.

We must treat `Creators` and `Accessors` separately, because we sometimes need to choose different instantiations of their `options`. In particular, `Map` itself matches `Creators3_with_comparator` but `Accessors3` (without comparator).
Consistency checks (same as in `Container`).