sig
  module type Map_ =
    sig
      type 'a key_
      type 'a elt_
      type ('a, 'b) map
      type ('a, 'b, 'c) result_
      val empty : ('a, 'b) Reins.Maps.Map_.map
      val is_empty : ('a, 'b) Reins.Maps.Map_.map -> bool
      val mem :
        'a Reins.Maps.Map_.key_ ->
        ('a, 'b) Reins.Maps.Map_.map ->
        (bool, 'a, 'b) Reins.Maps.Map_.result_
      val add :
        'a Reins.Maps.Map_.key_ ->
        'b Reins.Maps.Map_.elt_ ->
        ('a, 'b) Reins.Maps.Map_.map -> ('a, 'b) Reins.Maps.Map_.map
      val singleton :
        'a Reins.Maps.Map_.key_ ->
        'b Reins.Maps.Map_.elt_ -> ('a, 'b) Reins.Maps.Map_.map
      val remove :
        'a Reins.Maps.Map_.key_ ->
        ('a, 'b) Reins.Maps.Map_.map -> ('a, 'b) Reins.Maps.Map_.map
      val find :
        'a Reins.Maps.Map_.key_ ->
        ('a, 'b) Reins.Maps.Map_.map ->
        ('b Reins.Maps.Map_.elt_, 'a, 'b) Reins.Maps.Map_.result_
      val min_key :
        ('a, 'b) Reins.Maps.Map_.map ->
        ('a Reins.Maps.Map_.key_, 'a, 'b) Reins.Maps.Map_.result_
      val max_key :
        ('a, 'b) Reins.Maps.Map_.map ->
        ('a Reins.Maps.Map_.key_, 'a, 'b) Reins.Maps.Map_.result_
      val min_keyval :
        ('a, 'b) Reins.Maps.Map_.map ->
        ('a Reins.Maps.Map_.key_ * 'b Reins.Maps.Map_.elt_, 'a, 'b)
        Reins.Maps.Map_.result_
      val max_keyval :
        ('a, 'b) Reins.Maps.Map_.map ->
        ('a Reins.Maps.Map_.key_ * 'b Reins.Maps.Map_.elt_, 'a, 'b)
        Reins.Maps.Map_.result_
      val cardinal : ('a, 'b) Reins.Maps.Map_.map -> int
      val iter :
        ('a Reins.Maps.Map_.key_ -> 'b Reins.Maps.Map_.elt_ -> unit) ->
        ('a, 'b) Reins.Maps.Map_.map -> unit
      val fold :
        ('a -> 'b Reins.Maps.Map_.key_ -> 'c Reins.Maps.Map_.elt_ -> 'a) ->
        'a -> ('b, 'c) Reins.Maps.Map_.map -> 'a
      val map :
        ('a Reins.Maps.Map_.elt_ -> 'b Reins.Maps.Map_.elt_) ->
        ('c, 'a) Reins.Maps.Map_.map -> ('c, 'b) Reins.Maps.Map_.map
      val mapi :
        ('a Reins.Maps.Map_.key_ ->
         'b Reins.Maps.Map_.elt_ -> 'c Reins.Maps.Map_.elt_) ->
        ('a, 'b) Reins.Maps.Map_.map -> ('a, 'c) Reins.Maps.Map_.map
      val union :
        ('a Reins.Maps.Map_.key_ ->
         'b Reins.Maps.Map_.elt_ ->
         'b Reins.Maps.Map_.elt_ -> 'b Reins.Maps.Map_.elt_) ->
        ('a, 'b) Reins.Maps.Map_.map ->
        ('a, 'b) Reins.Maps.Map_.map -> ('a, 'b) Reins.Maps.Map_.map
      val inter :
        ('a Reins.Maps.Map_.key_ ->
         'b Reins.Maps.Map_.elt_ ->
         'b Reins.Maps.Map_.elt_ -> 'b Reins.Maps.Map_.elt_) ->
        ('a, 'b) Reins.Maps.Map_.map ->
        ('a, 'b) Reins.Maps.Map_.map -> ('a, 'b) Reins.Maps.Map_.map
      val diff :
        ('a Reins.Maps.Map_.key_ ->
         'b Reins.Maps.Map_.elt_ -> 'b Reins.Maps.Map_.elt_ -> bool) ->
        ('a, 'b) Reins.Maps.Map_.map ->
        ('a, 'b) Reins.Maps.Map_.map -> ('a, 'b) Reins.Maps.Map_.map
      val well_formed : ('a, 'b) Reins.Maps.Map_.map -> bool
      val of_result : ('a, 'b, 'c) Reins.Maps.Map_.result_ -> 'a
      type ('a, 'b) cursor_
      val to_cursor :
        ('a, 'b) Reins.Maps.Map_.map -> ('a, 'b) Reins.Maps.Map_.cursor_
      val from_cursor :
        ('a, 'b) Reins.Maps.Map_.cursor_ -> ('a, 'b) Reins.Maps.Map_.map
      val at_top : ('a, 'b) Reins.Maps.Map_.cursor_ -> bool
      val at_left : ('a, 'b) Reins.Maps.Map_.cursor_ -> bool
      val at_right : ('a, 'b) Reins.Maps.Map_.cursor_ -> bool
      val move_up :
        ('a, 'b) Reins.Maps.Map_.cursor_ -> ('a, 'b) Reins.Maps.Map_.cursor_
      val move_down_left :
        ('a, 'b) Reins.Maps.Map_.cursor_ -> ('a, 'b) Reins.Maps.Map_.cursor_
      val move_down_right :
        ('a, 'b) Reins.Maps.Map_.cursor_ -> ('a, 'b) Reins.Maps.Map_.cursor_
      val went_left : ('a, 'b) Reins.Maps.Map_.cursor_ -> bool
      val went_right : ('a, 'b) Reins.Maps.Map_.cursor_ -> bool
      val has_value : ('a, 'b) Reins.Maps.Map_.cursor_ -> bool
      val get_value :
        ('a, 'b) Reins.Maps.Map_.cursor_ ->
        'a Reins.Maps.Map_.key_ * 'b Reins.Maps.Map_.elt_
    end
  module type PolyMapSig =
    sig
      type ('a, 'b) t
      type 'a key = 'a
      type 'a elt = 'a
      type ('a, 'b) cursor
      type ('a, 'b, 'c) result
      type 'a key_ = 'a
      type 'a elt_ = 'a
      type ('a, 'b) map = ('a, 'b) t
      type ('a, 'b, 'c) result_ = ('a, 'b, 'c) result
      val empty : ('a, 'b) map
      val is_empty : ('a, 'b) map -> bool
      val mem : 'a key_ -> ('a, 'b) map -> (bool, 'a, 'b) result_
      val add : 'a key_ -> 'b elt_ -> ('a, 'b) map -> ('a, 'b) map
      val singleton : 'a key_ -> 'b elt_ -> ('a, 'b) map
      val remove : 'a key_ -> ('a, 'b) map -> ('a, 'b) map
      val find : 'a key_ -> ('a, 'b) map -> ('b elt_, 'a, 'b) result_
      val min_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
      val max_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
      val min_keyval : ('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
      val max_keyval : ('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
      val cardinal : ('a, 'b) map -> int
      val iter : ('a key_ -> 'b elt_ -> unit) -> ('a, 'b) map -> unit
      val fold : ('a -> 'b key_ -> 'c elt_ -> 'a) -> 'a -> ('b, 'c) map -> 'a
      val map : ('a elt_ -> 'b elt_) -> ('c, 'a) map -> ('c, 'b) map
      val mapi :
        ('a key_ -> 'b elt_ -> 'c elt_) -> ('a, 'b) map -> ('a, 'c) map
      val union :
        ('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
        ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
      val inter :
        ('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
        ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
      val diff :
        ('a key_ -> 'b elt_ -> 'b elt_ -> bool) ->
        ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
      val well_formed : ('a, 'b) map -> bool
      val of_result : ('a, 'b, 'c) result_ -> 'a
      type ('a, 'b) cursor_ = ('a, 'b) cursor
      val to_cursor : ('a, 'b) map -> ('a, 'b) cursor_
      val from_cursor : ('a, 'b) cursor_ -> ('a, 'b) map
      val at_top : ('a, 'b) cursor_ -> bool
      val at_left : ('a, 'b) cursor_ -> bool
      val at_right : ('a, 'b) cursor_ -> bool
      val move_up : ('a, 'b) cursor_ -> ('a, 'b) cursor_
      val move_down_left : ('a, 'b) cursor_ -> ('a, 'b) cursor_
      val move_down_right : ('a, 'b) cursor_ -> ('a, 'b) cursor_
      val went_left : ('a, 'b) cursor_ -> bool
      val went_right : ('a, 'b) cursor_ -> bool
      val has_value : ('a, 'b) cursor_ -> bool
      val get_value : ('a, 'b) cursor_ -> 'a key_ * 'b elt_
      val gen2 :
        (?size:int -> Random.State.t -> 'a key_) ->
        (?size:int -> Random.State.t -> 'b elt_) ->
        ?size:int -> Random.State.t -> ('a, 'b) map
      val to_string : ('a -> 'b -> string) -> ('a, 'b) map -> string
      val compare :
        ('a -> 'a -> int) ->
        ('b -> 'b -> int) ->
        ('a, 'b) Reins.Maps.PolyMapSig.t ->
        ('a, 'b) Reins.Maps.PolyMapSig.t -> int
      val compare_keys :
        ('a -> 'a -> int) ->
        ('a, 'b) Reins.Maps.PolyMapSig.t ->
        ('a, 'b) Reins.Maps.PolyMapSig.t -> int
    end
  module type PolyMapSigStd =
    sig
      type ('a, 'b) t
      type 'a key = 'a
      type 'a elt = 'a
      type ('a, 'b) cursor
      type ('a, 'b, 'c) result = 'a
      type 'a key_ = 'a
      type 'a elt_ = 'a
      type ('a, 'b) map = ('a, 'b) t
      type ('a, 'b, 'c) result_ = ('a, 'b, 'c) result
      val empty : ('a, 'b) map
      val is_empty : ('a, 'b) map -> bool
      val mem : 'a key_ -> ('a, 'b) map -> (bool, 'a, 'b) result_
      val add : 'a key_ -> 'b elt_ -> ('a, 'b) map -> ('a, 'b) map
      val singleton : 'a key_ -> 'b elt_ -> ('a, 'b) map
      val remove : 'a key_ -> ('a, 'b) map -> ('a, 'b) map
      val find : 'a key_ -> ('a, 'b) map -> ('b elt_, 'a, 'b) result_
      val min_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
      val max_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
      val min_keyval : ('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
      val max_keyval : ('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
      val cardinal : ('a, 'b) map -> int
      val iter : ('a key_ -> 'b elt_ -> unit) -> ('a, 'b) map -> unit
      val fold : ('a -> 'b key_ -> 'c elt_ -> 'a) -> 'a -> ('b, 'c) map -> 'a
      val map : ('a elt_ -> 'b elt_) -> ('c, 'a) map -> ('c, 'b) map
      val mapi :
        ('a key_ -> 'b elt_ -> 'c elt_) -> ('a, 'b) map -> ('a, 'c) map
      val union :
        ('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
        ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
      val inter :
        ('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
        ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
      val diff :
        ('a key_ -> 'b elt_ -> 'b elt_ -> bool) ->
        ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
      val well_formed : ('a, 'b) map -> bool
      val of_result : ('a, 'b, 'c) result_ -> 'a
      type ('a, 'b) cursor_ = ('a, 'b) cursor
      val to_cursor : ('a, 'b) map -> ('a, 'b) cursor_
      val from_cursor : ('a, 'b) cursor_ -> ('a, 'b) map
      val at_top : ('a, 'b) cursor_ -> bool
      val at_left : ('a, 'b) cursor_ -> bool
      val at_right : ('a, 'b) cursor_ -> bool
      val move_up : ('a, 'b) cursor_ -> ('a, 'b) cursor_
      val move_down_left : ('a, 'b) cursor_ -> ('a, 'b) cursor_
      val move_down_right : ('a, 'b) cursor_ -> ('a, 'b) cursor_
      val went_left : ('a, 'b) cursor_ -> bool
      val went_right : ('a, 'b) cursor_ -> bool
      val has_value : ('a, 'b) cursor_ -> bool
      val get_value : ('a, 'b) cursor_ -> 'a key_ * 'b elt_
      val gen2 :
        (?size:int -> Random.State.t -> 'a key_) ->
        (?size:int -> Random.State.t -> 'b elt_) ->
        ?size:int -> Random.State.t -> ('a, 'b) map
      val to_string : ('a -> 'b -> string) -> ('a, 'b) map -> string
      val compare :
        ('a -> 'a -> int) ->
        ('b -> 'b -> int) -> ('a, 'b) t -> ('a, 'b) t -> int
      val compare_keys : ('a -> 'a -> int) -> ('a, 'b) t -> ('a, 'b) t -> int
    end
  module type MonoKeyMapSig =
    sig
      type 'a t
      type key
      type 'a elt = 'a
      type 'a cursor
      type ('a, 'b) result
      type 'a key_ = key
      type 'a elt_ = 'a
      type ('a, 'b) map = 'b t
      type ('a, 'b, 'c) result_ = ('a, 'c) result
      val empty : ('a, 'b) map
      val is_empty : ('a, 'b) map -> bool
      val mem : 'a key_ -> ('a, 'b) map -> (bool, 'a, 'b) result_
      val add : 'a key_ -> 'b elt_ -> ('a, 'b) map -> ('a, 'b) map
      val singleton : 'a key_ -> 'b elt_ -> ('a, 'b) map
      val remove : 'a key_ -> ('a, 'b) map -> ('a, 'b) map
      val find : 'a key_ -> ('a, 'b) map -> ('b elt_, 'a, 'b) result_
      val min_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
      val max_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
      val min_keyval : ('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
      val max_keyval : ('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
      val cardinal : ('a, 'b) map -> int
      val iter : ('a key_ -> 'b elt_ -> unit) -> ('a, 'b) map -> unit
      val fold : ('a -> 'b key_ -> 'c elt_ -> 'a) -> 'a -> ('b, 'c) map -> 'a
      val map : ('a elt_ -> 'b elt_) -> ('c, 'a) map -> ('c, 'b) map
      val mapi :
        ('a key_ -> 'b elt_ -> 'c elt_) -> ('a, 'b) map -> ('a, 'c) map
      val union :
        ('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
        ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
      val inter :
        ('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
        ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
      val diff :
        ('a key_ -> 'b elt_ -> 'b elt_ -> bool) ->
        ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
      val well_formed : ('a, 'b) map -> bool
      val of_result : ('a, 'b, 'c) result_ -> 'a
      type ('a, 'b) cursor_ = 'b cursor
      val to_cursor : ('a, 'b) map -> ('a, 'b) cursor_
      val from_cursor : ('a, 'b) cursor_ -> ('a, 'b) map
      val at_top : ('a, 'b) cursor_ -> bool
      val at_left : ('a, 'b) cursor_ -> bool
      val at_right : ('a, 'b) cursor_ -> bool
      val move_up : ('a, 'b) cursor_ -> ('a, 'b) cursor_
      val move_down_left : ('a, 'b) cursor_ -> ('a, 'b) cursor_
      val move_down_right : ('a, 'b) cursor_ -> ('a, 'b) cursor_
      val went_left : ('a, 'b) cursor_ -> bool
      val went_right : ('a, 'b) cursor_ -> bool
      val has_value : ('a, 'b) cursor_ -> bool
      val get_value : ('a, 'b) cursor_ -> 'a key_ * 'b elt_
      val compare_keys :
        'a Reins.Maps.MonoKeyMapSig.t -> 'a Reins.Maps.MonoKeyMapSig.t -> int
      val compare :
        ('a -> 'a -> int) ->
        'a Reins.Maps.MonoKeyMapSig.t -> 'a Reins.Maps.MonoKeyMapSig.t -> int
      val to_string :
        ('a -> string) -> 'a Reins.Maps.MonoKeyMapSig.t -> string
      val gen2 :
        (?size:int -> Random.State.t -> Reins.Maps.MonoKeyMapSig.key) ->
        (?size:int -> Random.State.t -> 'a) ->
        ?size:int -> Random.State.t -> 'a Reins.Maps.MonoKeyMapSig.t
    end
  module type MonoKeyMapSigStd =
    sig
      type 'a t
      type key
      type 'a elt = 'a
      type 'a cursor
      type ('a, 'b) result = 'a
      type 'a key_ = key
      type 'a elt_ = 'a
      type ('a, 'b) map = 'b t
      type ('a, 'b, 'c) result_ = ('a, 'c) result
      val empty : ('a, 'b) map
      val is_empty : ('a, 'b) map -> bool
      val mem : 'a key_ -> ('a, 'b) map -> (bool, 'a, 'b) result_
      val add : 'a key_ -> 'b elt_ -> ('a, 'b) map -> ('a, 'b) map
      val singleton : 'a key_ -> 'b elt_ -> ('a, 'b) map
      val remove : 'a key_ -> ('a, 'b) map -> ('a, 'b) map
      val find : 'a key_ -> ('a, 'b) map -> ('b elt_, 'a, 'b) result_
      val min_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
      val max_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
      val min_keyval : ('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
      val max_keyval : ('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
      val cardinal : ('a, 'b) map -> int
      val iter : ('a key_ -> 'b elt_ -> unit) -> ('a, 'b) map -> unit
      val fold : ('a -> 'b key_ -> 'c elt_ -> 'a) -> 'a -> ('b, 'c) map -> 'a
      val map : ('a elt_ -> 'b elt_) -> ('c, 'a) map -> ('c, 'b) map
      val mapi :
        ('a key_ -> 'b elt_ -> 'c elt_) -> ('a, 'b) map -> ('a, 'c) map
      val union :
        ('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
        ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
      val inter :
        ('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
        ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
      val diff :
        ('a key_ -> 'b elt_ -> 'b elt_ -> bool) ->
        ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
      val well_formed : ('a, 'b) map -> bool
      val of_result : ('a, 'b, 'c) result_ -> 'a
      type ('a, 'b) cursor_ = 'b cursor
      val to_cursor : ('a, 'b) map -> ('a, 'b) cursor_
      val from_cursor : ('a, 'b) cursor_ -> ('a, 'b) map
      val at_top : ('a, 'b) cursor_ -> bool
      val at_left : ('a, 'b) cursor_ -> bool
      val at_right : ('a, 'b) cursor_ -> bool
      val move_up : ('a, 'b) cursor_ -> ('a, 'b) cursor_
      val move_down_left : ('a, 'b) cursor_ -> ('a, 'b) cursor_
      val move_down_right : ('a, 'b) cursor_ -> ('a, 'b) cursor_
      val went_left : ('a, 'b) cursor_ -> bool
      val went_right : ('a, 'b) cursor_ -> bool
      val has_value : ('a, 'b) cursor_ -> bool
      val get_value : ('a, 'b) cursor_ -> 'a key_ * 'b elt_
      val compare_keys : 'a t -> 'a t -> int
      val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
      val to_string : ('a -> string) -> 'a t -> string
      val gen2 :
        (?size:int -> Random.State.t -> key) ->
        (?size:int -> Random.State.t -> 'a) ->
        ?size:int -> Random.State.t -> 'a t
    end
  module type MonoKeyMapSigFnStd =
    functor (C : Types.Mono.Comparable) ->
      sig
        type 'a t
        type key = C.t
        type 'a elt = 'a
        type 'a cursor
        type ('a, 'b) result = 'a
        type 'a key_ = key
        type 'a elt_ = 'a
        type ('a, 'b) map = 'b t
        type ('a, 'b, 'c) result_ = ('a, 'c) result
        val empty : ('a, 'b) map
        val is_empty : ('a, 'b) map -> bool
        val mem : 'a key_ -> ('a, 'b) map -> (bool, 'a, 'b) result_
        val add : 'a key_ -> 'b elt_ -> ('a, 'b) map -> ('a, 'b) map
        val singleton : 'a key_ -> 'b elt_ -> ('a, 'b) map
        val remove : 'a key_ -> ('a, 'b) map -> ('a, 'b) map
        val find : 'a key_ -> ('a, 'b) map -> ('b elt_, 'a, 'b) result_
        val min_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
        val max_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
        val min_keyval : ('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
        val max_keyval : ('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
        val cardinal : ('a, 'b) map -> int
        val iter : ('a key_ -> 'b elt_ -> unit) -> ('a, 'b) map -> unit
        val fold :
          ('a -> 'b key_ -> 'c elt_ -> 'a) -> 'a -> ('b, 'c) map -> 'a
        val map : ('a elt_ -> 'b elt_) -> ('c, 'a) map -> ('c, 'b) map
        val mapi :
          ('a key_ -> 'b elt_ -> 'c elt_) -> ('a, 'b) map -> ('a, 'c) map
        val union :
          ('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
          ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
        val inter :
          ('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
          ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
        val diff :
          ('a key_ -> 'b elt_ -> 'b elt_ -> bool) ->
          ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
        val well_formed : ('a, 'b) map -> bool
        val of_result : ('a, 'b, 'c) result_ -> 'a
        type ('a, 'b) cursor_ = 'b cursor
        val to_cursor : ('a, 'b) map -> ('a, 'b) cursor_
        val from_cursor : ('a, 'b) cursor_ -> ('a, 'b) map
        val at_top : ('a, 'b) cursor_ -> bool
        val at_left : ('a, 'b) cursor_ -> bool
        val at_right : ('a, 'b) cursor_ -> bool
        val move_up : ('a, 'b) cursor_ -> ('a, 'b) cursor_
        val move_down_left : ('a, 'b) cursor_ -> ('a, 'b) cursor_
        val move_down_right : ('a, 'b) cursor_ -> ('a, 'b) cursor_
        val went_left : ('a, 'b) cursor_ -> bool
        val went_right : ('a, 'b) cursor_ -> bool
        val has_value : ('a, 'b) cursor_ -> bool
        val get_value : ('a, 'b) cursor_ -> 'a key_ * 'b elt_
        val compare_keys : 'a t -> 'a t -> int
        val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
        val to_string : ('a -> string) -> 'a t -> string
        val gen2 :
          (?size:int -> Random.State.t -> key) ->
          (?size:int -> Random.State.t -> 'a) ->
          ?size:int -> Random.State.t -> 'a t
      end
  module type GenKeyMapSig =
    sig
      type 'a t
      type key
      type 'a elt = 'a
      type 'a cursor
      type ('a, 'b) result
      type 'a key_ = key
      type 'a elt_ = 'a
      type ('a, 'b) map = 'b t
      type ('a, 'b, 'c) result_ = ('a, 'c) result
      val empty : ('a, 'b) map
      val is_empty : ('a, 'b) map -> bool
      val mem : 'a key_ -> ('a, 'b) map -> (bool, 'a, 'b) result_
      val add : 'a key_ -> 'b elt_ -> ('a, 'b) map -> ('a, 'b) map
      val singleton : 'a key_ -> 'b elt_ -> ('a, 'b) map
      val remove : 'a key_ -> ('a, 'b) map -> ('a, 'b) map
      val find : 'a key_ -> ('a, 'b) map -> ('b elt_, 'a, 'b) result_
      val min_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
      val max_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
      val min_keyval : ('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
      val max_keyval : ('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
      val cardinal : ('a, 'b) map -> int
      val iter : ('a key_ -> 'b elt_ -> unit) -> ('a, 'b) map -> unit
      val fold : ('a -> 'b key_ -> 'c elt_ -> 'a) -> 'a -> ('b, 'c) map -> 'a
      val map : ('a elt_ -> 'b elt_) -> ('c, 'a) map -> ('c, 'b) map
      val mapi :
        ('a key_ -> 'b elt_ -> 'c elt_) -> ('a, 'b) map -> ('a, 'c) map
      val union :
        ('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
        ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
      val inter :
        ('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
        ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
      val diff :
        ('a key_ -> 'b elt_ -> 'b elt_ -> bool) ->
        ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
      val well_formed : ('a, 'b) map -> bool
      val of_result : ('a, 'b, 'c) result_ -> 'a
      type ('a, 'b) cursor_ = 'b cursor
      val to_cursor : ('a, 'b) map -> ('a, 'b) cursor_
      val from_cursor : ('a, 'b) cursor_ -> ('a, 'b) map
      val at_top : ('a, 'b) cursor_ -> bool
      val at_left : ('a, 'b) cursor_ -> bool
      val at_right : ('a, 'b) cursor_ -> bool
      val move_up : ('a, 'b) cursor_ -> ('a, 'b) cursor_
      val move_down_left : ('a, 'b) cursor_ -> ('a, 'b) cursor_
      val move_down_right : ('a, 'b) cursor_ -> ('a, 'b) cursor_
      val went_left : ('a, 'b) cursor_ -> bool
      val went_right : ('a, 'b) cursor_ -> bool
      val has_value : ('a, 'b) cursor_ -> bool
      val get_value : ('a, 'b) cursor_ -> 'a key_ * 'b elt_
      val compare_keys : 'a t -> 'a t -> int
      val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
      val to_string : ('a -> string) -> 'a t -> string
      val gen2 :
        (?size:int -> Random.State.t -> key) ->
        (?size:int -> Random.State.t -> 'a) ->
        ?size:int -> Random.State.t -> 'a t
      val gen1 :
        (?size:int -> Random.State.t -> 'a) ->
        ?size:int -> Random.State.t -> 'a t
    end
  module type GenKeyMapSigStd =
    sig
      type 'a t
      type key
      type 'a elt = 'a
      type 'a cursor
      type ('a, 'b) result = 'a
      type 'a key_ = key
      type 'a elt_ = 'a
      type ('a, 'b) map = 'b t
      type ('a, 'b, 'c) result_ = ('a, 'c) result
      val empty : ('a, 'b) map
      val is_empty : ('a, 'b) map -> bool
      val mem : 'a key_ -> ('a, 'b) map -> (bool, 'a, 'b) result_
      val add : 'a key_ -> 'b elt_ -> ('a, 'b) map -> ('a, 'b) map
      val singleton : 'a key_ -> 'b elt_ -> ('a, 'b) map
      val remove : 'a key_ -> ('a, 'b) map -> ('a, 'b) map
      val find : 'a key_ -> ('a, 'b) map -> ('b elt_, 'a, 'b) result_
      val min_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
      val max_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
      val min_keyval : ('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
      val max_keyval : ('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
      val cardinal : ('a, 'b) map -> int
      val iter : ('a key_ -> 'b elt_ -> unit) -> ('a, 'b) map -> unit
      val fold : ('a -> 'b key_ -> 'c elt_ -> 'a) -> 'a -> ('b, 'c) map -> 'a
      val map : ('a elt_ -> 'b elt_) -> ('c, 'a) map -> ('c, 'b) map
      val mapi :
        ('a key_ -> 'b elt_ -> 'c elt_) -> ('a, 'b) map -> ('a, 'c) map
      val union :
        ('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
        ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
      val inter :
        ('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
        ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
      val diff :
        ('a key_ -> 'b elt_ -> 'b elt_ -> bool) ->
        ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
      val well_formed : ('a, 'b) map -> bool
      val of_result : ('a, 'b, 'c) result_ -> 'a
      type ('a, 'b) cursor_ = 'b cursor
      val to_cursor : ('a, 'b) map -> ('a, 'b) cursor_
      val from_cursor : ('a, 'b) cursor_ -> ('a, 'b) map
      val at_top : ('a, 'b) cursor_ -> bool
      val at_left : ('a, 'b) cursor_ -> bool
      val at_right : ('a, 'b) cursor_ -> bool
      val move_up : ('a, 'b) cursor_ -> ('a, 'b) cursor_
      val move_down_left : ('a, 'b) cursor_ -> ('a, 'b) cursor_
      val move_down_right : ('a, 'b) cursor_ -> ('a, 'b) cursor_
      val went_left : ('a, 'b) cursor_ -> bool
      val went_right : ('a, 'b) cursor_ -> bool
      val has_value : ('a, 'b) cursor_ -> bool
      val get_value : ('a, 'b) cursor_ -> 'a key_ * 'b elt_
      val compare_keys : 'a t -> 'a t -> int
      val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
      val to_string : ('a -> string) -> 'a t -> string
      val gen2 :
        (?size:int -> Random.State.t -> key) ->
        (?size:int -> Random.State.t -> 'a) ->
        ?size:int -> Random.State.t -> 'a t
      val gen1 :
        (?size:int -> Random.State.t -> 'a) ->
        ?size:int -> Random.State.t -> 'a t
    end
  module type GenKeyMapSigFnStd =
    functor (C : Types.Mono.ArbitraryComparable) ->
      sig
        type 'a t
        type key = C.t
        type 'a elt = 'a
        type 'a cursor
        type ('a, 'b) result = 'a
        type 'a key_ = key
        type 'a elt_ = 'a
        type ('a, 'b) map = 'b t
        type ('a, 'b, 'c) result_ = ('a, 'c) result
        val empty : ('a, 'b) map
        val is_empty : ('a, 'b) map -> bool
        val mem : 'a key_ -> ('a, 'b) map -> (bool, 'a, 'b) result_
        val add : 'a key_ -> 'b elt_ -> ('a, 'b) map -> ('a, 'b) map
        val singleton : 'a key_ -> 'b elt_ -> ('a, 'b) map
        val remove : 'a key_ -> ('a, 'b) map -> ('a, 'b) map
        val find : 'a key_ -> ('a, 'b) map -> ('b elt_, 'a, 'b) result_
        val min_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
        val max_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
        val min_keyval : ('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
        val max_keyval : ('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
        val cardinal : ('a, 'b) map -> int
        val iter : ('a key_ -> 'b elt_ -> unit) -> ('a, 'b) map -> unit
        val fold :
          ('a -> 'b key_ -> 'c elt_ -> 'a) -> 'a -> ('b, 'c) map -> 'a
        val map : ('a elt_ -> 'b elt_) -> ('c, 'a) map -> ('c, 'b) map
        val mapi :
          ('a key_ -> 'b elt_ -> 'c elt_) -> ('a, 'b) map -> ('a, 'c) map
        val union :
          ('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
          ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
        val inter :
          ('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
          ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
        val diff :
          ('a key_ -> 'b elt_ -> 'b elt_ -> bool) ->
          ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
        val well_formed : ('a, 'b) map -> bool
        val of_result : ('a, 'b, 'c) result_ -> 'a
        type ('a, 'b) cursor_ = 'b cursor
        val to_cursor : ('a, 'b) map -> ('a, 'b) cursor_
        val from_cursor : ('a, 'b) cursor_ -> ('a, 'b) map
        val at_top : ('a, 'b) cursor_ -> bool
        val at_left : ('a, 'b) cursor_ -> bool
        val at_right : ('a, 'b) cursor_ -> bool
        val move_up : ('a, 'b) cursor_ -> ('a, 'b) cursor_
        val move_down_left : ('a, 'b) cursor_ -> ('a, 'b) cursor_
        val move_down_right : ('a, 'b) cursor_ -> ('a, 'b) cursor_
        val went_left : ('a, 'b) cursor_ -> bool
        val went_right : ('a, 'b) cursor_ -> bool
        val has_value : ('a, 'b) cursor_ -> bool
        val get_value : ('a, 'b) cursor_ -> 'a key_ * 'b elt_
        val compare_keys : 'a t -> 'a t -> int
        val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
        val to_string : ('a -> string) -> 'a t -> string
        val gen2 :
          (?size:int -> Random.State.t -> key) ->
          (?size:int -> Random.State.t -> 'a) ->
          ?size:int -> Random.State.t -> 'a t
        val gen1 :
          (?size:int -> Random.State.t -> 'a) ->
          ?size:int -> Random.State.t -> 'a t
      end
  module type MonoMapSig =
    sig
      type t
      type key
      type elt
      type cursor
      type 'a result
      type 'a key_ = key
      type 'a elt_ = elt
      type ('a, 'b) map = t
      type ('a, 'b, 'c) result_ = 'a result
      val empty : ('a, 'b) map
      val is_empty : ('a, 'b) map -> bool
      val mem : 'a key_ -> ('a, 'b) map -> (bool, 'a, 'b) result_
      val add : 'a key_ -> 'b elt_ -> ('a, 'b) map -> ('a, 'b) map
      val singleton : 'a key_ -> 'b elt_ -> ('a, 'b) map
      val remove : 'a key_ -> ('a, 'b) map -> ('a, 'b) map
      val find : 'a key_ -> ('a, 'b) map -> ('b elt_, 'a, 'b) result_
      val min_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
      val max_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
      val min_keyval : ('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
      val max_keyval : ('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
      val cardinal : ('a, 'b) map -> int
      val iter : ('a key_ -> 'b elt_ -> unit) -> ('a, 'b) map -> unit
      val fold : ('a -> 'b key_ -> 'c elt_ -> 'a) -> 'a -> ('b, 'c) map -> 'a
      val map : ('a elt_ -> 'b elt_) -> ('c, 'a) map -> ('c, 'b) map
      val mapi :
        ('a key_ -> 'b elt_ -> 'c elt_) -> ('a, 'b) map -> ('a, 'c) map
      val union :
        ('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
        ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
      val inter :
        ('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
        ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
      val diff :
        ('a key_ -> 'b elt_ -> 'b elt_ -> bool) ->
        ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
      val well_formed : ('a, 'b) map -> bool
      val of_result : ('a, 'b, 'c) result_ -> 'a
      type ('a, 'b) cursor_ = cursor
      val to_cursor : ('a, 'b) map -> ('a, 'b) cursor_
      val from_cursor : ('a, 'b) cursor_ -> ('a, 'b) map
      val at_top : ('a, 'b) cursor_ -> bool
      val at_left : ('a, 'b) cursor_ -> bool
      val at_right : ('a, 'b) cursor_ -> bool
      val move_up : ('a, 'b) cursor_ -> ('a, 'b) cursor_
      val move_down_left : ('a, 'b) cursor_ -> ('a, 'b) cursor_
      val move_down_right : ('a, 'b) cursor_ -> ('a, 'b) cursor_
      val went_left : ('a, 'b) cursor_ -> bool
      val went_right : ('a, 'b) cursor_ -> bool
      val has_value : ('a, 'b) cursor_ -> bool
      val get_value : ('a, 'b) cursor_ -> 'a key_ * 'b elt_
      val compare_keys :
        Reins.Maps.MonoMapSig.t -> Reins.Maps.MonoMapSig.t -> int
      val compare : Reins.Maps.MonoMapSig.t -> Reins.Maps.MonoMapSig.t -> int
      val to_string : Reins.Maps.MonoMapSig.t -> string
      val gen2 :
        (?size:int -> Random.State.t -> Reins.Maps.MonoMapSig.key) ->
        (?size:int -> Random.State.t -> Reins.Maps.MonoMapSig.elt) ->
        ?size:int -> Random.State.t -> Reins.Maps.MonoMapSig.t
    end
  module type MonoMapSigFn =
    functor (K : Types.Mono.Comparable) ->
      functor (V : Types.Mono.Comparable) ->
        sig
          type t
          type key = K.t
          type elt = V.t
          type cursor
          type 'a result
          type 'a key_ = key
          type 'a elt_ = elt
          type ('a, 'b) map = t
          type ('a, 'b, 'c) result_ = 'a result
          val empty : ('a, 'b) map
          val is_empty : ('a, 'b) map -> bool
          val mem : 'a key_ -> ('a, 'b) map -> (bool, 'a, 'b) result_
          val add : 'a key_ -> 'b elt_ -> ('a, 'b) map -> ('a, 'b) map
          val singleton : 'a key_ -> 'b elt_ -> ('a, 'b) map
          val remove : 'a key_ -> ('a, 'b) map -> ('a, 'b) map
          val find : 'a key_ -> ('a, 'b) map -> ('b elt_, 'a, 'b) result_
          val min_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
          val max_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
          val min_keyval :
            ('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
          val max_keyval :
            ('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
          val cardinal : ('a, 'b) map -> int
          val iter : ('a key_ -> 'b elt_ -> unit) -> ('a, 'b) map -> unit
          val fold :
            ('a -> 'b key_ -> 'c elt_ -> 'a) -> 'a -> ('b, 'c) map -> 'a
          val map : ('a elt_ -> 'b elt_) -> ('c, 'a) map -> ('c, 'b) map
          val mapi :
            ('a key_ -> 'b elt_ -> 'c elt_) -> ('a, 'b) map -> ('a, 'c) map
          val union :
            ('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
            ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
          val inter :
            ('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
            ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
          val diff :
            ('a key_ -> 'b elt_ -> 'b elt_ -> bool) ->
            ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
          val well_formed : ('a, 'b) map -> bool
          val of_result : ('a, 'b, 'c) result_ -> 'a
          type ('a, 'b) cursor_ = cursor
          val to_cursor : ('a, 'b) map -> ('a, 'b) cursor_
          val from_cursor : ('a, 'b) cursor_ -> ('a, 'b) map
          val at_top : ('a, 'b) cursor_ -> bool
          val at_left : ('a, 'b) cursor_ -> bool
          val at_right : ('a, 'b) cursor_ -> bool
          val move_up : ('a, 'b) cursor_ -> ('a, 'b) cursor_
          val move_down_left : ('a, 'b) cursor_ -> ('a, 'b) cursor_
          val move_down_right : ('a, 'b) cursor_ -> ('a, 'b) cursor_
          val went_left : ('a, 'b) cursor_ -> bool
          val went_right : ('a, 'b) cursor_ -> bool
          val has_value : ('a, 'b) cursor_ -> bool
          val get_value : ('a, 'b) cursor_ -> 'a key_ * 'b elt_
          val compare_keys : t -> t -> int
          val compare : t -> t -> int
          val to_string : t -> string
          val gen2 :
            (?size:int -> Random.State.t -> key) ->
            (?size:int -> Random.State.t -> elt) ->
            ?size:int -> Random.State.t -> t
        end
  module type MonoMapSigFnStd =
    functor (K : Types.Mono.Comparable) ->
      functor (V : Types.Mono.Comparable) ->
        sig
          type t
          type key = K.t
          type elt = V.t
          type cursor
          type 'a result = 'a
          type 'a key_ = key
          type 'a elt_ = elt
          type ('a, 'b) map = t
          type ('a, 'b, 'c) result_ = 'a result
          val empty : ('a, 'b) map
          val is_empty : ('a, 'b) map -> bool
          val mem : 'a key_ -> ('a, 'b) map -> (bool, 'a, 'b) result_
          val add : 'a key_ -> 'b elt_ -> ('a, 'b) map -> ('a, 'b) map
          val singleton : 'a key_ -> 'b elt_ -> ('a, 'b) map
          val remove : 'a key_ -> ('a, 'b) map -> ('a, 'b) map
          val find : 'a key_ -> ('a, 'b) map -> ('b elt_, 'a, 'b) result_
          val min_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
          val max_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
          val min_keyval :
            ('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
          val max_keyval :
            ('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
          val cardinal : ('a, 'b) map -> int
          val iter : ('a key_ -> 'b elt_ -> unit) -> ('a, 'b) map -> unit
          val fold :
            ('a -> 'b key_ -> 'c elt_ -> 'a) -> 'a -> ('b, 'c) map -> 'a
          val map : ('a elt_ -> 'b elt_) -> ('c, 'a) map -> ('c, 'b) map
          val mapi :
            ('a key_ -> 'b elt_ -> 'c elt_) -> ('a, 'b) map -> ('a, 'c) map
          val union :
            ('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
            ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
          val inter :
            ('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
            ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
          val diff :
            ('a key_ -> 'b elt_ -> 'b elt_ -> bool) ->
            ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
          val well_formed : ('a, 'b) map -> bool
          val of_result : ('a, 'b, 'c) result_ -> 'a
          type ('a, 'b) cursor_ = cursor
          val to_cursor : ('a, 'b) map -> ('a, 'b) cursor_
          val from_cursor : ('a, 'b) cursor_ -> ('a, 'b) map
          val at_top : ('a, 'b) cursor_ -> bool
          val at_left : ('a, 'b) cursor_ -> bool
          val at_right : ('a, 'b) cursor_ -> bool
          val move_up : ('a, 'b) cursor_ -> ('a, 'b) cursor_
          val move_down_left : ('a, 'b) cursor_ -> ('a, 'b) cursor_
          val move_down_right : ('a, 'b) cursor_ -> ('a, 'b) cursor_
          val went_left : ('a, 'b) cursor_ -> bool
          val went_right : ('a, 'b) cursor_ -> bool
          val has_value : ('a, 'b) cursor_ -> bool
          val get_value : ('a, 'b) cursor_ -> 'a key_ * 'b elt_
          val compare_keys : t -> t -> int
          val compare : t -> t -> int
          val to_string : t -> string
          val gen2 :
            (?size:int -> Random.State.t -> key) ->
            (?size:int -> Random.State.t -> elt) ->
            ?size:int -> Random.State.t -> t
        end
  module type GenMapSig =
    sig
      type t
      type key
      type elt
      type cursor
      type 'a result
      type 'a key_ = key
      type 'a elt_ = elt
      type ('a, 'b) map = t
      type ('a, 'b, 'c) result_ = 'a result
      val empty : ('a, 'b) map
      val is_empty : ('a, 'b) map -> bool
      val mem : 'a key_ -> ('a, 'b) map -> (bool, 'a, 'b) result_
      val add : 'a key_ -> 'b elt_ -> ('a, 'b) map -> ('a, 'b) map
      val singleton : 'a key_ -> 'b elt_ -> ('a, 'b) map
      val remove : 'a key_ -> ('a, 'b) map -> ('a, 'b) map
      val find : 'a key_ -> ('a, 'b) map -> ('b elt_, 'a, 'b) result_
      val min_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
      val max_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
      val min_keyval : ('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
      val max_keyval : ('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
      val cardinal : ('a, 'b) map -> int
      val iter : ('a key_ -> 'b elt_ -> unit) -> ('a, 'b) map -> unit
      val fold : ('a -> 'b key_ -> 'c elt_ -> 'a) -> 'a -> ('b, 'c) map -> 'a
      val map : ('a elt_ -> 'b elt_) -> ('c, 'a) map -> ('c, 'b) map
      val mapi :
        ('a key_ -> 'b elt_ -> 'c elt_) -> ('a, 'b) map -> ('a, 'c) map
      val union :
        ('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
        ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
      val inter :
        ('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
        ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
      val diff :
        ('a key_ -> 'b elt_ -> 'b elt_ -> bool) ->
        ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
      val well_formed : ('a, 'b) map -> bool
      val of_result : ('a, 'b, 'c) result_ -> 'a
      type ('a, 'b) cursor_ = cursor
      val to_cursor : ('a, 'b) map -> ('a, 'b) cursor_
      val from_cursor : ('a, 'b) cursor_ -> ('a, 'b) map
      val at_top : ('a, 'b) cursor_ -> bool
      val at_left : ('a, 'b) cursor_ -> bool
      val at_right : ('a, 'b) cursor_ -> bool
      val move_up : ('a, 'b) cursor_ -> ('a, 'b) cursor_
      val move_down_left : ('a, 'b) cursor_ -> ('a, 'b) cursor_
      val move_down_right : ('a, 'b) cursor_ -> ('a, 'b) cursor_
      val went_left : ('a, 'b) cursor_ -> bool
      val went_right : ('a, 'b) cursor_ -> bool
      val has_value : ('a, 'b) cursor_ -> bool
      val get_value : ('a, 'b) cursor_ -> 'a key_ * 'b elt_
      val compare_keys : t -> t -> int
      val compare : t -> t -> int
      val to_string : t -> string
      val gen2 :
        (?size:int -> Random.State.t -> key) ->
        (?size:int -> Random.State.t -> elt) ->
        ?size:int -> Random.State.t -> t
      val gen : ?size:int -> Random.State.t -> t
    end
  module type GenMapSigFn =
    functor (K : Types.Mono.ArbitraryComparable) ->
      functor (V : Types.Mono.ArbitraryComparable) ->
        sig
          type t
          type key = K.t
          type elt = V.t
          type cursor
          type 'a result
          type 'a key_ = key
          type 'a elt_ = elt
          type ('a, 'b) map = t
          type ('a, 'b, 'c) result_ = 'a result
          val empty : ('a, 'b) map
          val is_empty : ('a, 'b) map -> bool
          val mem : 'a key_ -> ('a, 'b) map -> (bool, 'a, 'b) result_
          val add : 'a key_ -> 'b elt_ -> ('a, 'b) map -> ('a, 'b) map
          val singleton : 'a key_ -> 'b elt_ -> ('a, 'b) map
          val remove : 'a key_ -> ('a, 'b) map -> ('a, 'b) map
          val find : 'a key_ -> ('a, 'b) map -> ('b elt_, 'a, 'b) result_
          val min_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
          val max_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
          val min_keyval :
            ('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
          val max_keyval :
            ('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
          val cardinal : ('a, 'b) map -> int
          val iter : ('a key_ -> 'b elt_ -> unit) -> ('a, 'b) map -> unit
          val fold :
            ('a -> 'b key_ -> 'c elt_ -> 'a) -> 'a -> ('b, 'c) map -> 'a
          val map : ('a elt_ -> 'b elt_) -> ('c, 'a) map -> ('c, 'b) map
          val mapi :
            ('a key_ -> 'b elt_ -> 'c elt_) -> ('a, 'b) map -> ('a, 'c) map
          val union :
            ('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
            ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
          val inter :
            ('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
            ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
          val diff :
            ('a key_ -> 'b elt_ -> 'b elt_ -> bool) ->
            ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
          val well_formed : ('a, 'b) map -> bool
          val of_result : ('a, 'b, 'c) result_ -> 'a
          type ('a, 'b) cursor_ = cursor
          val to_cursor : ('a, 'b) map -> ('a, 'b) cursor_
          val from_cursor : ('a, 'b) cursor_ -> ('a, 'b) map
          val at_top : ('a, 'b) cursor_ -> bool
          val at_left : ('a, 'b) cursor_ -> bool
          val at_right : ('a, 'b) cursor_ -> bool
          val move_up : ('a, 'b) cursor_ -> ('a, 'b) cursor_
          val move_down_left : ('a, 'b) cursor_ -> ('a, 'b) cursor_
          val move_down_right : ('a, 'b) cursor_ -> ('a, 'b) cursor_
          val went_left : ('a, 'b) cursor_ -> bool
          val went_right : ('a, 'b) cursor_ -> bool
          val has_value : ('a, 'b) cursor_ -> bool
          val get_value : ('a, 'b) cursor_ -> 'a key_ * 'b elt_
          val compare_keys : t -> t -> int
          val compare : t -> t -> int
          val to_string : t -> string
          val gen2 :
            (?size:int -> Random.State.t -> key) ->
            (?size:int -> Random.State.t -> elt) ->
            ?size:int -> Random.State.t -> t
          val gen : ?size:int -> Random.State.t -> t
        end
  module type GenMapSigFnStd =
    functor (K : Types.Mono.ArbitraryComparable) ->
      functor (V : Types.Mono.ArbitraryComparable) ->
        sig
          type t
          type key = K.t
          type elt = V.t
          type cursor
          type 'a result = 'a
          type 'a key_ = key
          type 'a elt_ = elt
          type ('a, 'b) map = t
          type ('a, 'b, 'c) result_ = 'a result
          val empty : ('a, 'b) map
          val is_empty : ('a, 'b) map -> bool
          val mem : 'a key_ -> ('a, 'b) map -> (bool, 'a, 'b) result_
          val add : 'a key_ -> 'b elt_ -> ('a, 'b) map -> ('a, 'b) map
          val singleton : 'a key_ -> 'b elt_ -> ('a, 'b) map
          val remove : 'a key_ -> ('a, 'b) map -> ('a, 'b) map
          val find : 'a key_ -> ('a, 'b) map -> ('b elt_, 'a, 'b) result_
          val min_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
          val max_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
          val min_keyval :
            ('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
          val max_keyval :
            ('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
          val cardinal : ('a, 'b) map -> int
          val iter : ('a key_ -> 'b elt_ -> unit) -> ('a, 'b) map -> unit
          val fold :
            ('a -> 'b key_ -> 'c elt_ -> 'a) -> 'a -> ('b, 'c) map -> 'a
          val map : ('a elt_ -> 'b elt_) -> ('c, 'a) map -> ('c, 'b) map
          val mapi :
            ('a key_ -> 'b elt_ -> 'c elt_) -> ('a, 'b) map -> ('a, 'c) map
          val union :
            ('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
            ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
          val inter :
            ('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
            ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
          val diff :
            ('a key_ -> 'b elt_ -> 'b elt_ -> bool) ->
            ('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
          val well_formed : ('a, 'b) map -> bool
          val of_result : ('a, 'b, 'c) result_ -> 'a
          type ('a, 'b) cursor_ = cursor
          val to_cursor : ('a, 'b) map -> ('a, 'b) cursor_
          val from_cursor : ('a, 'b) cursor_ -> ('a, 'b) map
          val at_top : ('a, 'b) cursor_ -> bool
          val at_left : ('a, 'b) cursor_ -> bool
          val at_right : ('a, 'b) cursor_ -> bool
          val move_up : ('a, 'b) cursor_ -> ('a, 'b) cursor_
          val move_down_left : ('a, 'b) cursor_ -> ('a, 'b) cursor_
          val move_down_right : ('a, 'b) cursor_ -> ('a, 'b) cursor_
          val went_left : ('a, 'b) cursor_ -> bool
          val went_right : ('a, 'b) cursor_ -> bool
          val has_value : ('a, 'b) cursor_ -> bool
          val get_value : ('a, 'b) cursor_ -> 'a key_ * 'b elt_
          val compare_keys : t -> t -> int
          val compare : t -> t -> int
          val to_string : t -> string
          val gen2 :
            (?size:int -> Random.State.t -> key) ->
            (?size:int -> Random.State.t -> elt) ->
            ?size:int -> Random.State.t -> t
          val gen : ?size:int -> Random.State.t -> t
        end
end