sig
module Stat :
sig
type t =
Core_kernel.Core_gc.Stat.t = {
minor_words : float;
promoted_words : float;
major_words : float;
minor_collections : int;
major_collections : int;
heap_words : int;
heap_chunks : int;
live_words : int;
live_blocks : int;
free_words : int;
free_blocks : int;
largest_free : int;
fragments : int;
compactions : int;
top_heap_words : int;
stack_size : int;
}
val stack_size : t -> int
val top_heap_words : t -> int
val compactions : t -> int
val fragments : t -> int
val largest_free : t -> int
val free_blocks : t -> int
val free_words : t -> int
val live_blocks : t -> int
val live_words : t -> int
val heap_chunks : t -> int
val heap_words : t -> int
val major_collections : t -> int
val minor_collections : t -> int
val major_words : t -> float
val promoted_words : t -> float
val minor_words : t -> float
module Fields :
sig
val names : string list
val stack_size : (t, int) Fieldslib.Field.t
val top_heap_words : (t, int) Fieldslib.Field.t
val compactions : (t, int) Fieldslib.Field.t
val fragments : (t, int) Fieldslib.Field.t
val largest_free : (t, int) Fieldslib.Field.t
val free_blocks : (t, int) Fieldslib.Field.t
val free_words : (t, int) Fieldslib.Field.t
val live_blocks : (t, int) Fieldslib.Field.t
val live_words : (t, int) Fieldslib.Field.t
val heap_chunks : (t, int) Fieldslib.Field.t
val heap_words : (t, int) Fieldslib.Field.t
val major_collections : (t, int) Fieldslib.Field.t
val minor_collections : (t, int) Fieldslib.Field.t
val major_words : (t, float) Fieldslib.Field.t
val promoted_words : (t, float) Fieldslib.Field.t
val minor_words : (t, float) Fieldslib.Field.t
val fold :
init:'acc__ ->
minor_words:('acc__ -> (t, float) Fieldslib.Field.t -> 'acc__) ->
promoted_words:('acc__ -> (t, float) Fieldslib.Field.t -> 'acc__) ->
major_words:('acc__ -> (t, float) Fieldslib.Field.t -> 'acc__) ->
minor_collections:('acc__ -> (t, int) Fieldslib.Field.t -> 'acc__) ->
major_collections:('acc__ -> (t, int) Fieldslib.Field.t -> 'acc__) ->
heap_words:('acc__ -> (t, int) Fieldslib.Field.t -> 'acc__) ->
heap_chunks:('acc__ -> (t, int) Fieldslib.Field.t -> 'acc__) ->
live_words:('acc__ -> (t, int) Fieldslib.Field.t -> 'acc__) ->
live_blocks:('acc__ -> (t, int) Fieldslib.Field.t -> 'acc__) ->
free_words:('acc__ -> (t, int) Fieldslib.Field.t -> 'acc__) ->
free_blocks:('acc__ -> (t, int) Fieldslib.Field.t -> 'acc__) ->
largest_free:('acc__ -> (t, int) Fieldslib.Field.t -> 'acc__) ->
fragments:('acc__ -> (t, int) Fieldslib.Field.t -> 'acc__) ->
compactions:('acc__ -> (t, int) Fieldslib.Field.t -> 'acc__) ->
top_heap_words:('acc__ -> (t, int) Fieldslib.Field.t -> 'acc__) ->
stack_size:('acc__ -> (t, int) Fieldslib.Field.t -> 'acc__) ->
'acc__
val make_creator :
minor_words:((t, float) Fieldslib.Field.t ->
'compile_acc__ ->
('input__ -> float) * 'compile_acc__) ->
promoted_words:((t, float) Fieldslib.Field.t ->
'compile_acc__ ->
('input__ -> float) * 'compile_acc__) ->
major_words:((t, float) Fieldslib.Field.t ->
'compile_acc__ ->
('input__ -> float) * 'compile_acc__) ->
minor_collections:((t, int) Fieldslib.Field.t ->
'compile_acc__ ->
('input__ -> int) * 'compile_acc__) ->
major_collections:((t, int) Fieldslib.Field.t ->
'compile_acc__ ->
('input__ -> int) * 'compile_acc__) ->
heap_words:((t, int) Fieldslib.Field.t ->
'compile_acc__ -> ('input__ -> int) * 'compile_acc__) ->
heap_chunks:((t, int) Fieldslib.Field.t ->
'compile_acc__ -> ('input__ -> int) * 'compile_acc__) ->
live_words:((t, int) Fieldslib.Field.t ->
'compile_acc__ -> ('input__ -> int) * 'compile_acc__) ->
live_blocks:((t, int) Fieldslib.Field.t ->
'compile_acc__ -> ('input__ -> int) * 'compile_acc__) ->
free_words:((t, int) Fieldslib.Field.t ->
'compile_acc__ -> ('input__ -> int) * 'compile_acc__) ->
free_blocks:((t, int) Fieldslib.Field.t ->
'compile_acc__ -> ('input__ -> int) * 'compile_acc__) ->
largest_free:((t, int) Fieldslib.Field.t ->
'compile_acc__ ->
('input__ -> int) * 'compile_acc__) ->
fragments:((t, int) Fieldslib.Field.t ->
'compile_acc__ -> ('input__ -> int) * 'compile_acc__) ->
compactions:((t, int) Fieldslib.Field.t ->
'compile_acc__ -> ('input__ -> int) * 'compile_acc__) ->
top_heap_words:((t, int) Fieldslib.Field.t ->
'compile_acc__ ->
('input__ -> int) * 'compile_acc__) ->
stack_size:((t, int) Fieldslib.Field.t ->
'compile_acc__ -> ('input__ -> int) * 'compile_acc__) ->
'compile_acc__ -> ('input__ -> t) * 'compile_acc__
val create :
minor_words:float ->
promoted_words:float ->
major_words:float ->
minor_collections:int ->
major_collections:int ->
heap_words:int ->
heap_chunks:int ->
live_words:int ->
live_blocks:int ->
free_words:int ->
free_blocks:int ->
largest_free:int ->
fragments:int ->
compactions:int -> top_heap_words:int -> stack_size:int -> t
val map :
minor_words:((t, float) Fieldslib.Field.t -> float) ->
promoted_words:((t, float) Fieldslib.Field.t -> float) ->
major_words:((t, float) Fieldslib.Field.t -> float) ->
minor_collections:((t, int) Fieldslib.Field.t -> int) ->
major_collections:((t, int) Fieldslib.Field.t -> int) ->
heap_words:((t, int) Fieldslib.Field.t -> int) ->
heap_chunks:((t, int) Fieldslib.Field.t -> int) ->
live_words:((t, int) Fieldslib.Field.t -> int) ->
live_blocks:((t, int) Fieldslib.Field.t -> int) ->
free_words:((t, int) Fieldslib.Field.t -> int) ->
free_blocks:((t, int) Fieldslib.Field.t -> int) ->
largest_free:((t, int) Fieldslib.Field.t -> int) ->
fragments:((t, int) Fieldslib.Field.t -> int) ->
compactions:((t, int) Fieldslib.Field.t -> int) ->
top_heap_words:((t, int) Fieldslib.Field.t -> int) ->
stack_size:((t, int) Fieldslib.Field.t -> int) -> t
val iter :
minor_words:((t, float) Fieldslib.Field.t -> unit) ->
promoted_words:((t, float) Fieldslib.Field.t -> unit) ->
major_words:((t, float) Fieldslib.Field.t -> unit) ->
minor_collections:((t, int) Fieldslib.Field.t -> unit) ->
major_collections:((t, int) Fieldslib.Field.t -> unit) ->
heap_words:((t, int) Fieldslib.Field.t -> unit) ->
heap_chunks:((t, int) Fieldslib.Field.t -> unit) ->
live_words:((t, int) Fieldslib.Field.t -> unit) ->
live_blocks:((t, int) Fieldslib.Field.t -> unit) ->
free_words:((t, int) Fieldslib.Field.t -> unit) ->
free_blocks:((t, int) Fieldslib.Field.t -> unit) ->
largest_free:((t, int) Fieldslib.Field.t -> unit) ->
fragments:((t, int) Fieldslib.Field.t -> unit) ->
compactions:((t, int) Fieldslib.Field.t -> unit) ->
top_heap_words:((t, int) Fieldslib.Field.t -> unit) ->
stack_size:((t, int) Fieldslib.Field.t -> unit) -> unit
val for_all :
minor_words:((t, float) Fieldslib.Field.t -> bool) ->
promoted_words:((t, float) Fieldslib.Field.t -> bool) ->
major_words:((t, float) Fieldslib.Field.t -> bool) ->
minor_collections:((t, int) Fieldslib.Field.t -> bool) ->
major_collections:((t, int) Fieldslib.Field.t -> bool) ->
heap_words:((t, int) Fieldslib.Field.t -> bool) ->
heap_chunks:((t, int) Fieldslib.Field.t -> bool) ->
live_words:((t, int) Fieldslib.Field.t -> bool) ->
live_blocks:((t, int) Fieldslib.Field.t -> bool) ->
free_words:((t, int) Fieldslib.Field.t -> bool) ->
free_blocks:((t, int) Fieldslib.Field.t -> bool) ->
largest_free:((t, int) Fieldslib.Field.t -> bool) ->
fragments:((t, int) Fieldslib.Field.t -> bool) ->
compactions:((t, int) Fieldslib.Field.t -> bool) ->
top_heap_words:((t, int) Fieldslib.Field.t -> bool) ->
stack_size:((t, int) Fieldslib.Field.t -> bool) -> bool
val exists :
minor_words:((t, float) Fieldslib.Field.t -> bool) ->
promoted_words:((t, float) Fieldslib.Field.t -> bool) ->
major_words:((t, float) Fieldslib.Field.t -> bool) ->
minor_collections:((t, int) Fieldslib.Field.t -> bool) ->
major_collections:((t, int) Fieldslib.Field.t -> bool) ->
heap_words:((t, int) Fieldslib.Field.t -> bool) ->
heap_chunks:((t, int) Fieldslib.Field.t -> bool) ->
live_words:((t, int) Fieldslib.Field.t -> bool) ->
live_blocks:((t, int) Fieldslib.Field.t -> bool) ->
free_words:((t, int) Fieldslib.Field.t -> bool) ->
free_blocks:((t, int) Fieldslib.Field.t -> bool) ->
largest_free:((t, int) Fieldslib.Field.t -> bool) ->
fragments:((t, int) Fieldslib.Field.t -> bool) ->
compactions:((t, int) Fieldslib.Field.t -> bool) ->
top_heap_words:((t, int) Fieldslib.Field.t -> bool) ->
stack_size:((t, int) Fieldslib.Field.t -> bool) -> bool
val to_list :
minor_words:((t, float) Fieldslib.Field.t -> 'elem__) ->
promoted_words:((t, float) Fieldslib.Field.t -> 'elem__) ->
major_words:((t, float) Fieldslib.Field.t -> 'elem__) ->
minor_collections:((t, int) Fieldslib.Field.t -> 'elem__) ->
major_collections:((t, int) Fieldslib.Field.t -> 'elem__) ->
heap_words:((t, int) Fieldslib.Field.t -> 'elem__) ->
heap_chunks:((t, int) Fieldslib.Field.t -> 'elem__) ->
live_words:((t, int) Fieldslib.Field.t -> 'elem__) ->
live_blocks:((t, int) Fieldslib.Field.t -> 'elem__) ->
free_words:((t, int) Fieldslib.Field.t -> 'elem__) ->
free_blocks:((t, int) Fieldslib.Field.t -> 'elem__) ->
largest_free:((t, int) Fieldslib.Field.t -> 'elem__) ->
fragments:((t, int) Fieldslib.Field.t -> 'elem__) ->
compactions:((t, int) Fieldslib.Field.t -> 'elem__) ->
top_heap_words:((t, int) Fieldslib.Field.t -> 'elem__) ->
stack_size:((t, int) Fieldslib.Field.t -> 'elem__) ->
'elem__ list
val map_poly :
([< `Read | `Set_and_create ], t, 'x0) Fieldslib.Field.user ->
'x0 list
module Direct :
sig
val iter :
t ->
minor_words:((t, float) Fieldslib.Field.t ->
t -> float -> unit) ->
promoted_words:((t, float) Fieldslib.Field.t ->
t -> float -> unit) ->
major_words:((t, float) Fieldslib.Field.t ->
t -> float -> unit) ->
minor_collections:((t, int) Fieldslib.Field.t ->
t -> int -> unit) ->
major_collections:((t, int) Fieldslib.Field.t ->
t -> int -> unit) ->
heap_words:((t, int) Fieldslib.Field.t -> t -> int -> unit) ->
heap_chunks:((t, int) Fieldslib.Field.t -> t -> int -> unit) ->
live_words:((t, int) Fieldslib.Field.t -> t -> int -> unit) ->
live_blocks:((t, int) Fieldslib.Field.t -> t -> int -> unit) ->
free_words:((t, int) Fieldslib.Field.t -> t -> int -> unit) ->
free_blocks:((t, int) Fieldslib.Field.t -> t -> int -> unit) ->
largest_free:((t, int) Fieldslib.Field.t -> t -> int -> unit) ->
fragments:((t, int) Fieldslib.Field.t -> t -> int -> unit) ->
compactions:((t, int) Fieldslib.Field.t -> t -> int -> unit) ->
top_heap_words:((t, int) Fieldslib.Field.t ->
t -> int -> unit) ->
stack_size:((t, int) Fieldslib.Field.t -> t -> int -> unit) ->
unit
val fold :
t ->
init:'acc__ ->
minor_words:('acc__ ->
(t, float) Fieldslib.Field.t ->
t -> float -> 'acc__) ->
promoted_words:('acc__ ->
(t, float) Fieldslib.Field.t ->
t -> float -> 'acc__) ->
major_words:('acc__ ->
(t, float) Fieldslib.Field.t ->
t -> float -> 'acc__) ->
minor_collections:('acc__ ->
(t, int) Fieldslib.Field.t ->
t -> int -> 'acc__) ->
major_collections:('acc__ ->
(t, int) Fieldslib.Field.t ->
t -> int -> 'acc__) ->
heap_words:('acc__ ->
(t, int) Fieldslib.Field.t -> t -> int -> 'acc__) ->
heap_chunks:('acc__ ->
(t, int) Fieldslib.Field.t -> t -> int -> 'acc__) ->
live_words:('acc__ ->
(t, int) Fieldslib.Field.t -> t -> int -> 'acc__) ->
live_blocks:('acc__ ->
(t, int) Fieldslib.Field.t -> t -> int -> 'acc__) ->
free_words:('acc__ ->
(t, int) Fieldslib.Field.t -> t -> int -> 'acc__) ->
free_blocks:('acc__ ->
(t, int) Fieldslib.Field.t -> t -> int -> 'acc__) ->
largest_free:('acc__ ->
(t, int) Fieldslib.Field.t ->
t -> int -> 'acc__) ->
fragments:('acc__ ->
(t, int) Fieldslib.Field.t -> t -> int -> 'acc__) ->
compactions:('acc__ ->
(t, int) Fieldslib.Field.t -> t -> int -> 'acc__) ->
top_heap_words:('acc__ ->
(t, int) Fieldslib.Field.t ->
t -> int -> 'acc__) ->
stack_size:('acc__ ->
(t, int) Fieldslib.Field.t -> t -> int -> 'acc__) ->
'acc__
val set_all_mutable_fields : t -> unit
end
end
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 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 = Core_kernel.Core_gc.Stat.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 -> '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:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> '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 -> 'a t
val add_multi : 'a list t -> key:Key.t -> data:'a -> '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:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> 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) ->
'a Core_kernel.Validate.check ->
'a t Core_kernel.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t * [ `Left of 'a | `Right of 'a | `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:('a -> bool) -> bool
val exists : 'a t -> f:('a -> 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:'b -> f:(key:Key.t -> data:'a -> 'b -> '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 :
('a -> 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 -> '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:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> '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 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 -> 'a t
val add_multi : 'a list t -> key:Key.t -> data:'a -> '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:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> 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) ->
'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t * [ `Left of 'a | `Right of 'a | `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:('a -> bool) -> bool
val exists : 'a t -> f:('a -> 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:'b -> f:(key:Key.t -> data:'a -> 'b -> '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 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 : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val compare : ('a -> 'a -> 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:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b
val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> '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:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel.Core_set.Tree.t ->
f:('a -> 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:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b
val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> '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:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel.Core_set.t -> f:('a -> 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 t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
end
type stat = Stat.t
module Control :
sig
type t =
Core_kernel.Core_gc.Control.t = {
mutable minor_heap_size : int;
mutable major_heap_increment : int;
mutable space_overhead : int;
mutable verbose : int;
mutable max_overhead : int;
mutable stack_limit : int;
mutable allocation_policy : int;
}
val allocation_policy : t -> int
val set_allocation_policy : t -> int -> unit
val stack_limit : t -> int
val set_stack_limit : t -> int -> unit
val max_overhead : t -> int
val set_max_overhead : t -> int -> unit
val verbose : t -> int
val set_verbose : t -> int -> unit
val space_overhead : t -> int
val set_space_overhead : t -> int -> unit
val major_heap_increment : t -> int
val set_major_heap_increment : t -> int -> unit
val minor_heap_size : t -> int
val set_minor_heap_size : t -> int -> unit
module Fields :
sig
val names : string list
val allocation_policy : (t, int) Fieldslib.Field.t
val stack_limit : (t, int) Fieldslib.Field.t
val max_overhead : (t, int) Fieldslib.Field.t
val verbose : (t, int) Fieldslib.Field.t
val space_overhead : (t, int) Fieldslib.Field.t
val major_heap_increment : (t, int) Fieldslib.Field.t
val minor_heap_size : (t, int) Fieldslib.Field.t
val fold :
init:'acc__ ->
minor_heap_size:('acc__ -> (t, int) Fieldslib.Field.t -> 'acc__) ->
major_heap_increment:('acc__ ->
(t, int) Fieldslib.Field.t -> 'acc__) ->
space_overhead:('acc__ -> (t, int) Fieldslib.Field.t -> 'acc__) ->
verbose:('acc__ -> (t, int) Fieldslib.Field.t -> 'acc__) ->
max_overhead:('acc__ -> (t, int) Fieldslib.Field.t -> 'acc__) ->
stack_limit:('acc__ -> (t, int) Fieldslib.Field.t -> 'acc__) ->
allocation_policy:('acc__ -> (t, int) Fieldslib.Field.t -> 'acc__) ->
'acc__
val make_creator :
minor_heap_size:((t, int) Fieldslib.Field.t ->
'compile_acc__ ->
('input__ -> int) * 'compile_acc__) ->
major_heap_increment:((t, int) Fieldslib.Field.t ->
'compile_acc__ ->
('input__ -> int) * 'compile_acc__) ->
space_overhead:((t, int) Fieldslib.Field.t ->
'compile_acc__ ->
('input__ -> int) * 'compile_acc__) ->
verbose:((t, int) Fieldslib.Field.t ->
'compile_acc__ -> ('input__ -> int) * 'compile_acc__) ->
max_overhead:((t, int) Fieldslib.Field.t ->
'compile_acc__ ->
('input__ -> int) * 'compile_acc__) ->
stack_limit:((t, int) Fieldslib.Field.t ->
'compile_acc__ -> ('input__ -> int) * 'compile_acc__) ->
allocation_policy:((t, int) Fieldslib.Field.t ->
'compile_acc__ ->
('input__ -> int) * 'compile_acc__) ->
'compile_acc__ -> ('input__ -> t) * 'compile_acc__
val create :
minor_heap_size:int ->
major_heap_increment:int ->
space_overhead:int ->
verbose:int ->
max_overhead:int -> stack_limit:int -> allocation_policy:int -> t
val map :
minor_heap_size:((t, int) Fieldslib.Field.t -> int) ->
major_heap_increment:((t, int) Fieldslib.Field.t -> int) ->
space_overhead:((t, int) Fieldslib.Field.t -> int) ->
verbose:((t, int) Fieldslib.Field.t -> int) ->
max_overhead:((t, int) Fieldslib.Field.t -> int) ->
stack_limit:((t, int) Fieldslib.Field.t -> int) ->
allocation_policy:((t, int) Fieldslib.Field.t -> int) -> t
val iter :
minor_heap_size:((t, int) Fieldslib.Field.t -> unit) ->
major_heap_increment:((t, int) Fieldslib.Field.t -> unit) ->
space_overhead:((t, int) Fieldslib.Field.t -> unit) ->
verbose:((t, int) Fieldslib.Field.t -> unit) ->
max_overhead:((t, int) Fieldslib.Field.t -> unit) ->
stack_limit:((t, int) Fieldslib.Field.t -> unit) ->
allocation_policy:((t, int) Fieldslib.Field.t -> unit) -> unit
val for_all :
minor_heap_size:((t, int) Fieldslib.Field.t -> bool) ->
major_heap_increment:((t, int) Fieldslib.Field.t -> bool) ->
space_overhead:((t, int) Fieldslib.Field.t -> bool) ->
verbose:((t, int) Fieldslib.Field.t -> bool) ->
max_overhead:((t, int) Fieldslib.Field.t -> bool) ->
stack_limit:((t, int) Fieldslib.Field.t -> bool) ->
allocation_policy:((t, int) Fieldslib.Field.t -> bool) -> bool
val exists :
minor_heap_size:((t, int) Fieldslib.Field.t -> bool) ->
major_heap_increment:((t, int) Fieldslib.Field.t -> bool) ->
space_overhead:((t, int) Fieldslib.Field.t -> bool) ->
verbose:((t, int) Fieldslib.Field.t -> bool) ->
max_overhead:((t, int) Fieldslib.Field.t -> bool) ->
stack_limit:((t, int) Fieldslib.Field.t -> bool) ->
allocation_policy:((t, int) Fieldslib.Field.t -> bool) -> bool
val to_list :
minor_heap_size:((t, int) Fieldslib.Field.t -> 'elem__) ->
major_heap_increment:((t, int) Fieldslib.Field.t -> 'elem__) ->
space_overhead:((t, int) Fieldslib.Field.t -> 'elem__) ->
verbose:((t, int) Fieldslib.Field.t -> 'elem__) ->
max_overhead:((t, int) Fieldslib.Field.t -> 'elem__) ->
stack_limit:((t, int) Fieldslib.Field.t -> 'elem__) ->
allocation_policy:((t, int) Fieldslib.Field.t -> 'elem__) ->
'elem__ list
val map_poly :
([< `Read | `Set_and_create ], t, 'x0) Fieldslib.Field.user ->
'x0 list
module Direct :
sig
val iter :
t ->
minor_heap_size:((t, int) Fieldslib.Field.t ->
t -> int -> unit) ->
major_heap_increment:((t, int) Fieldslib.Field.t ->
t -> int -> unit) ->
space_overhead:((t, int) Fieldslib.Field.t ->
t -> int -> unit) ->
verbose:((t, int) Fieldslib.Field.t -> t -> int -> unit) ->
max_overhead:((t, int) Fieldslib.Field.t -> t -> int -> unit) ->
stack_limit:((t, int) Fieldslib.Field.t -> t -> int -> unit) ->
allocation_policy:((t, int) Fieldslib.Field.t ->
t -> int -> unit) ->
unit
val fold :
t ->
init:'acc__ ->
minor_heap_size:('acc__ ->
(t, int) Fieldslib.Field.t ->
t -> int -> 'acc__) ->
major_heap_increment:('acc__ ->
(t, int) Fieldslib.Field.t ->
t -> int -> 'acc__) ->
space_overhead:('acc__ ->
(t, int) Fieldslib.Field.t ->
t -> int -> 'acc__) ->
verbose:('acc__ ->
(t, int) Fieldslib.Field.t -> t -> int -> 'acc__) ->
max_overhead:('acc__ ->
(t, int) Fieldslib.Field.t ->
t -> int -> 'acc__) ->
stack_limit:('acc__ ->
(t, int) Fieldslib.Field.t -> t -> int -> 'acc__) ->
allocation_policy:('acc__ ->
(t, int) Fieldslib.Field.t ->
t -> int -> 'acc__) ->
'acc__
val set_all_mutable_fields :
t ->
minor_heap_size:int ->
major_heap_increment:int ->
space_overhead:int ->
verbose:int ->
max_overhead:int ->
stack_limit:int -> allocation_policy:int -> unit
end
end
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 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 =
Core_kernel.Core_gc.Control.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 -> '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:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> '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 -> 'a t
val add_multi : 'a list t -> key:Key.t -> data:'a -> '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:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> 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) ->
'a Core_kernel.Validate.check ->
'a t Core_kernel.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t * [ `Left of 'a | `Right of 'a | `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:('a -> bool) -> bool
val exists : 'a t -> f:('a -> 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:'b -> f:(key:Key.t -> data:'a -> 'b -> '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 :
('a -> 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 -> '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:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> '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 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 -> 'a t
val add_multi : 'a list t -> key:Key.t -> data:'a -> '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:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> 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) ->
'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t * [ `Left of 'a | `Right of 'a | `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:('a -> bool) -> bool
val exists : 'a t -> f:('a -> 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:'b -> f:(key:Key.t -> data:'a -> 'b -> '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 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 : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val compare : ('a -> 'a -> 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:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b
val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> '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:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel.Core_set.Tree.t ->
f:('a -> 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:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b
val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> '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:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel.Core_set.t -> f:('a -> 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 t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
end
type control = Control.t
external stat : unit -> stat = "caml_gc_stat"
external quick_stat : unit -> stat = "caml_gc_quick_stat"
external counters : unit -> float * float * float = "caml_gc_counters"
external minor_words : unit -> int = "core_kernel_gc_minor_words"
external major_words : unit -> int = "core_kernel_gc_major_words" "noalloc"
external promoted_words : unit -> int = "core_kernel_gc_promoted_words"
"noalloc"
external minor_collections : unit -> int
= "core_kernel_gc_minor_collections" "noalloc"
external major_collections : unit -> int
= "core_kernel_gc_major_collections" "noalloc"
external heap_words : unit -> int = "core_kernel_gc_heap_words" "noalloc"
external heap_chunks : unit -> int = "core_kernel_gc_heap_chunks" "noalloc"
external compactions : unit -> int = "core_kernel_gc_compactions" "noalloc"
external top_heap_words : unit -> int = "core_kernel_gc_top_heap_words"
"noalloc"
external major_plus_minor_words : unit -> int
= "core_kernel_gc_major_plus_minor_words"
external get : unit -> control = "caml_gc_get"
external set : control -> unit = "caml_gc_set"
external minor : unit -> unit = "caml_gc_minor"
external major_slice : int -> int = "caml_gc_major_slice"
external major : unit -> unit = "caml_gc_major"
external full_major : unit -> unit = "caml_gc_full_major"
external compact : unit -> unit = "caml_gc_compaction"
val print_stat : out_channel -> unit
val allocated_bytes : unit -> float
val keep_alive : 'a -> unit
val tune :
?logger:(string -> unit) ->
?minor_heap_size:int ->
?major_heap_increment:int ->
?space_overhead:int ->
?verbose:int ->
?max_overhead:int ->
?stack_limit:int -> ?allocation_policy:int -> unit -> unit
module Allocation_policy :
sig
type t = Core_kernel.Core_gc.Allocation_policy.t = Next_fit | First_fit
end
val disable_compaction :
?logger:(string -> unit) ->
allocation_policy:[ `Don't_change | `Set_to of Allocation_policy.t ] ->
unit -> unit
module Expert :
sig
val add_finalizer :
'a Core_kernel.Heap_block.t ->
('a Core_kernel.Heap_block.t -> unit) -> unit
val add_finalizer_exn : 'a -> ('a -> unit) -> unit
val finalize_release : unit -> unit
module Alarm :
sig
type t = Core_kernel.Core_gc.Expert.Alarm.t
val create : (unit -> unit) -> t
val delete : t -> unit
val sexp_of_t : t -> Sexplib.Sexp.t
end
end
val without_compactions :
?logger:(string -> unit) -> f:('a -> 'b) -> 'a -> 'b
end