sig
  type ('k, +'v, 'cmp) t
  val compare :
    ('-> '-> int) -> ('k, 'v, 'cmp) t -> ('k, 'v, 'cmp) t -> int
  val create :
    left_of_leftmost:'->
    value_right_of:('k, 'v, 'cmp) Core_kernel.Std.Map.t -> ('k, 'v, 'cmp) t
  val always :
    '->
    comparator:('k, 'cmp) Core_kernel.Std.Comparator.t -> ('k, 'v, 'cmp) t
  val find : ('k, 'v, 'cmp) t -> '-> 'v
  val change : ('k, 'v, 'cmp) t -> at:'-> '-> ('k, 'v, 'cmp) t
  val map : ('k, 'a, 'cmp) t -> f:('-> 'b) -> ('k, 'b, 'cmp) t
  val map2 :
    ('k, 'a, 'cmp) t ->
    ('k, 'b, 'cmp) t -> f:('-> '-> 'c) -> ('k, 'c, 'cmp) t
  val remove_changes_within :
    ('k, 'v, 'cmp) t -> 'Interval_map_intf.Interval.t -> ('k, 'v, 'cmp) t
  val set_within :
    ('k, 'v, 'cmp) t ->
    'Interval_map_intf.Interval.t -> '-> ('k, 'v, 'cmp) t
  val map_within :
    ('k, 'v, 'cmp) t ->
    'Interval_map_intf.Interval.t -> f:('-> 'v) -> ('k, 'v, 'cmp) t
  val construct_preimage :
    ('k, 'v, 'cmp) t ->
    ('v * 'Interval_map_intf.Interval.t) Core_kernel.Std.Sequence.t
  module Make :
    functor (T : Interval_map_intf.Type_with_map_module->
      sig
        module Key :
          sig
            type t = T.Map.Key.t
            type comparator_witness = T.Map.Key.comparator_witness
            val comparator :
              (t, comparator_witness) Core_kernel.Std.Comparator.comparator
          end
        module Interval :
          sig
            type t = Key.t Interval_map_intf.Interval.t
            val is_empty : t -> bool
            val contains : t -> Key.t -> bool
          end
        type 'a t = (Key.t, 'a, Key.comparator_witness) t
        val create :
          left_of_leftmost:'->
          value_right_of:(Key.t, 'a, Key.comparator_witness)
                         Core_kernel.Std.Map.t ->
          'a t
        val always : '-> 'a t
        val find : 'v t -> Key.t -> 'v
        val change : 'v t -> at:Key.t -> '-> 'v t
        val map : 'a t -> f:('-> 'b) -> 'b t
        val map2 : 'a t -> 'b t -> f:('-> '-> 'c) -> 'c t
        val remove_changes_within : 'v t -> Interval.t -> 'v t
        val set_within : 'v t -> Interval.t -> '-> 'v t
        val map_within : 'v t -> Interval.t -> f:('-> 'v) -> 'v t
        val construct_preimage :
          'v t -> ('v * Interval.t) Core_kernel.Std.Sequence.t
        val compare : ('-> '-> int) -> 'a t -> 'a t -> int
        val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
        val sexp_of_t : ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
      end
  module Make_with_boundary :
    functor (Key : Interval_map_intf.Key->
      sig
        module Left_boundary :
          sig
            type t = Key.t Left_boundary.t
            val ( >= ) : t -> t -> bool
            val ( <= ) : t -> t -> bool
            val ( = ) : t -> t -> bool
            val ( > ) : t -> t -> bool
            val ( < ) : t -> t -> bool
            val ( <> ) : t -> t -> bool
            val equal : t -> t -> bool
            val min : t -> t -> t
            val max : t -> t -> t
            val ascending : t -> t -> int
            val descending : t -> t -> int
            val between : t -> low:t -> high:t -> bool
            module Replace_polymorphic_compare :
              sig
                val ( >= ) : t -> t -> bool
                val ( <= ) : t -> t -> bool
                val ( = ) : t -> t -> bool
                val ( > ) : t -> t -> bool
                val ( < ) : t -> t -> bool
                val ( <> ) : t -> t -> bool
                val equal : t -> t -> bool
                val compare : t -> t -> int
                val min : t -> t -> t
                val max : t -> t -> t
                val _squelch_unused_module_warning_ : unit
              end
            type comparator_witness
            val comparator :
              (t, comparator_witness) Core_kernel.Comparator.comparator
            val validate_lbound :
              min:t Core_kernel.Comparable_intf.bound ->
              t Core_kernel.Validate.check
            val validate_ubound :
              max:t Core_kernel.Comparable_intf.bound ->
              t Core_kernel.Validate.check
            val validate_bound :
              min:t Core_kernel.Comparable_intf.bound ->
              max:t Core_kernel.Comparable_intf.bound ->
              t Core_kernel.Validate.check
            module Map :
              sig
                module Key :
                  sig
                    type t = t
                    type comparator_witness = comparator_witness
                    val comparator :
                      (t, comparator_witness)
                      Core_kernel.Comparator.comparator
                  end
                module Tree :
                  sig
                    type 'a t =
                        (Key.t, 'a, Key.comparator_witness)
                        Core_kernel.Core_map.Tree.t
                    val empty : 'a t
                    val singleton : Key.t -> '-> 'a t
                    val of_alist :
                      (Key.t * 'a) list ->
                      [ `Duplicate_key of Key.t | `Ok of 'a t ]
                    val of_alist_or_error :
                      (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t
                    val of_alist_exn : (Key.t * 'a) list -> 'a t
                    val of_alist_multi : (Key.t * 'a) list -> 'a list t
                    val of_alist_fold :
                      (Key.t * 'a) list ->
                      init:'-> f:('-> '-> 'b) -> 'b t
                    val of_alist_reduce :
                      (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
                    val of_sorted_array :
                      (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t
                    val of_sorted_array_unchecked :
                      (Key.t * 'a) array -> 'a t
                    val of_tree : 'a t -> 'a t
                    val invariants : 'a t -> bool
                    val is_empty : 'a t -> bool
                    val length : 'a t -> int
                    val add : 'a t -> key:Key.t -> data:'-> 'a t
                    val add_multi :
                      'a list t -> key:Key.t -> data:'-> 'a list t
                    val change :
                      'a t -> Key.t -> ('a option -> 'a option) -> 'a t
                    val find : 'a t -> Key.t -> 'a option
                    val find_exn : 'a t -> Key.t -> 'a
                    val remove : 'a t -> Key.t -> 'a t
                    val mem : 'a t -> Key.t -> bool
                    val iter :
                      'a t -> f:(key:Key.t -> data:'-> unit) -> unit
                    val iter2 :
                      'a t ->
                      'b t ->
                      f:(key:Key.t ->
                         data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                         unit) ->
                      unit
                    val map : 'a t -> f:('-> 'b) -> 'b t
                    val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
                    val fold :
                      'a t ->
                      init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                    val fold_right :
                      'a t ->
                      init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                    val filter :
                      'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
                    val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                    val filter_mapi :
                      'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
                    val compare_direct :
                      ('-> '-> int) -> 'a t -> 'a t -> int
                    val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                    val keys : 'a t -> Key.t list
                    val data : 'a t -> 'a list
                    val to_alist : 'a t -> (Key.t * 'a) list
                    val validate :
                      name:(Key.t -> string) ->
                      'Core_kernel.Validate.check ->
                      'a t Core_kernel.Validate.check
                    val merge :
                      'a t ->
                      'b t ->
                      f:(key:Key.t ->
                         [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                         'c option) ->
                      'c t
                    val symmetric_diff :
                      'a t ->
                      'a t ->
                      data_equal:('-> '-> bool) ->
                      (Key.t *
                       [ `Left of '| `Right of '| `Unequal of 'a * 'a ])
                      Core_kernel.Sequence.t
                    val min_elt : 'a t -> (Key.t * 'a) option
                    val min_elt_exn : 'a t -> Key.t * 'a
                    val max_elt : 'a t -> (Key.t * 'a) option
                    val max_elt_exn : 'a t -> Key.t * 'a
                    val for_all : 'a t -> f:('-> bool) -> bool
                    val exists : 'a t -> f:('-> bool) -> bool
                    val split :
                      'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
                    val fold_range_inclusive :
                      'a t ->
                      min:Key.t ->
                      max:Key.t ->
                      init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                    val range_to_alist :
                      'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
                    val closest_key :
                      'a t ->
                      [ `Greater_or_equal_to
                      | `Greater_than
                      | `Less_or_equal_to
                      | `Less_than ] -> Key.t -> (Key.t * 'a) option
                    val nth : 'a t -> int -> (Key.t * 'a) option
                    val rank : 'a t -> Key.t -> int option
                    val to_tree : 'a t -> 'a t
                    val to_sequence :
                      ?order:[ `Decreasing_key | `Increasing_key ] ->
                      ?keys_greater_or_equal_to:Key.t ->
                      ?keys_less_or_equal_to:Key.t ->
                      'a t -> (Key.t * 'a) Core_kernel.Sequence.t
                    val t_of_sexp :
                      (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
                    val sexp_of_t :
                      ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
                  end
                type 'a t =
                    (Key.t, 'a, Key.comparator_witness)
                    Core_kernel.Core_map.t
                val empty : 'a t
                val singleton : Key.t -> '-> 'a t
                val of_alist :
                  (Key.t * 'a) list ->
                  [ `Duplicate_key of Key.t | `Ok of 'a t ]
                val of_alist_or_error :
                  (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t
                val of_alist_exn : (Key.t * 'a) list -> 'a t
                val of_alist_multi : (Key.t * 'a) list -> 'a list t
                val of_alist_fold :
                  (Key.t * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
                val of_alist_reduce :
                  (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
                val of_sorted_array :
                  (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t
                val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
                val of_tree : 'Tree.t -> 'a t
                val invariants : 'a t -> bool
                val is_empty : 'a t -> bool
                val length : 'a t -> int
                val add : 'a t -> key:Key.t -> data:'-> 'a t
                val add_multi :
                  'a list t -> key:Key.t -> data:'-> 'a list t
                val change :
                  'a t -> Key.t -> ('a option -> 'a option) -> 'a t
                val find : 'a t -> Key.t -> 'a option
                val find_exn : 'a t -> Key.t -> 'a
                val remove : 'a t -> Key.t -> 'a t
                val mem : 'a t -> Key.t -> bool
                val iter : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
                val iter2 :
                  'a t ->
                  'b t ->
                  f:(key:Key.t ->
                     data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                     unit) ->
                  unit
                val map : 'a t -> f:('-> 'b) -> 'b t
                val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
                val fold :
                  'a t ->
                  init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                val fold_right :
                  'a t ->
                  init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                val filter : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
                val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                val filter_mapi :
                  'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
                val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
                val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                val keys : 'a t -> Key.t list
                val data : 'a t -> 'a list
                val to_alist : 'a t -> (Key.t * 'a) list
                val validate :
                  name:(Key.t -> string) ->
                  'Core_kernel.Validate.check ->
                  'a t Core_kernel.Validate.check
                val merge :
                  'a t ->
                  'b t ->
                  f:(key:Key.t ->
                     [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                     'c option) ->
                  'c t
                val symmetric_diff :
                  'a t ->
                  'a t ->
                  data_equal:('-> '-> bool) ->
                  (Key.t *
                   [ `Left of '| `Right of '| `Unequal of 'a * 'a ])
                  Core_kernel.Sequence.t
                val min_elt : 'a t -> (Key.t * 'a) option
                val min_elt_exn : 'a t -> Key.t * 'a
                val max_elt : 'a t -> (Key.t * 'a) option
                val max_elt_exn : 'a t -> Key.t * 'a
                val for_all : 'a t -> f:('-> bool) -> bool
                val exists : 'a t -> f:('-> bool) -> bool
                val split :
                  'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
                val fold_range_inclusive :
                  'a t ->
                  min:Key.t ->
                  max:Key.t ->
                  init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                val range_to_alist :
                  'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
                val closest_key :
                  'a t ->
                  [ `Greater_or_equal_to
                  | `Greater_than
                  | `Less_or_equal_to
                  | `Less_than ] -> Key.t -> (Key.t * 'a) option
                val nth : 'a t -> int -> (Key.t * 'a) option
                val rank : 'a t -> Key.t -> int option
                val to_tree : 'a t -> 'Tree.t
                val to_sequence :
                  ?order:[ `Decreasing_key | `Increasing_key ] ->
                  ?keys_greater_or_equal_to:Key.t ->
                  ?keys_less_or_equal_to:Key.t ->
                  'a t -> (Key.t * 'a) Core_kernel.Sequence.t
                val t_of_sexp :
                  (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
                val sexp_of_t :
                  ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
                val compare : ('-> '-> int) -> 'a t -> 'a t -> int
              end
            module Set :
              sig
                module Elt :
                  sig
                    type t = t
                    type comparator_witness = comparator_witness
                    val comparator :
                      (t, comparator_witness)
                      Core_kernel.Comparator.comparator
                    val t_of_sexp : Sexplib.Sexp.t -> t
                    val sexp_of_t : t -> Sexplib.Sexp.t
                  end
                module Tree :
                  sig
                    type t =
                        (Elt.t, Elt.comparator_witness)
                        Core_kernel.Core_set.Tree.t
                    val length : t -> int
                    val is_empty : t -> bool
                    val iter : t -> f:(Elt.t -> unit) -> unit
                    val fold :
                      t ->
                      init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
                    val exists : t -> f:(Elt.t -> bool) -> bool
                    val for_all : t -> f:(Elt.t -> bool) -> bool
                    val count : t -> f:(Elt.t -> bool) -> int
                    val sum :
                      (module Core_kernel.Commutative_group.S with type t = 'sum) ->
                      t -> f:(Elt.t -> 'sum) -> 'sum
                    val find : t -> f:(Elt.t -> bool) -> Elt.t option
                    val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
                    val to_list : t -> Elt.t list
                    val to_array : t -> Elt.t array
                    val invariants : t -> bool
                    val mem : t -> Elt.t -> bool
                    val add : t -> Elt.t -> t
                    val remove : t -> Elt.t -> t
                    val union : t -> t -> t
                    val inter : t -> t -> t
                    val diff : t -> t -> t
                    val symmetric_diff :
                      t ->
                      t ->
                      (Elt.t, Elt.t) Core_kernel.Either.t
                      Core_kernel.Sequence.t
                    val compare_direct : t -> t -> int
                    val equal : t -> t -> bool
                    val subset : t -> t -> bool
                    val fold_until :
                      t ->
                      init:'->
                      f:('-> Elt.t -> [ `Continue of '| `Stop of 'b ]) ->
                      'b
                    val fold_right :
                      t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
                    val iter2 :
                      t ->
                      t ->
                      f:([ `Both of Elt.t * Elt.t
                         | `Left of Elt.t
                         | `Right of Elt.t ] -> unit) ->
                      unit
                    val filter : t -> f:(Elt.t -> bool) -> t
                    val partition_tf : t -> f:(Elt.t -> bool) -> t * t
                    val elements : t -> Elt.t list
                    val min_elt : t -> Elt.t option
                    val min_elt_exn : t -> Elt.t
                    val max_elt : t -> Elt.t option
                    val max_elt_exn : t -> Elt.t
                    val choose : t -> Elt.t option
                    val choose_exn : t -> Elt.t
                    val split : t -> Elt.t -> t * Elt.t option * t
                    val group_by :
                      t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
                    val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
                    val find_index : t -> int -> Elt.t option
                    val remove_index : t -> int -> t
                    val to_tree : t -> t
                    val to_sequence :
                      ?order:[ `Decreasing | `Increasing ] ->
                      ?greater_or_equal_to:Elt.t ->
                      ?less_or_equal_to:Elt.t ->
                      t -> Elt.t Core_kernel.Sequence.t
                    val to_map :
                      t ->
                      f:(Elt.t -> 'data) ->
                      (Elt.t, 'data, Elt.comparator_witness)
                      Core_kernel.Core_set_intf.Map.t
                    val empty : t
                    val singleton : Elt.t -> t
                    val union_list : t list -> t
                    val of_list : Elt.t list -> t
                    val of_array : Elt.t array -> t
                    val of_sorted_array :
                      Elt.t array -> t Core_kernel.Or_error.t
                    val of_sorted_array_unchecked : Elt.t array -> t
                    val stable_dedup_list : Elt.t list -> Elt.t list
                    val map :
                      ('a, 'b) Core_kernel.Core_set.Tree.t ->
                      f:('-> Elt.t) -> t
                    val filter_map :
                      ('a, 'b) Core_kernel.Core_set.Tree.t ->
                      f:('-> Elt.t option) -> t
                    val of_tree : t -> t
                    val of_map_keys :
                      (Elt.t, 'a, Elt.comparator_witness)
                      Core_kernel.Core_set_intf.Map.t -> t
                    val t_of_sexp : Sexplib.Sexp.t -> t
                    val sexp_of_t : t -> Sexplib.Sexp.t
                    val compare : t -> t -> int
                  end
                type t =
                    (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t
                val length : t -> int
                val is_empty : t -> bool
                val iter : t -> f:(Elt.t -> unit) -> unit
                val fold :
                  t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
                val exists : t -> f:(Elt.t -> bool) -> bool
                val for_all : t -> f:(Elt.t -> bool) -> bool
                val count : t -> f:(Elt.t -> bool) -> int
                val sum :
                  (module Core_kernel.Commutative_group.S with type t = 'sum) ->
                  t -> f:(Elt.t -> 'sum) -> 'sum
                val find : t -> f:(Elt.t -> bool) -> Elt.t option
                val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
                val to_list : t -> Elt.t list
                val to_array : t -> Elt.t array
                val invariants : t -> bool
                val mem : t -> Elt.t -> bool
                val add : t -> Elt.t -> t
                val remove : t -> Elt.t -> t
                val union : t -> t -> t
                val inter : t -> t -> t
                val diff : t -> t -> t
                val symmetric_diff :
                  t ->
                  t ->
                  (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t
                val compare_direct : t -> t -> int
                val equal : t -> t -> bool
                val subset : t -> t -> bool
                val fold_until :
                  t ->
                  init:'->
                  f:('-> Elt.t -> [ `Continue of '| `Stop of 'b ]) -> 'b
                val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
                val iter2 :
                  t ->
                  t ->
                  f:([ `Both of Elt.t * Elt.t
                     | `Left of Elt.t
                     | `Right of Elt.t ] -> unit) ->
                  unit
                val filter : t -> f:(Elt.t -> bool) -> t
                val partition_tf : t -> f:(Elt.t -> bool) -> t * t
                val elements : t -> Elt.t list
                val min_elt : t -> Elt.t option
                val min_elt_exn : t -> Elt.t
                val max_elt : t -> Elt.t option
                val max_elt_exn : t -> Elt.t
                val choose : t -> Elt.t option
                val choose_exn : t -> Elt.t
                val split : t -> Elt.t -> t * Elt.t option * t
                val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
                val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
                val find_index : t -> int -> Elt.t option
                val remove_index : t -> int -> t
                val to_tree : t -> Tree.t
                val to_sequence :
                  ?order:[ `Decreasing | `Increasing ] ->
                  ?greater_or_equal_to:Elt.t ->
                  ?less_or_equal_to:Elt.t ->
                  t -> Elt.t Core_kernel.Sequence.t
                val to_map :
                  t ->
                  f:(Elt.t -> 'data) ->
                  (Elt.t, 'data, Elt.comparator_witness)
                  Core_kernel.Core_set_intf.Map.t
                val empty : t
                val singleton : Elt.t -> t
                val union_list : t list -> t
                val of_list : Elt.t list -> t
                val of_array : Elt.t array -> t
                val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t
                val of_sorted_array_unchecked : Elt.t array -> t
                val stable_dedup_list : Elt.t list -> Elt.t list
                val map :
                  ('a, 'b) Core_kernel.Core_set.t -> f:('-> Elt.t) -> t
                val filter_map :
                  ('a, 'b) Core_kernel.Core_set.t ->
                  f:('-> Elt.t option) -> t
                val of_tree : Tree.t -> t
                val of_map_keys :
                  (Elt.t, 'a, Elt.comparator_witness)
                  Core_kernel.Core_set_intf.Map.t -> t
                val t_of_sexp : Sexplib.Sexp.t -> t
                val sexp_of_t : t -> Sexplib.Sexp.t
                val compare : t -> t -> int
              end
            val compare : t -> t -> int
            val t_of_sexp : Sexplib.Sexp.t -> t
            val sexp_of_t : t -> Sexplib.Sexp.t
          end
        module Key :
          sig
            type t = Left_boundary.t
            type comparator_witness
            val comparator :
              (t, comparator_witness) Core_kernel.Std.Comparator.comparator
          end
        module Interval :
          sig
            type t = Key.t Interval_map_intf.Interval.t
            val is_empty : t -> bool
            val contains : t -> Key.t -> bool
          end
        type 'a t = (Key.t, 'a, Key.comparator_witness) t
        val create :
          left_of_leftmost:'->
          value_right_of:(Key.t, 'a, Key.comparator_witness)
                         Core_kernel.Std.Map.t ->
          'a t
        val always : '-> 'a t
        val find : 'v t -> Key.t -> 'v
        val change : 'v t -> at:Key.t -> '-> 'v t
        val map : 'a t -> f:('-> 'b) -> 'b t
        val map2 : 'a t -> 'b t -> f:('-> '-> 'c) -> 'c t
        val remove_changes_within : 'v t -> Interval.t -> 'v t
        val set_within : 'v t -> Interval.t -> '-> 'v t
        val map_within : 'v t -> Interval.t -> f:('-> 'v) -> 'v t
        val construct_preimage :
          'v t -> ('v * Interval.t) Core_kernel.Std.Sequence.t
        val compare : ('-> '-> int) -> 'a t -> 'a t -> int
        val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
        val sexp_of_t : ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
        val find' : 'a t -> Key.t -> 'a
      end
end