Base.Map.Creators_and_accessors_generic · base v0.15.0

base

Full standard library replacement for OCaml

Version

IN THIS PACKAGE

library base
- module Base
  - module Applicative
    
    module type Applicative_infix
    
    module type Applicative_infix2
    
    module type Applicative_infix3
    
    module type Basic
    
    module type Basic2
    
    module type Basic2_using_map2
    
    module type Basic3
    
    module type Basic3_using_map2
    
    module type Basic_using_map2
    
    module Compose
    
    argument 1-F
    
    module Applicative_infix
    
    argument 2-G
    
    module Applicative_infix
    
    module Applicative_infix
    
    module type Let_syntax
    
    module Let_syntax
    
    module Let_syntax
    
    module Open_on_rhs_intf
    
    module type Let_syntax2
    
    module Let_syntax
    
    module Let_syntax
    
    module Open_on_rhs_intf
    
    module type Let_syntax3
    
    module Let_syntax
    
    module Let_syntax
    
    module Open_on_rhs_intf
    
    module Make
    
    argument 1-X
    
    module Applicative_infix
    
    module Make2
    
    argument 1-X
    
    module Applicative_infix
    
    module Make2_using_map2
    
    argument 1-X
    
    module Applicative_infix
    
    module Make3
    
    argument 1-X
    
    module Applicative_infix
    
    module Make3_using_map2
    
    argument 1-X
    
    module Applicative_infix
    
    module Make_let_syntax
    
    argument 1-X
    
    argument 2-Intf
    
    module Let_syntax
    
    module Let_syntax
    
    module Make_let_syntax2
    
    argument 1-X
    
    argument 2-Intf
    
    module Let_syntax
    
    module Let_syntax
    
    module Make_let_syntax3
    
    argument 1-X
    
    argument 2-Intf
    
    module Let_syntax
    
    module Let_syntax
    
    module Make_using_map2
    
    argument 1-X
    
    module Applicative_infix
    
    module Of_monad
    
    argument 1-M
    
    module Let_syntax
    
    module Let_syntax
    
    module Open_on_rhs
    
    module Monad_infix
    
    module Applicative_infix
    
    module Of_monad2
    
    argument 1-M
    
    module Let_syntax
    
    module Let_syntax
    
    module Open_on_rhs
    
    module Monad_infix
    
    module Applicative_infix
    
    module Pair
    
    argument 1-F
    
    module Applicative_infix
    
    argument 2-G
    
    module Applicative_infix
    
    module Applicative_infix
    
    module type S
    
    module Applicative_infix
    
    module type S2
    
    module Applicative_infix
    
    module S2_to_S
    
    argument 1-X
    
    module Applicative_infix
    
    module Applicative_infix
    
    module S2_to_S3
    
    argument 1-X
    
    module Applicative_infix
    
    module Applicative_infix
    
    module type S3
    
    module Applicative_infix
    
    module S3_to_S2
    
    argument 1-X
    
    module Applicative_infix
    
    module Applicative_infix
    
    module S_to_S2
    
    argument 1-X
    
    module Applicative_infix
    
    module Applicative_infix
  - module Array
  - module Avltree
  - module Backtrace
    
    module Exn
  - module Binary_search
  - module Binary_searchable
    
    module type Indexable
    
    module type Indexable1
    
    module Make
    
    argument 1-T
    
    module Make1
    
    argument 1-T
    
    module type S
    
    module type S1
    
    module Which_target_by_key
    
    module Which_target_by_segment
  - module Blit
    
    module Make
    
    argument 1-Sequence
    
    module Make1
    
    argument 1-Sequence
    
    module Make1_generic
    
    argument 1-Sequence
    
    module Make_distinct
    
    argument 1-Src
    
    argument 2-Dst
    
    module Make_to_string
    
    argument 1-T
    
    argument 2-To_bytes
    
    module type S
    
    module type S1
    
    module type S1_distinct
    
    module type S_distinct
    
    module type S_to_string
    
    module type Sequence
    
    module type Sequence1
  - module Bool
    
    module Non_short_circuiting
  - module Buffer
    
    module type S
    
    module To_string
    
    module To_string
  - module Bytes
    
    module From_string
    
    module To_string
  - module Char
    
    module Caseless
    
    module O
  - module Comparable
    
    module Infix
    
    argument 1-T
    
    module Inherit
    
    argument 1-C
    
    argument 2-T
    
    module Make
    
    argument 1-T
    
    module Make_using_comparator
    
    argument 1-T
    
    module Poly
    
    argument 1-T
    
    module Polymorphic_compare
    
    argument 1-T
    
    module type S
    
    module type With_compare
    
    module With_zero
    
    argument 1-T
  - module Comparator
    
    module Derived
    
    argument 1-M
    
    module Derived2
    
    argument 1-M
    
    module Derived_phantom
    
    argument 1-M
    
    module Make
    
    argument 1-M
    
    module Make1
    
    argument 1-M
    
    module Module
    
    module Poly
    
    module type S
    
    module type S1
    
    module type S_fc
    
    module S_to_S1
    
    argument 1-S
  - module Comparisons
    
    module type Infix
    
    module type S
  - module Container
    
    module Continue_or_stop
    
    module type Generic
    
    module type Generic_phantom
    
    module Make
    
    argument 1-T
    
    module Make0
    
    argument 1-T
    
    module Elt
    
    module Make_gen
    
    argument 1-T
    
    module type S0
    
    module type S0_phantom
    
    module type S1
    
    module type S1_phantom
    
    module type S1_phantom_invariant
    
    module type Summable
  - module Continue_or_stop
  - module Either
    
    module First
    
    module Applicative_infix
    
    module Let_syntax
    
    module Let_syntax
    
    module Open_on_rhs
    
    module Monad_infix
    
    module type Focused
    
    module Applicative_infix
    
    module Let_syntax
    
    module Let_syntax
    
    module Open_on_rhs
    
    module Monad_infix
    
    module Second
    
    module Applicative_infix
    
    module Let_syntax
    
    module Let_syntax
    
    module Open_on_rhs
    
    module Monad_infix
  - module Equal
    
    module type S
    
    module type S1
    
    module type S2
    
    module type S3
  - module Error
    
    module Internal_repr
  - module Exn
  - module Export
  - module Field
  - module Float
    
    module Class
    
    module O
    
    module O_dot
    
    module Parts
    
    module Terse
  - module Floatable
    
    module type S
  - module Fn
  - module Formatter
  - module Hash
    
    module Builtin
    
    module F
    
    argument 1-Hash
    
    module For_tests
    
    module Builtin
    
    module For_tests
    
    module For_tests
    
    module type Full
    
    module Builtin
    
    module For_tests
    
    module type S
    
    module For_tests
  - module Hash_set
    
    module type Accessors
    
    module Creators
    
    argument 1-Elt
    
    module type Creators_generic
    
    module type Equal_m
    
    module type For_deriving
    
    module type Equal_m
    
    module M
    
    argument 1-Elt
    
    module type M_of_sexp
    
    module type Sexp_of_m
    
    module M
    
    argument 1-Elt
    
    module type M_of_sexp
    
    module Poly
    
    module type Sexp_of_m
  - module Hashable
    
    module type Hashable
    
    module type Key
  - module Hasher
    
    module type S
    
    module type S1
  - module Hashtbl
    
    module type Accessors
    
    module Creators
    
    argument 1-Key
    
    module type Equal_m
    
    module type For_deriving
    
    module type Equal_m
    
    module type M_of_sexp
    
    module type M_sexp_grammar
    
    module type Sexp_of_m
    
    module Key
    
    module type S
    
    module M
    
    argument 1-K
    
    module type M_of_sexp
    
    module type M_sexp_grammar
    
    module Merge_into_action
    
    module type Multi
    
    module Poly
    
    module type S_poly
    
    module type S_without_submodules
    
    module type Sexp_of_m
  - module Identifiable
    
    module type Arg
    
    module type Arg_with_comparator
    
    module Make
    
    argument 1-M
    
    module Make_using_comparator
    
    argument 1-M
    
    module type S
  - module Indexed_container
    
    module type Generic
    
    module Make
    
    argument 1-T
    
    module Make0
    
    argument 1-T
    
    module Elt
    
    module Make_gen
    
    argument 1-T
    
    module type S0
    
    module type S1
  - module Info
    
    module Internal_repr
    
    module type S
    
    module Internal_repr
  - module Int
    
    module Hex
    
    module type Hexable
    
    module Hex
    
    module type Int_without_module_types
    
    module Hex
    
    module O
    
    module O
    
    module type Operators
    
    module type Operators_unbounded
    
    module type Round
    
    module type S
    
    module Hex
    
    module O
    
    module type S_common
    
    module Hex
    
    module type S_unbounded
    
    module Hex
    
    module O
  - module Int32
    
    module Hex
    
    module O
  - module Int63
    
    module Hex
    
    module O
    
    module Overflow_exn
  - module Int64
    
    module Hex
    
    module O
  - module Int_conversions
    
    module Make
    
    argument 1-I
    
    module Make_hex
    
    argument 1-I
    
    module Hex
  - module Int_math
    
    module Make
    
    argument 1-X
    
    module type Make_arg
    
    module Private
    
    module Pow_overflow_bounds
  - module Intable
    
    module type S
  - module Invariant
    
    module type S
    
    module type S1
    
    module type S2
    
    module type S3
  - module Lazy
    
    module Let_syntax
    
    module Let_syntax
    
    module Open_on_rhs
    
    module Monad_infix
    
    module T_unforcing
  - module Linked_queue
  - module List
    
    module Assoc
    
    module Cartesian_product
    
    module Applicative_infix
    
    module Let_syntax
    
    module Let_syntax
    
    module Open_on_rhs
    
    module Monad_infix
    
    module Infix
    
    module Let_syntax
    
    module Let_syntax
    
    module Open_on_rhs
    
    module Monad_infix
    
    module Or_unequal_lengths
  - module Map
    
    module type Accessors1
    
    module type Accessors2
    
    module type Accessors3
    
    module type Accessors3_with_comparator
    
    module type Accessors_generic
    
    module type Compare_m
    
    module Continue_or_stop
    
    module type Creators1
    
    module type Creators2
    
    module type Creators3_with_comparator
    
    module type Creators_and_accessors1
    
    module type Creators_and_accessors2
    
    module type Creators_and_accessors3_with_comparator
    
    module type Creators_and_accessors_generic
    
    module type Creators_generic
    
    module type Equal_m
    
    module Finished_or_unfinished
    
    module type For_deriving
    
    module type Compare_m
    
    module type Equal_m
    
    module type M_of_sexp
    
    module type M_sexp_grammar
    
    module type Sexp_of_m
    
    module M
    
    argument 1-K
    
    module type M_of_sexp
    
    module type M_sexp_grammar
    
    module Merge_element
    
    module Or_duplicate
    
    module Poly
    
    module type S_poly
    
    module type Sexp_of_m
    
    module Symmetric_diff_element
    
    module Using_comparator
    
    module Empty_without_value_restriction
    
    argument 1-K
    
    module Tree
    
    module Build_increasing
    
    module With_comparator
    
    module With_first_class_module
    
    module Without_comparator
  - module Maybe_bound
  - module Monad
    
    module type Basic
    
    module type Basic2
    
    module type Basic3
    
    module type Basic_indexed
    
    module Ident
    
    module Let_syntax
    
    module Let_syntax
    
    module Open_on_rhs
    
    module Monad_infix
    
    module type Infix
    
    module type Infix2
    
    module type Infix3
    
    module type Infix_indexed
    
    module Make
    
    argument 1-X
    
    module Let_syntax
    
    module Let_syntax
    
    module Open_on_rhs
    
    module Monad_infix
    
    module Make2
    
    argument 1-X
    
    module Let_syntax
    
    module Let_syntax
    
    module Open_on_rhs
    
    module Monad_infix
    
    module Make3
    
    argument 1-X
    
    module Let_syntax
    
    module Let_syntax
    
    module Open_on_rhs
    
    module Monad_infix
    
    module Make_indexed
    
    argument 1-X
    
    module Let_syntax
    
    module Let_syntax
    
    module Open_on_rhs
    
    module Monad_infix
    
    module Of_monad
    
    argument 1-Monad
    
    module Let_syntax
    
    module Let_syntax
    
    module Open_on_rhs
    
    module Monad_infix
    
    argument 2-M
    
    module Let_syntax
    
    module Let_syntax
    
    module Open_on_rhs
    
    module Monad_infix
    
    module Of_monad2
    
    argument 1-Monad
    
    module Let_syntax
    
    module Let_syntax
    
    module Open_on_rhs
    
    module Monad_infix
    
    argument 2-M
    
    module Let_syntax
    
    module Let_syntax
    
    module Open_on_rhs
    
    module Monad_infix
    
    module Of_monad3
    
    argument 1-Monad
    
    module Let_syntax
    
    module Let_syntax
    
    module Open_on_rhs
    
    module Monad_infix
    
    argument 2-M
    
    module Let_syntax
    
    module Let_syntax
    
    module Open_on_rhs
    
    module Monad_infix
    
    module Of_monad_indexed
    
    argument 1-Monad
    
    module Let_syntax
    
    module Let_syntax
    
    module Open_on_rhs
    
    module Monad_infix
    
    argument 2-M
    
    module Let_syntax
    
    module Let_syntax
    
    module Open_on_rhs
    
    module Monad_infix
    
    module type S
    
    module Let_syntax
    
    module Let_syntax
    
    module Open_on_rhs
    
    module Monad_infix
    
    module type S2
    
    module Let_syntax
    
    module Let_syntax
    
    module Open_on_rhs
    
    module Monad_infix
    
    module type S3
    
    module Let_syntax
    
    module Let_syntax
    
    module Open_on_rhs
    
    module Monad_infix
    
    module type S_indexed
    
    module Let_syntax
    
    module Let_syntax
    
    module Open_on_rhs
    
    module Monad_infix
    
    module type S_without_syntax
    
    module Monad_infix
    
    module type Syntax
    
    module Let_syntax
    
    module Let_syntax
    
    module Open_on_rhs
    
    module type Syntax2
    
    module Let_syntax
    
    module Let_syntax
    
    module Open_on_rhs
    
    module type Syntax3
    
    module Let_syntax
    
    module Let_syntax
    
    module Open_on_rhs
    
    module type Syntax_indexed
    
    module Let_syntax
    
    module Let_syntax
    
    module Open_on_rhs
  - module Nativeint
    
    module Hex
    
    module O
  - module Nothing
  - module Option
    
    module Applicative_infix
    
    module Let_syntax
    
    module Let_syntax
    
    module Open_on_rhs
    
    module Monad_infix
  - module Option_array
  - module Or_error
    
    module Applicative_infix
    
    module Let_syntax
    
    module Let_syntax
    
    module Open_on_rhs
    
    module Monad_infix
  - module Ordered_collection_common
    
    module Private
  - module Ordering
    
    module Export
  - module Poly
  - module Popcount
  - module Pretty_printer
    
    module Register
    
    argument 1-M
    
    module Register_pp
    
    argument 1-M
    
    module type S
  - module Printf
  - module Queue
    
    module type S
  - module Random
    
    module State
  - module Ref
    
    module And_value
  - module Result
    
    module Error
    
    module Let_syntax
    
    module Let_syntax
    
    module Open_on_rhs
    
    module Monad_infix
    
    module Export
    
    module Let_syntax
    
    module Let_syntax
    
    module Open_on_rhs
    
    module Monad_infix
  - module Sequence
    
    module Expert
    
    module Generator
    
    module Let_syntax
    
    module Let_syntax
    
    module Open_on_rhs
    
    module Monad_infix
    
    module Infix
    
    module Let_syntax
    
    module Let_syntax
    
    module Open_on_rhs
    
    module Merge_with_duplicates_element
    
    module Monad_infix
    
    module Step
  - module Set
    
    module type Accessors0
    
    module Named
    
    module type Accessors1
    
    module Named
    
    module type Accessors2
    
    module Named
    
    module type Accessors2_with_comparator
    
    module Named
    
    module type Accessors_generic
    
    module Named
    
    module type Compare_m
    
    module type Creators0
    
    module type Creators1
    
    module type Creators2
    
    module type Creators2_with_comparator
    
    module type Creators_and_accessors0
    
    module Named
    
    module type Creators_and_accessors1
    
    module Named
    
    module type Creators_and_accessors2
    
    module Named
    
    module type Creators_and_accessors2_with_comparator
    
    module Named
    
    module type Creators_generic
    
    module type Elt_plain
    
    module type Equal_m
    
    module type For_deriving
    
    module type Compare_m
    
    module type Equal_m
    
    module type M_of_sexp
    
    module type M_sexp_grammar
    
    module type Sexp_of_m
    
    module M
    
    argument 1-Elt
    
    module type M_of_sexp
    
    module type M_sexp_grammar
    
    module Merge_to_sequence_element
    
    module Named
    
    module Poly
    
    module Named
    
    module type S_poly
    
    module Named
    
    module type Sexp_of_m
    
    module Using_comparator
    
    module Empty_without_value_restriction
    
    argument 1-Elt
    
    module Named
    
    module Tree
    
    module Named
    
    module With_comparator
    
    module With_first_class_module
    
    module Without_comparator
  - module Sexp
    
    module Private
  - module Sexpable
    
    module Of_sexpable
    
    argument 1-Sexpable
    
    argument 2-M
    
    module Of_sexpable1
    
    argument 1-Sexpable
    
    argument 2-M
    
    module Of_sexpable2
    
    argument 1-Sexpable
    
    argument 2-M
    
    module Of_sexpable3
    
    argument 1-Sexpable
    
    argument 2-M
    
    module Of_stringable
    
    argument 1-M
    
    module type S
    
    module type S1
    
    module type S2
    
    module type S3
  - module Sign
  - module Sign_or_nan
  - module Source_code_position
  - module Stack
    
    module type S
  - module Staged
  - module String
    
    module Caseless
    
    module Escaping
    
    module Search_pattern
  - module Stringable
    
    module type S
  - module Sys
  - module type T
    
    module type T
    
    module type T1
    
    module type T2
    
    module type T3
  - module type T1
  - module type T2
  - module type T3
  - module Type_equal
    
    module Composition_preserves_injectivity
    
    argument 1-M1
    
    argument 2-M2
    
    module Id
    
    module Uid
    
    module type Injective
    
    module type Injective2
    
    module Lift
    
    argument 1-X
    
    module Lift2
    
    argument 1-X
    
    module Lift3
    
    argument 1-X
  - module Uchar
  - module Uniform_array
  - module Unit
  - module Variant
  - module With_return
  - module Word_size
library base.base_internalhash_types
- module Base_internalhash_types
library base.caml
- module Caml
  - module In_channel
  - module Out_channel
library base.md5
- module Md5_lib
library base.shadow_stdlib
- module Shadow_stdlib
  - module In_channel
  - module Out_channel

type ('k, 'v, 'cmp) t

type ('k, 'v, 'cmp) tree

type 'k key

type ('a, 'cmp, 'z) options

type 'cmp cmp

val empty : ( 'k, 'cmp, ( 'k, _, 'cmp ) t ) options

val singleton : ( 'k, 'cmp, 'k key -> 'v -> ( 'k, 'v, 'cmp ) t ) options

val map_keys : 
  ( 'k2,
    'cmp2,
    ( 'k1, 'v, 'cmp1 ) t ->
    f:( 'k1 key -> 'k2 key ) ->
    [ `Ok of ( 'k2, 'v, 'cmp2 ) t | `Duplicate_key of 'k2 key ] )
    options

val map_keys_exn : 
  ( 'k2,
    'cmp2,
    ( 'k1, 'v, 'cmp1 ) t ->
    f:( 'k1 key -> 'k2 key ) ->
    ( 'k2, 'v, 'cmp2 ) t )
    options

val of_sorted_array : 
  ( 'k, 'cmp, ('k key * 'v) array -> ( 'k, 'v, 'cmp ) t Or_error.t ) options

val of_sorted_array_unchecked : 
  ( 'k, 'cmp, ('k key * 'v) array -> ( 'k, 'v, 'cmp ) t ) options

val of_increasing_iterator_unchecked : 
  ( 'k, 'cmp, len:int -> f:( int -> 'k key * 'v ) -> ( 'k, 'v, 'cmp ) t )
    options

val of_alist : 
  ( 'k,
    'cmp,
    ('k key * 'v) list ->
    [ `Ok of ( 'k, 'v, 'cmp ) t | `Duplicate_key of 'k key ] )
    options

val of_alist_or_error : 
  ( 'k, 'cmp, ('k key * 'v) list -> ( 'k, 'v, 'cmp ) t Or_error.t ) options

val of_alist_exn : 
  ( 'k, 'cmp, ('k key * 'v) list -> ( 'k, 'v, 'cmp ) t ) options

val of_alist_multi : 
  ( 'k, 'cmp, ('k key * 'v) list -> ( 'k, 'v list, 'cmp ) t ) options

val of_alist_fold : 
  ( 'k,
    'cmp,
    ('k key * 'v1) list ->
    init:'v2 ->
    f:( 'v2 -> 'v1 -> 'v2 ) ->
    ( 'k, 'v2, 'cmp ) t )
    options

val of_alist_reduce : 
  ( 'k,
    'cmp,
    ('k key * 'v) list ->
    f:( 'v -> 'v -> 'v ) ->
    ( 'k, 'v, 'cmp ) t )
    options

val of_increasing_sequence : 
  ( 'k, 'cmp, ('k key * 'v) Sequence.t -> ( 'k, 'v, 'cmp ) t Or_error.t )
    options

val of_sequence : 
  ( 'k,
    'cmp,
    ('k key * 'v) Sequence.t ->
    [ `Ok of ( 'k, 'v, 'cmp ) t | `Duplicate_key of 'k key ] )
    options

val of_sequence_or_error : 
  ( 'k, 'cmp, ('k key * 'v) Sequence.t -> ( 'k, 'v, 'cmp ) t Or_error.t )
    options

val of_sequence_exn : 
  ( 'k, 'cmp, ('k key * 'v) Sequence.t -> ( 'k, 'v, 'cmp ) t ) options

val of_sequence_multi : 
  ( 'k, 'cmp, ('k key * 'v) Sequence.t -> ( 'k, 'v list, 'cmp ) t ) options

val of_sequence_fold : 
  ( 'k,
    'cmp,
    ('k key * 'v1) Sequence.t ->
    init:'v2 ->
    f:( 'v2 -> 'v1 -> 'v2 ) ->
    ( 'k, 'v2, 'cmp ) t )
    options

val of_sequence_reduce : 
  ( 'k,
    'cmp,
    ('k key * 'v) Sequence.t ->
    f:( 'v -> 'v -> 'v ) ->
    ( 'k, 'v, 'cmp ) t )
    options

val of_iteri : 
  ( 'k,
    'cmp,
    iteri:( f:( key:'k key -> data:'v -> unit ) -> unit ) ->
    [ `Ok of ( 'k, 'v, 'cmp ) t | `Duplicate_key of 'k key ] )
    options

val of_iteri_exn : 
  ( 'k,
    'cmp,
    iteri:( f:( key:'k key -> data:'v -> unit ) -> unit ) ->
    ( 'k, 'v, 'cmp ) t )
    options

val of_tree : 
  ( 'k, 'cmp, ( 'k key, 'v, 'cmp ) tree -> ( 'k, 'v, 'cmp ) t ) options

val invariants : ( 'k, 'cmp, ( 'k, 'v, 'cmp ) t -> bool ) options

val is_empty : ( _, _, _ ) t -> bool

val length : ( _, _, _ ) t -> int

val add : 
  ( 'k,
    'cmp,
    ( 'k, 'v, 'cmp ) t ->
    key:'k key ->
    data:'v ->
    [ `Ok of ( 'k, 'v, 'cmp ) t | `Duplicate ] )
    options

val add_exn : 
  ( 'k,
    'cmp,
    ( 'k, 'v, 'cmp ) t ->
    key:'k key ->
    data:'v ->
    ( 'k, 'v, 'cmp ) t )
    options

val set : 
  ( 'k,
    'cmp,
    ( 'k, 'v, 'cmp ) t ->
    key:'k key ->
    data:'v ->
    ( 'k, 'v, 'cmp ) t )
    options

val add_multi : 
  ( 'k,
    'cmp,
    ( 'k, 'v list, 'cmp ) t ->
    key:'k key ->
    data:'v ->
    ( 'k, 'v list, 'cmp ) t )
    options

val remove_multi : 
  ( 'k, 'cmp, ( 'k, 'v list, 'cmp ) t -> 'k key -> ( 'k, 'v list, 'cmp ) t )
    options

val find_multi : 
  ( 'k, 'cmp, ( 'k, 'v list, 'cmp ) t -> 'k key -> 'v list ) options

val change : 
  ( 'k,
    'cmp,
    ( 'k, 'v, 'cmp ) t ->
    'k key ->
    f:( 'v option -> 'v option ) ->
    ( 'k, 'v, 'cmp ) t )
    options

val update : 
  ( 'k,
    'cmp,
    ( 'k, 'v, 'cmp ) t ->
    'k key ->
    f:( 'v option -> 'v ) ->
    ( 'k, 'v, 'cmp ) t )
    options

val find : ( 'k, 'cmp, ( 'k, 'v, 'cmp ) t -> 'k key -> 'v option ) options

val find_exn : ( 'k, 'cmp, ( 'k, 'v, 'cmp ) t -> 'k key -> 'v ) options

val remove : 
  ( 'k, 'cmp, ( 'k, 'v, 'cmp ) t -> 'k key -> ( 'k, 'v, 'cmp ) t ) options

val mem : ( 'k, 'cmp, ( 'k, _, 'cmp ) t -> 'k key -> bool ) options

val iter_keys : ( 'k, _, _ ) t -> f:( 'k key -> unit ) -> unit

val iter : ( _, 'v, _ ) t -> f:( 'v -> unit ) -> unit

val iteri : ( 'k, 'v, _ ) t -> f:( key:'k key -> data:'v -> unit ) -> unit

val iteri_until : 
  ( 'k, 'v, _ ) t ->
  f:( key:'k key -> data:'v -> Continue_or_stop.t ) ->
  Finished_or_unfinished.t

val iter2 : 
  ( 'k,
    'cmp,
    ( 'k, 'v1, 'cmp ) t ->
    ( 'k, 'v2, 'cmp ) t ->
    f:
      ( key:'k key ->
        data:[ `Left of 'v1 | `Right of 'v2 | `Both of 'v1 * 'v2 ] ->
        unit ) ->
    unit )
    options

val map : ( 'k, 'v1, 'cmp ) t -> f:( 'v1 -> 'v2 ) -> ( 'k, 'v2, 'cmp ) t

val mapi : 
  ( 'k, 'v1, 'cmp ) t ->
  f:( key:'k key -> data:'v1 -> 'v2 ) ->
  ( 'k, 'v2, 'cmp ) t

val fold : 
  ( 'k, 'v, _ ) t ->
  init:'a ->
  f:( key:'k key -> data:'v -> 'a -> 'a ) ->
  'a

val fold_until : 
  ( 'k, 'v, _ ) t ->
  init:'a ->
  f:
    ( key:'k key ->
      data:'v ->
      'a ->
      ( 'a, 'final ) Container.Continue_or_stop.t ) ->
  finish:( 'a -> 'final ) ->
  'final

val fold_right : 
  ( 'k, 'v, _ ) t ->
  init:'a ->
  f:( key:'k key -> data:'v -> 'a -> 'a ) ->
  'a

val fold2 : 
  ( 'k,
    'cmp,
    ( 'k, 'v1, 'cmp ) t ->
    ( 'k, 'v2, 'cmp ) t ->
    init:'a ->
    f:
      ( key:'k key ->
        data:[ `Left of 'v1 | `Right of 'v2 | `Both of 'v1 * 'v2 ] ->
        'a ->
        'a ) ->
    'a )
    options

val filter_keys : 
  ( 'k,
    'cmp,
    ( 'k, 'v, 'cmp ) t ->
    f:( 'k key -> bool ) ->
    ( 'k, 'v, 'cmp ) t )
    options

val filter : 
  ( 'k, 'cmp, ( 'k, 'v, 'cmp ) t -> f:( 'v -> bool ) -> ( 'k, 'v, 'cmp ) t )
    options

val filteri : 
  ( 'k,
    'cmp,
    ( 'k, 'v, 'cmp ) t ->
    f:( key:'k key -> data:'v -> bool ) ->
    ( 'k, 'v, 'cmp ) t )
    options

val filter_map : 
  ( 'k,
    'cmp,
    ( 'k, 'v1, 'cmp ) t ->
    f:( 'v1 -> 'v2 option ) ->
    ( 'k, 'v2, 'cmp ) t )
    options

val filter_mapi : 
  ( 'k,
    'cmp,
    ( 'k, 'v1, 'cmp ) t ->
    f:( key:'k key -> data:'v1 -> 'v2 option ) ->
    ( 'k, 'v2, 'cmp ) t )
    options

val partition_mapi : 
  ( 'k,
    'cmp,
    ( 'k, 'v1, 'cmp ) t ->
    f:( key:'k key -> data:'v1 -> ( 'v2, 'v3 ) Either.t ) ->
    ( 'k, 'v2, 'cmp ) t * ( 'k, 'v3, 'cmp ) t )
    options

val partition_map : 
  ( 'k,
    'cmp,
    ( 'k, 'v1, 'cmp ) t ->
    f:( 'v1 -> ( 'v2, 'v3 ) Either.t ) ->
    ( 'k, 'v2, 'cmp ) t * ( 'k, 'v3, 'cmp ) t )
    options

val partitioni_tf : 
  ( 'k,
    'cmp,
    ( 'k, 'v, 'cmp ) t ->
    f:( key:'k key -> data:'v -> bool ) ->
    ( 'k, 'v, 'cmp ) t * ( 'k, 'v, 'cmp ) t )
    options

val partition_tf : 
  ( 'k,
    'cmp,
    ( 'k, 'v, 'cmp ) t ->
    f:( 'v -> bool ) ->
    ( 'k, 'v, 'cmp ) t * ( 'k, 'v, 'cmp ) t )
    options

val combine_errors : 
  ( 'k, 'cmp, ( 'k, 'v Or_error.t, 'cmp ) t -> ( 'k, 'v, 'cmp ) t Or_error.t )
    options

val compare_direct : 
  ( 'k,
    'cmp,
    ( 'v -> 'v -> int ) ->
    ( 'k, 'v, 'cmp ) t ->
    ( 'k, 'v, 'cmp ) t ->
    int )
    options

val equal : 
  ( 'k,
    'cmp,
    ( 'v -> 'v -> bool ) ->
    ( 'k, 'v, 'cmp ) t ->
    ( 'k, 'v, 'cmp ) t ->
    bool )
    options

val keys : ( 'k, _, _ ) t -> 'k key list

val data : ( _, 'v, _ ) t -> 'v list

val to_alist : 
  ?key_order:[ `Increasing | `Decreasing ] ->
  ( 'k, 'v, _ ) t ->
  ('k key * 'v) list

val merge : 
  ( 'k,
    'cmp,
    ( 'k, 'v1, 'cmp ) t ->
    ( 'k, 'v2, 'cmp ) t ->
    f:
      ( key:'k key ->
        [ `Left of 'v1 | `Right of 'v2 | `Both of 'v1 * 'v2 ] ->
        'v3 option ) ->
    ( 'k, 'v3, 'cmp ) t )
    options

val merge_skewed : 
  ( 'k,
    'cmp,
    ( 'k, 'v, 'cmp ) t ->
    ( 'k, 'v, 'cmp ) t ->
    combine:( key:'k key -> 'v -> 'v -> 'v ) ->
    ( 'k, 'v, 'cmp ) t )
    options

val symmetric_diff : 
  ( 'k,
    'cmp,
    ( 'k, 'v, 'cmp ) t ->
    ( 'k, 'v, 'cmp ) t ->
    data_equal:( 'v -> 'v -> bool ) ->
    ('k key * [ `Left of 'v | `Right of 'v | `Unequal of 'v * 'v ]) Sequence.t )
    options

val fold_symmetric_diff : 
  ( 'k,
    'cmp,
    ( 'k, 'v, 'cmp ) t ->
    ( 'k, 'v, 'cmp ) t ->
    data_equal:( 'v -> 'v -> bool ) ->
    init:'a ->
    f:
      ( 'a ->
        ('k key * [ `Left of 'v | `Right of 'v | `Unequal of 'v * 'v ]) ->
        'a ) ->
    'a )
    options

val min_elt : ( 'k, 'v, _ ) t -> ('k key * 'v) option

val min_elt_exn : ( 'k, 'v, _ ) t -> 'k key * 'v

val max_elt : ( 'k, 'v, _ ) t -> ('k key * 'v) option

val max_elt_exn : ( 'k, 'v, _ ) t -> 'k key * 'v

val for_all : ( 'k, 'v, _ ) t -> f:( 'v -> bool ) -> bool

val for_alli : ( 'k, 'v, _ ) t -> f:( key:'k key -> data:'v -> bool ) -> bool

val exists : ( 'k, 'v, _ ) t -> f:( 'v -> bool ) -> bool

val existsi : ( 'k, 'v, _ ) t -> f:( key:'k key -> data:'v -> bool ) -> bool

val count : ( 'k, 'v, _ ) t -> f:( 'v -> bool ) -> int

val counti : ( 'k, 'v, _ ) t -> f:( key:'k key -> data:'v -> bool ) -> int

val split : 
  ( 'k,
    'cmp,
    ( 'k, 'v, 'cmp ) t ->
    'k key ->
    ( 'k, 'v, 'cmp ) t * ('k key * 'v) option * ( 'k, 'v, 'cmp ) t )
    options

val append : 
  ( 'k,
    'cmp,
    lower_part:( 'k, 'v, 'cmp ) t ->
    upper_part:( 'k, 'v, 'cmp ) t ->
    [ `Ok of ( 'k, 'v, 'cmp ) t | `Overlapping_key_ranges ] )
    options

val subrange : 
  ( 'k,
    'cmp,
    ( 'k, 'v, 'cmp ) t ->
    lower_bound:'k key Maybe_bound.t ->
    upper_bound:'k key Maybe_bound.t ->
    ( 'k, 'v, 'cmp ) t )
    options

val fold_range_inclusive : 
  ( 'k,
    'cmp,
    ( 'k, 'v, 'cmp ) t ->
    min:'k key ->
    max:'k key ->
    init:'a ->
    f:( key:'k key -> data:'v -> 'a -> 'a ) ->
    'a )
    options

val range_to_alist : 
  ( 'k,
    'cmp,
    ( 'k, 'v, 'cmp ) t ->
    min:'k key ->
    max:'k key ->
    ('k key * 'v) list )
    options

val closest_key : 
  ( 'k,
    'cmp,
    ( 'k, 'v, 'cmp ) t ->
    [ `Greater_or_equal_to | `Greater_than | `Less_or_equal_to | `Less_than ] ->
    'k key ->
    ('k key * 'v) option )
    options

val nth : ( 'k, 'v, 'cmp ) t -> int -> ('k key * 'v) option

val nth_exn : ( 'k, 'v, 'cmp ) t -> int -> 'k key * 'v

val rank : ( 'k, 'cmp, ( 'k, _, 'cmp ) t -> 'k key -> int option ) options

val to_tree : ( 'k, 'v, 'cmp ) t -> ( 'k key, 'v, 'cmp ) tree

val to_sequence : 
  ( 'k,
    'cmp,
    ?order:[ `Increasing_key | `Decreasing_key ] ->
    ?keys_greater_or_equal_to:'k key ->
    ?keys_less_or_equal_to:'k key ->
    ( 'k, 'v, 'cmp ) t ->
    ('k key * 'v) Sequence.t )
    options

val binary_search : 
  ( 'k,
    'cmp,
    ( 'k, 'v, 'cmp ) t ->
    compare:( key:'k key -> data:'v -> 'key -> int ) ->
    Binary_searchable.Which_target_by_key.t ->
    'key ->
    ('k key * 'v) option )
    options

val binary_search_segmented : 
  ( 'k,
    'cmp,
    ( 'k, 'v, 'cmp ) t ->
    segment_of:( key:'k key -> data:'v -> [ `Left | `Right ] ) ->
    Binary_searchable.Which_target_by_segment.t ->
    ('k key * 'v) option )
    options

val binary_search_subrange : 
  ( 'k,
    'cmp,
    ( 'k, 'v, 'cmp ) t ->
    compare:( key:'k key -> data:'v -> 'bound -> int ) ->
    lower_bound:'bound Maybe_bound.t ->
    upper_bound:'bound Maybe_bound.t ->
    ( 'k, 'v, 'cmp ) t )
    options