simon/ocaml-containers
1
0
Fork 0
mirror of https://github.com/c-cube/ocaml-containers.git synced 2026-01-21 16:56:39 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge pull request #178 from Fourchaux/master

Browse source 
Small typos & Style
This commit is contained in:
Simon Cruanes 2018-01-21 14:38:27 -06:00 • committed by GitHub
commit f98bcffaee
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
31 changed files with 434 additions and 480 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

40
src/data/CCBV.mli
View file

@ -16,13 +16,13 @@ type t
(** A resizable bitvector *)
val empty : unit -> t
(** Empty bitvector *)
(** Empty bitvector. *)
val create : size:int -> bool -> t
(** Create a bitvector of given size, with given default value *)
(** Create a bitvector of given size, with given default value. *)
val copy : t -> t
(** Copy of bitvector *)
(** Copy of bitvector. *)
val cardinal : t -> int
(** Number of bits set to one, seen as a set of bits. *)
@ -51,7 +51,7 @@ val set : t -> int -> unit
(** Set i-th bit, extending the bitvector if needed. *)
val get : t -> int -> bool
(** Is the i-th bit true? Returns false if the index is too high*)
(** Is the i-th bit true? Returns false if the index is too high. *)
val reset : t -> int -> unit
(** Set i-th bit to 0, extending the bitvector if needed. *)
@ -60,20 +60,20 @@ val flip : t -> int -> unit
(** Flip i-th bit, extending the bitvector if needed. *)
val clear : t -> unit
(** Set every bit to 0 *)
(** Set every bit to 0. *)
val iter : t -> (int -> bool -> unit) -> unit
(** Iterate on all bits *)
(** Iterate on all bits. *)
val iter_true : t -> (int -> unit) -> unit
(** Iterate on bits set to 1 *)
(** Iterate on bits set to 1. *)
val to_list : t -> int list
(** List of indexes that are true *)
(** List of indexes that are true. *)
val to_sorted_list : t -> int list
(** Same as {!to_list}, but also guarantees the list is sorted in
increasing order *)
increasing order. *)
val of_list : int list -> t
(** From a list of true bits.
@ -87,12 +87,12 @@ val first : t -> int option
val first_exn : t -> int
(** First set bit, or
@raise Not_found if all bits are 0
@raise Not_found if all bits are 0.
@since 1.2 *)
val filter : t -> (int -> bool) -> unit
(** [filter bv p] only keeps the true bits of [bv] whose [index]
satisfies [p index] *)
satisfies [p index]. *)
val negate_self : t -> unit
(** [negate_self t] flips all of the bits in [t].
@ -103,28 +103,26 @@ val negate : t -> t
(** [negate t] returns a copy of [t] with all of the bits flipped. *)
val union_into : into:t -> t -> unit
(** [union ~into bv] sets [into] to the union of itself and [bv].
(** [union_into ~into bv] sets [into] to the union of itself and [bv].
Also updates the length of [into] to be at least [length bv]. *)
val inter_into : into:t -> t -> unit
(** [inter ~into bv] sets [into] to the intersection of itself and [bv]
(** [inter_into ~into bv] sets [into] to the intersection of itself and [bv].
Also updates the length of [into] to be at most [length bv]. *)
val union : t -> t -> t
(** [union bv1 bv2] returns the union of the two sets *)
(** [union bv1 bv2] returns the union of the two sets. *)
val inter : t -> t -> t
(** [inter bv1 bv2] returns the intersection of the two sets *)
(** [inter bv1 bv2] returns the intersection of the two sets. *)
val diff_into : into:t -> t -> unit
(** [diff ~into t] Modify [into] with only the bits set but not in [t].
(** [diff_into ~into t] modifies [into] with only the bits set but not in [t].
@since 1.2 *)
val diff : t -> t -> t
(** [diff t1 t2] Return those bits found [t1] but not in [t2].
(** [diff t1 t2] returns those bits found in [t1] but not in [t2].
@since 1.2 *)
@ -135,7 +133,7 @@ val select : t -> 'a array -> 'a list
selected. *)
val selecti : t -> 'a array -> ('a * int) list
(** Same as {!select}, but selected elements are paired with their index *)
(** Same as {!select}, but selected elements are paired with their indexes. *)
type 'a sequence = ('a -> unit) -> unit
@ -143,5 +141,5 @@ val to_seq : t -> int sequence
val of_seq : int sequence -> t
val pp : Format.formatter -> t -> unit
(** Print the bitvector as a string of bits
(** Print the bitvector as a string of bits.
@since 0.13 *)

18
src/data/CCBitField.mli
View file

@ -25,13 +25,13 @@
*)
exception TooManyFields
(** Raised when too many fields are packed into one bitfield *)
(** Raised when too many fields are packed into one bitfield. *)
exception Frozen
(** Raised when a frozen bitfield is modified *)
(** Raised when a frozen bitfield is modified. *)
val max_width : int
(** System-dependent maximum width for a bitfield, typically 30 or 62 *)
(** System-dependent maximum width for a bitfield, typically 30 or 62. *)
(** {2 Bitfield Signature} *)
module type S = sig
@ -40,25 +40,25 @@ module type S = sig
should create a new, incompatible type *)
val empty : t
(** Empty bitfields (all bits 0) *)
(** Empty bitfields (all bits 0). *)
type field
val get : field -> t -> bool
(** Get the value of this field *)
(** Get the value of this field. *)
val set : field -> bool -> t -> t
(** Set the value of this field *)
(** Set the value of this field. *)
val mk_field : unit -> field
(** Make a new field *)
(** Make a new field. *)
val freeze : unit -> unit
(** Prevent new fields from being added. From now on, creating
a field will raise Frozen *)
a field will raise Frozen. *)
val total_width : unit -> int
(** Current width of the bitfield *)
(** Current width of the bitfield. *)
end
(** Create a new bitfield type *)

12
src/data/CCCache.mli
View file

@ -29,7 +29,7 @@ type 'a hash = 'a -> int
type ('a, 'b) t
val clear : (_,_) t -> unit
(** Clear the content of the cache *)
(** Clear the content of the cache. *)
type ('a, 'b) callback = in_cache:bool -> 'a -> 'b -> unit
(** Type of the callback that is called once a cached value is found
@ -44,7 +44,7 @@ val with_cache : ?cb:('a, 'b) callback -> ('a, 'b) t -> ('a -> 'b) -> 'a -> 'b
cache [c]. It always returns the same value as
[f x], if [f x] returns, or raise the same exception.
However, [f] may not be called if [x] is in the cache.
@param cb called after the value is generated or retrieved *)
@param cb called after the value is generated or retrieved. *)
val with_cache_rec : ?cb:('a, 'b) callback -> ('a,'b) t -> (('a -> 'b) -> 'a -> 'b) -> 'a -> 'b
(** [with_cache_rec c f] is a function that first, applies [f] to
@ -61,7 +61,7 @@ val with_cache_rec : ?cb:('a, 'b) callback -> ('a,'b) t -> (('a -> 'b) -> 'a ->
fib 70;;
]}
@param cb called after the value is generated or retrieved
@param cb called after the value is generated or retrieved.
*)
val size : (_,_) t -> int
@ -72,18 +72,18 @@ val iter : ('a,'b) t -> ('a -> 'b -> unit) -> unit
(** Iterate on cached values. Should yield [size cache] pairs. *)
val add : ('a, 'b) t -> 'a -> 'b -> bool
(** Manually add a cached value. Returns [true] if the value has succesfully
(** Manually add a cached value. Returns [true] if the value has successfully
been added, and [false] if the value was already bound.
@since 1.5 *)
val dummy : ('a,'b) t
(** Dummy cache, never stores any value *)
(** Dummy cache, never stores any value. *)
val linear : eq:'a equal -> int -> ('a, 'b) t
(** Linear cache with the given size. It stores key/value pairs in
an array and does linear search at every call, so it should only be used
with small size.
@param eq optional equality predicate for keys *)
@param eq optional equality predicate for keys. *)
val replacing : eq:'a equal -> ?hash:'a hash ->
int -> ('a,'b) t

56
src/data/CCDeque.mli
View file

@ -4,7 +4,7 @@
(** {1 Imperative deque}
This structure provides fast access to its front and back elements,
with O(1) operations*)
with O(1) operations *)
type 'a t
(** Contains 'a elements, queue in both ways *)
@ -12,10 +12,10 @@ type 'a t
exception Empty
val create : unit -> 'a t
(** New deque *)
(** New deque. *)
val clear : _ t -> unit
(** Remove all elements
(** Remove all elements.
@since 0.13 *)
val is_empty : 'a t -> bool
@ -24,52 +24,52 @@ val is_empty : 'a t -> bool
val equal : eq:('a -> 'a -> bool) -> 'a t -> 'a t -> bool
(** [equal a b] checks whether [a] and [b] contain the same sequence of
elements.
@param eq comparison function for elements
@param eq comparison function for elements.
@since 0.13 *)
val compare : cmp:('a -> 'a -> int) -> 'a t -> 'a t -> int
(** [compare a b] compares lexicographically [a] and [b]
@param cmp comparison function for elements
@param cmp comparison function for elements.
@since 0.13 *)
val length : 'a t -> int
(** Number of elements
used to be linear time, now constant time *)
(** Number of elements.
Used to be linear time, now constant time. *)
val push_front : 'a t -> 'a -> unit
(** Push value at the front *)
(** Push value at the front. *)
val push_back : 'a t -> 'a -> unit
(** Push value at the back *)
(** Push value at the back. *)
val peek_front : 'a t -> 'a
(** First value, or @raise Empty if empty *)
(** First value, or @raise Empty if empty. *)
val peek_back : 'a t -> 'a
(** Last value, or @raise Empty if empty *)
(** Last value, or @raise Empty if empty. *)
val take_back : 'a t -> 'a
(** Take last value, or @raise Empty if empty *)
(** Take last value, or @raise Empty if empty. *)
val take_front : 'a t -> 'a
(** Take first value, or @raise Empty if empty *)
(** Take first value, or @raise Empty if empty. *)
val append_front : into:'a t -> 'a t -> unit
(** [append_front ~into q] adds all elements of [q] at the front
of [into]
O(length q) in time
of [into].
[O(length q)] in time.
@since 0.13 *)
val append_back : into:'a t -> 'a t -> unit
(** [append_back ~into q] adds all elements of [q] at the back of [into].
O(length q) in time
[O(length q)] in time.
@since 0.13 *)
val iter : ('a -> unit) -> 'a t -> unit
(** Iterate on elements *)
(** Iterate on elements. *)
val fold : ('b -> 'a -> 'b) -> 'b -> 'a t -> 'b
(** Fold on elements
(** Fold on elements.
@since 0.13 *)
(** {2 Conversions} *)
@ -80,36 +80,36 @@ type 'a sequence = ('a -> unit) -> unit
val of_seq : 'a sequence -> 'a t
(** Create a deque from the sequence.
@since 0.13 optional argument [deque] disappears, use
{!add_seq_back} instead *)
{!add_seq_back} instead. *)
val to_seq : 'a t -> 'a sequence
(** iterate on the elements *)
(** Iterate on the elements. *)
val of_gen : 'a gen -> 'a t
(** [of_gen g] makes a deque containing the elements of [g]
(** [of_gen g] makes a deque containing the elements of [g].
@since 0.13 *)
val to_gen : 'a t -> 'a gen
(** Iterates on elements of the deque
(** Iterate on elements of the deque.
@since 0.13 *)
val add_seq_front : 'a t -> 'a sequence -> unit
(** [add_seq_front q seq] adds elements of [seq] into the front of [q],
in reverse order.
O(n) in time, where [n] is the number of elements to add.
[O(n)] in time, where [n] is the number of elements to add.
@since 0.13 *)
val add_seq_back : 'a t -> 'a sequence -> unit
(** [add_seq_back q seq] adds elements of [seq] into the back of [q],
in order.
O(n) in time, where [n] is the number of elements to add.
[O(n)] in time, where [n] is the number of elements to add.
@since 0.13 *)
val copy : 'a t -> 'a t
(** Fresh copy, O(n) in time *)
(** Fresh copy, [O(n)] in time. *)
val of_list : 'a list -> 'a t
(** Conversion from list, in order
(** Conversion from list, in order.
@since 0.13 *)
val to_list : 'a t -> 'a list
@ -117,7 +117,7 @@ val to_list : 'a t -> 'a list
@since 0.13 *)
val to_rev_list : 'a t -> 'a list
(** Efficient conversion to list, in reverse order
(** Efficient conversion to list, in reverse order.
@since 0.13 *)
(** {2 print} *)
@ -125,5 +125,5 @@ val to_rev_list : 'a t -> 'a list
type 'a printer = Format.formatter -> 'a -> unit
val pp : 'a printer -> 'a t printer
(** Print the elements
(** Print the elements.
@since 0.13 *)

44
src/data/CCFQueue.mli
View file

@ -24,67 +24,67 @@ val doubleton : 'a -> 'a -> 'a t
exception Empty
val cons : 'a -> 'a t -> 'a t
(** Push element at the front of the queue *)
(** Push element at the front of the queue. *)
val snoc : 'a t -> 'a -> 'a t
(** Push element at the end of the queue *)
(** Push element at the end of the queue. *)
val take_front : 'a t -> ('a * 'a t) option
(** Get and remove the first element *)
(** Get and remove the first element. *)
val take_front_exn : 'a t -> ('a * 'a t)
(** Same as {!take_front}, but fails on empty queues.
@raise Empty if the queue is empty *)
@raise Empty if the queue is empty. *)
val take_front_l : int -> 'a t -> 'a list * 'a t
(** [take_front_l n q] takes at most [n] elements from the front
of [q], and returns them wrapped in a list
@raise Invalid_argument if n<0 *)
of [q], and returns them wrapped in a list.
@raise Invalid_argument if n<0. *)
val take_front_while : ('a -> bool) -> 'a t -> 'a list * 'a t
val take_back : 'a t -> ('a t * 'a) option
(** Take last element *)
(** Take last element. *)
val take_back_exn : 'a t -> ('a t * 'a)
(** Same as {!take_back}, but fails on empty queues.
@raise Empty if the queue is empty *)
@raise Empty if the queue is empty. *)
val take_back_l : int -> 'a t -> 'a t * 'a list
(** [take_back_l n q] removes and returns the last [n] elements of [q]. The
elements are in the order of the queue, that is, the head of the returned
list is the first element to appear via {!take_front}.
[take_back_l 2 (of_list [1;2;3;4]) = of_list [1;2], [3;4]]
@raise Invalid_argument if n<0 *)
[take_back_l 2 (of_list [1;2;3;4]) = of_list [1;2], [3;4]].
@raise Invalid_argument if n<0. *)
val take_back_while : ('a -> bool) -> 'a t -> 'a t * 'a list
(** {2 Individual extraction} *)
val first : 'a t -> 'a option
(** First element of the queue *)
(** First element of the queue. *)
val last : 'a t -> 'a option
(** Last element of the queue *)
(** Last element of the queue. *)
val first_exn : 'a t -> 'a
(** Same as {!first} but
@raise Empty if the queue is empty *)
@raise Empty if the queue is empty. *)
val last_exn : 'a t -> 'a
val nth : int -> 'a t -> 'a option
(** Return the [i]-th element of the queue in logarithmic time *)
(** Return the [i]-th element of the queue in logarithmic time. *)
val nth_exn : int -> 'a t -> 'a
(** Unsafe version of {!nth}
@raise Not_found if the index is wrong *)
(** Unsafe version of {!nth}.
@raise Not_found if the index is wrong. *)
val tail : 'a t -> 'a t
(** Queue deprived of its first element. Does nothing on empty queues *)
(** Queue deprived of its first element. Does nothing on empty queues. *)
val init : 'a t -> 'a t
(** Queue deprived of its last element. Does nothing on empty queues *)
(** Queue deprived of its last element. Does nothing on empty queues. *)
(** {2 Global Operations} *)
@ -94,17 +94,17 @@ val append : 'a t -> 'a t -> 'a t
Linear in the size of the second queue. *)
val rev : 'a t -> 'a t
(** Reverse the queue, O(n) complexity
(** Reverse the queue, [O(n)] complexity.
@since 0.10 *)
val map : ('a -> 'b) -> 'a t -> 'b t
(** Map values *)
(** Map values. *)
val (>|=) : 'a t -> ('a -> 'b) -> 'b t
(** Synonym to {!map} *)
(** Synonym to {!map}. *)
val size : 'a t -> int
(** Number of elements in the queue (constant time) *)
(** Number of elements in the queue (constant time). *)
val fold : ('b -> 'a -> 'b) -> 'b -> 'a t -> 'b

62
src/data/CCGraph.mli
View file

@ -32,7 +32,7 @@ type 'a sequence_once = 'a sequence
(** Sequence that should be used only once *)
exception Sequence_once
(** Raised when a sequence meant to be used once is used several times *)
(** Raised when a sequence meant to be used once is used several times. *)
module Seq : sig
type 'a t = 'a sequence
@ -55,7 +55,7 @@ type ('v, 'e) t = ('v -> ('e * 'v) sequence)
type ('v, 'e) graph = ('v, 'e) t
val make : ('v -> ('e * 'v) sequence) -> ('v, 'e) t
(** Make a graph by providing the children function *)
(** Make a graph by providing the children function. *)
(** {2 Tags}
@ -78,10 +78,10 @@ type ('k, 'a) table = {
type 'a set = ('a, unit) table
val mk_table: eq:('k -> 'k -> bool) -> ?hash:('k -> int) -> int -> ('k, 'a) table
(** Default implementation for {!table}: a {!Hashtbl.t} *)
(** Default implementation for {!table}: a {!Hashtbl.t}. *)
val mk_map: cmp:('k -> 'k -> int) -> unit -> ('k, 'a) table
(** Use a {!Map.S} underneath *)
(** Use a {!Map.S} underneath. *)
(** {2 Bags of vertices} *)
@ -97,7 +97,7 @@ val mk_stack: unit -> 'a bag
val mk_heap: leq:('a -> 'a -> bool) -> 'a bag
(** [mk_heap ~leq] makes a priority queue where [leq x y = true] means that
[x] is smaller than [y] and should be prioritary *)
[x] is smaller than [y] and should be prioritary. *)
(** {2 Traversals} *)
@ -149,7 +149,7 @@ module Traverse : sig
Yields each vertex paired with its distance to the set of initial vertices
(the smallest distance needed to reach the node from the initial vertices)
@param dist distance from origin of the edge to destination,
must be strictly positive. Default is 1 for every edge *)
must be strictly positive. Default is 1 for every edge. *)
val dijkstra_tag : ?dist:('e -> int) ->
tags:'v tag_set ->
@ -180,15 +180,15 @@ module Traverse : sig
'v sequence ->
('v,'e) t sequence_once
(** Full version of DFS.
@param eq equality predicate on vertices *)
@param eq equality predicate on vertices. *)
val dfs_tag: eq:('v -> 'v -> bool) ->
tags:'v tag_set ->
graph:('v, 'e) graph ->
'v sequence ->
('v,'e) t sequence_once
(** Full version of DFS using integer tags
@param eq equality predicate on vertices *)
(** Full version of DFS using integer tags.
@param eq equality predicate on vertices. *)
end
end
@ -218,12 +218,12 @@ val topo_sort : eq:('v -> 'v -> bool) ->
element of [l] is reachable from [seq].
The list is sorted in a way such that if [v -> v'] in the graph, then
[v] comes before [v'] in the list (i.e. has a smaller index).
Basically [v -> v'] means that [v] is smaller than [v']
see {{: https://en.wikipedia.org/wiki/Topological_sorting} wikipedia}
@param eq equality predicate on vertices (default [(=)])
Basically [v -> v'] means that [v] is smaller than [v'].
See {{: https://en.wikipedia.org/wiki/Topological_sorting} wikipedia}.
@param eq equality predicate on vertices (default [(=)]).
@param rev if true, the dependency relation is inverted ([v -> v'] means
[v'] occurs before [v])
@raise Has_cycle if the graph is not a DAG *)
[v'] occurs before [v]).
@raise Has_cycle if the graph is not a DAG. *)
val topo_sort_tag : eq:('v -> 'v -> bool) ->
?rev:bool ->
@ -231,7 +231,7 @@ val topo_sort_tag : eq:('v -> 'v -> bool) ->
graph:('v, 'e) t ->
'v sequence ->
'v list
(** Same as {!topo_sort} but uses an explicit tag set *)
(** Same as {!topo_sort} but uses an explicit tag set. *)
(** {2 Lazy Spanning Tree} *)
@ -251,7 +251,7 @@ val spanning_tree : tbl:'v set ->
'v ->
('v, 'e) Lazy_tree.t
(** [spanning_tree ~graph v] computes a lazy spanning tree that has [v]
as a root. The table [tbl] is used for the memoization part *)
as a root. The table [tbl] is used for the memoization part. *)
val spanning_tree_tag : tags:'v tag_set ->
graph:('v, 'e) t ->
@ -261,7 +261,7 @@ val spanning_tree_tag : tags:'v tag_set ->
(** {2 Strongly Connected Components} *)
type 'v scc_state
(** Hidden state for {!scc} *)
(** Hidden state for {!scc}. *)
val scc : tbl:('v, 'v scc_state) table ->
graph:('v, 'e) t ->
@ -272,8 +272,8 @@ val scc : tbl:('v, 'v scc_state) table ->
in the graph.
The components are explored in a topological order (if C1 and C2 are
components, and C1 points to C2, then C2 will be yielded before C1).
Uses {{: https://en.wikipedia.org/wiki/Tarjan's_strongly_connected_components_algorithm} Tarjan's algorithm}
@param tbl table used to map nodes to some hidden state
Uses {{: https://en.wikipedia.org/wiki/Tarjan's_strongly_connected_components_algorithm} Tarjan's algorithm}.
@param tbl table used to map nodes to some hidden state.
@raise Sequence_once if the result is iterated on more than once.
*)
@ -314,10 +314,10 @@ module Dot : sig
Format.formatter ->
'v ->
unit
(** Print the graph, starting from given vertex, on the formatter
@param attrs_v attributes for vertices
@param attrs_e attributes for edges
@param name name of the graph *)
(** Print the graph, starting from given vertex, on the formatter.
@param attrs_v attributes for vertices.
@param attrs_e attributes for edges.
@param name name of the graph. *)
val pp_seq : tbl:('v,vertex_state) table ->
eq:('v -> 'v -> bool) ->
@ -330,7 +330,7 @@ module Dot : sig
unit
val with_out : string -> (Format.formatter -> 'a) -> 'a
(** Shortcut to open a file and write to it *)
(** Shortcut to open a file and write to it. *)
end
(** {2 Mutable Graph} *)
@ -345,7 +345,7 @@ val mk_mut_tbl : eq:('v -> 'v -> bool) ->
?hash:('v -> int) ->
int ->
('v, 'a) mut_graph
(** Make a new mutable graph from a Hashtbl. Edges are labelled with type ['a] *)
(** Make a new mutable graph from a Hashtbl. Edges are labelled with type ['a]. *)
(** {2 Immutable Graph}
@ -359,7 +359,7 @@ module type MAP = sig
type 'a t
val as_graph : 'a t -> (vertex, 'a) graph
(** Graph view of the map *)
(** Graph view of the map. *)
val empty : 'a t
@ -368,12 +368,12 @@ module type MAP = sig
val remove_edge : vertex -> vertex -> 'a t -> 'a t
val add : vertex -> 'a t -> 'a t
(** Add a vertex, possibly with no outgoing edge *)
(** Add a vertex, possibly with no outgoing edge. *)
val remove : vertex -> 'a t -> 'a t
(** Remove the vertex and all its outgoing edges.
Edges that point to the vertex are {b NOT} removed, they must be
manually removed with {!remove_edge} *)
manually removed with {!remove_edge}. *)
val union : 'a t -> 'a t -> 'a t
@ -401,15 +401,15 @@ module Map(O : Map.OrderedType) : MAP with type vertex = O.t
val of_list : eq:('v -> 'v -> bool) -> ('v * 'v) list -> ('v, unit) t
(** [of_list l] makes a graph from a list of pairs of vertices.
Each pair [(a,b)] is an edge from [a] to [b].
@param eq equality used to compare vertices *)
@param eq equality used to compare vertices. *)
val of_hashtbl : ('v, 'v list) Hashtbl.t -> ('v, unit) t
(** [of_hashtbl tbl] makes a graph from a hashtable that maps vertices
to lists of children *)
to lists of children. *)
val of_fun : ('v -> 'v list) -> ('v, unit) t
(** [of_fun f] makes a graph out of a function that maps a vertex to
the list of its children. The function is assumed to be deterministic. *)
val divisors_graph : (int, unit) t
(** [n] points to all its strict divisors *)
(** [n] points to all its strict divisors. *)

44
src/data/CCHashSet.mli
View file

@ -14,72 +14,72 @@ module type S = sig
type elt
val create : int -> t
(** [create n] makes a new set with the given capacity [n] *)
(** [create n] makes a new set with the given capacity [n]. *)
val singleton : elt -> t
(** [singleton x] is the singleton [{x}] *)
(** [singleton x] is the singleton [{x}]. *)
val clear : t -> unit
(** [clear s] removes all elements from [s] *)
(** [clear s] removes all elements from [s]. *)
val copy : t -> t
(** Fresh copy *)
(** Fresh copy. *)
val copy_into : into:t -> t -> unit
(** [copy_into ~into s] copies all elements of [s] into [into] *)
(** [copy_into ~into s] copies all elements of [s] into [into]. *)
val insert : t -> elt -> unit
(** [insert s x] adds [x] into [s] *)
(** [insert s x] adds [x] into [s]. *)
val remove : t -> elt -> unit
(** Remove the element, if it were in there *)
(** Remove the element, if it were in there. *)
val cardinal : t -> int
(** [cardinal s] returns the number of elements in [s] *)
(** [cardinal s] returns the number of elements in [s]. *)
val mem : t -> elt -> bool
(** [mem s x] returns [true] iff [x] is in [s] *)
(** [mem s x] returns [true] iff [x] is in [s]. *)
val find_exn : t -> elt -> elt
(** [find_exn s x] returns [y] if [x] and [y] are equal, and [mem s y].
@raise Not_found if [x] not in [s] *)
@raise Not_found if [x] not in [s]. *)
val find : t -> elt -> elt option
(** Safe version of {!find_exn} *)
(** Safe version of {!find_exn}. *)
val inter : t -> t -> t
(** [inter a b] returns [a ∩ b] *)
(** [inter a b] returns [a ∩ b]. *)
val inter_mut : into:t -> t -> unit
(** [inter_mut ~into a] changes [into] into [a ∩ into] *)
(** [inter_mut ~into a] changes [into] into [a ∩ into]. *)
val union : t -> t -> t
(** [union a b] returns [a ∪ b] *)
(** [union a b] returns [a ∪ b]. *)
val union_mut : into:t -> t -> unit
(** [union_mut ~into a] changes [into] into [a ∪ into] *)
(** [union_mut ~into a] changes [into] into [a ∪ into]. *)
val diff : t -> t -> t
(** [diff a b] returns [a - b] *)
(** [diff a b] returns [a - b]. *)
val subset : t -> t -> bool
(** [subset a b] returns [true] if all elements of [a] are in [b] *)
(** [subset a b] returns [true] if all elements of [a] are in [b]. *)
val equal : t -> t -> bool
(** [equal a b] is extensional equality ([a] and [b] have the same elements) *)
(** [equal a b] is extensional equality ([a] and [b] have the same elements). *)
val for_all : (elt -> bool) -> t -> bool
val exists : (elt -> bool) -> t -> bool
val iter : (elt -> unit) -> t -> unit
(** Iterate on values *)
(** Iterate on values. *)
val fold : ('a -> elt -> 'a) -> 'a -> t -> 'a
(** Fold on values *)
(** Fold on values. *)
val elements : t -> elt list
(** List of elements *)
(** List of elements. *)
val of_list : elt list -> t
@ -91,7 +91,7 @@ module type S = sig
val pp : ?sep:string -> elt printer -> t printer
(** [pp pp_elt] returns a set printer, given a printer for
individual elements *)
individual elements. *)
end
module type ELEMENT = sig

37
src/data/CCHashTrie.mli
View file

@ -28,28 +28,28 @@ module Transient : sig
is called, [r] cannot be used to modify the structure again. *)
val create : unit -> t
(** Create a new, active ID *)
(** Create a new, active ID. *)
val equal : t -> t -> bool
(** Equality between IDs *)
(** Equality between IDs. *)
val frozen : t -> bool
(** [frozen i] returns [true] if [freeze i] was called before. In this case,
the ID cannot be used for modifications again. *)
val active : t -> bool
(** [active i] is [not (frozen i)] *)
(** [active i] is [not (frozen i)]. *)
val freeze : t -> unit
(** [freeze i] makes [i] unusable for new modifications. The values
created with [i] will now be immutable. *)
val with_ : (t -> 'a) -> 'a
(** [Transient.with_ f] creates a transient ID [i], calls [f i],
(** [with_ f] creates a transient ID [i], calls [f i],
freezes the ID [i] and returns the result of [f i]. *)
exception Frozen
(** Raised when a frozen ID is used *)
(** Raised when a frozen ID is used. *)
end
(** {2 Signature} *)
@ -71,7 +71,7 @@ module type S = sig
val get : key -> 'a t -> 'a option
val get_exn : key -> 'a t -> 'a
(** @raise Not_found if key not present *)
(** @raise Not_found if key not present. *)
val remove : key -> 'a t -> 'a t
(** Remove the key, if present. *)
@ -79,29 +79,29 @@ module type S = sig
val update : key -> f:('a option -> 'a option) -> 'a t -> 'a t
(** [update k ~f m] calls [f (Some v)] if [get k m = Some v], [f None]
otherwise. Then, if [f] returns [Some v'] it binds [k] to [v'],
if [f] returns [None] it removes [k] *)
if [f] returns [None] it removes [k]. *)
val add_mut : id:Transient.t -> key -> 'a -> 'a t -> 'a t
(** [add_mut ~id k v m] behaves like [add k v m], except it will mutate
in place whenever possible. Changes done with an [id] might affect all
versions of the structure obtained with the same [id] (but not
other versions).
@raise Transient.Frozen if [id] is frozen *)
@raise Transient.Frozen if [id] is frozen. *)
val remove_mut : id:Transient.t -> key -> 'a t -> 'a t
(** Same as {!remove}, but modifies in place whenever possible
@raise Transient.Frozen if [id] is frozen *)
(** Same as {!remove}, but modifies in place whenever possible.
@raise Transient.Frozen if [id] is frozen. *)
val update_mut : id:Transient.t -> key -> f:('a option -> 'a option) -> 'a t -> 'a t
(** Same as {!update} but with mutability
@raise Transient.Frozen if [id] is frozen *)
(** Same as {!update} but with mutability.
@raise Transient.Frozen if [id] is frozen. *)
val cardinal : _ t -> int
val choose : 'a t -> (key * 'a) option
val choose_exn : 'a t -> key * 'a
(** @raise Not_found if not pair was found *)
(** @raise Not_found if not pair was found. *)
val iter : f:(key -> 'a -> unit) -> 'a t -> unit
@ -114,14 +114,14 @@ module type S = sig
val add_list : 'a t -> (key * 'a) list -> 'a t
val add_list_mut : id:Transient.t -> 'a t -> (key * 'a) list -> 'a t
(** @raise Frozen if the ID is frozen *)
(** @raise Frozen if the ID is frozen. *)
val of_list : (key * 'a) list -> 'a t
val add_seq : 'a t -> (key * 'a) sequence -> 'a t
val add_seq_mut : id:Transient.t -> 'a t -> (key * 'a) sequence -> 'a t
(** @raise Frozen if the ID is frozen *)
(** @raise Frozen if the ID is frozen. *)
val of_seq : (key * 'a) sequence -> 'a t
@ -130,7 +130,7 @@ module type S = sig
val add_gen : 'a t -> (key * 'a) gen -> 'a t
val add_gen_mut : id:Transient.t -> 'a t -> (key * 'a) gen -> 'a t
(** @raise Frozen if the ID is frozen *)
(** @raise Frozen if the ID is frozen. *)
val of_gen : (key * 'a) gen -> 'a t
@ -139,12 +139,13 @@ module type S = sig
(** {6 IO} *)
val pp : key printer -> 'a printer -> 'a t printer
(** Renamed from [val print] @since NEXT_RELEASE *)
(** Renamed from [val print].
@since NEXT_RELEASE *)
val as_tree : 'a t -> [`L of int * (key * 'a) list | `N ] ktree
(** For debugging purpose: explore the structure of the tree,
with [`L (h,l)] being a leaf (with shared hash [h])
and [`N] an inner node *)
and [`N] an inner node. *)
end
(** {2 Type for keys} *)

6
src/data/CCHet.mli
View file

@ -17,7 +17,7 @@ module Key : sig
val create : unit -> 'a t
val equal : 'a t -> 'a t -> bool
(** Compare two keys that have compatible types *)
(** Compare two keys that have compatible types. *)
end
type pair =
@ -38,7 +38,7 @@ module Tbl : sig
val find : t -> 'a Key.t -> 'a option
val find_exn : t -> 'a Key.t -> 'a
(** @raise Not_found if the key is not in the table *)
(** @raise Not_found if the key is not in the table. *)
val iter : (pair -> unit) -> t -> unit
@ -72,7 +72,7 @@ module Map : sig
val find : 'a Key.t -> t -> 'a option
val find_exn : 'a Key.t -> t -> 'a
(** @raise Not_found if the key is not in the table *)
(** @raise Not_found if the key is not in the table. *)
val iter : (pair -> unit) -> t -> unit

8
src/data/CCImmutArray.mli
View file

@ -24,17 +24,17 @@ val singleton : 'a -> 'a t
val doubleton : 'a -> 'a -> 'a t
val make : int -> 'a -> 'a t
(** [make n x] makes an array of [n] times [x] *)
(** [make n x] makes an array of [n] times [x]. *)
val init : int -> (int -> 'a) -> 'a t
(** [init n f] makes the array [[| f 0; f 1; ... ; f (n-1) |]].
@raise Invalid_argument if [n < 0] *)
@raise Invalid_argument if [n < 0]. *)
val get : 'a t -> int -> 'a
(** Access the element *)
(** Access the element. *)
val set : 'a t -> int -> 'a -> 'a t
(** Copy the array and modify its copy *)
(** Copy the array and modify its copy. *)
val sub : 'a t -> int -> int -> 'a t
(** [sub a start len] returns a fresh array of length len, containing the elements

12
src/data/CCIntMap.mli
View file

@ -19,8 +19,8 @@ val mem : int -> _ t -> bool
val find : int -> 'a t -> 'a option
val find_exn : int -> 'a t -> 'a
(** Same as {!find} but unsafe
@raise Not_found if key not present *)
(** Same as {!find} but unsafe.
@raise Not_found if key is not present. *)
val add : int -> 'a -> 'a t -> 'a t
@ -28,17 +28,17 @@ val remove : int -> 'a t -> 'a t
val equal : eq:('a -> 'a -> bool) -> 'a t -> 'a t -> bool
(** [equal ~eq a b] checks whether [a] and [b] have the same set of pairs
(key, value), comparing values with [eq]
(key, value), comparing values with [eq].
@since 0.13 *)
val compare : cmp:('a -> 'a -> int) -> 'a t -> 'a t -> int
(** Total order between maps; the precise order is unspecified .
(** Total order between maps; the precise order is unspecified.
@since 0.13 *)
val update : int -> ('a option -> 'a option) -> 'a t -> 'a t
val cardinal : _ t -> int
(** Number of bindings in the map. Linear time *)
(** Number of bindings in the map. Linear time. *)
val iter : (int -> 'a -> unit) -> 'a t -> unit
@ -53,7 +53,7 @@ val map : ('a -> 'b) -> 'a t -> 'b t
val choose : 'a t -> (int * 'a) option
val choose_exn : 'a t -> int * 'a
(** @raise Not_found if not pair was found *)
(** @raise Not_found if not pair was found. *)
val union : (int -> 'a -> 'a -> 'a) -> 'a t -> 'a t -> 'a t

26
src/data/CCMixmap.mli
View file

@ -37,9 +37,9 @@ type 'a injection
val create_inj : unit -> 'a injection
(** Return a value that works for a given type of values. This function is
normally called once for each type of value. Several keys may be
normally called once for each type of value. Several keys may be
created for the same type, but a value set with a given setter can only be
retrieved with the matching getter. The same key can be reused
retrieved with the matching getter. The same key can be reused
across multiple maps (although not in a thread-safe way). *)
module type S = sig
@ -49,50 +49,50 @@ module type S = sig
(** A map containing values of different types, indexed by {!key}. *)
val empty : t
(** Empty map *)
(** Empty map. *)
val get : inj:'a injection -> key -> t -> 'a option
(** Get the value corresponding to this key, if it exists and
belongs to the same key *)
belongs to the same key. *)
val add : inj:'a injection -> key -> 'a -> t -> t
(** Bind the key to the value, using [inj] *)
(** Bind the key to the value, using [inj]. *)
val find : inj:'a injection -> key -> t -> 'a
(** Find the value for the given key, which must be of the right type.
@raise Not_found if either the key is not found, or if its value
doesn't belong to the right type *)
doesn't belong to the right type. *)
val cardinal : t -> int
(** Number of bindings *)
(** Number of bindings. *)
val remove : key -> t -> t
(** Remove the binding for this key *)
(** Remove the binding for this key. *)
val mem : inj:_ injection-> key -> t -> bool
(** Is the given key in the map, with the right type? *)
val iter_keys : f:(key -> unit) -> t -> unit
(** Iterate on the keys of this map *)
(** Iterate on the keys of this map. *)
val fold_keys : f:('a -> key -> 'a) -> x:'a -> t -> 'a
(** Fold over the keys *)
(** Fold over the keys. *)
(** {2 Iterators} *)
type 'a sequence = ('a -> unit) -> unit
val keys_seq : t -> key sequence
(** All the keys *)
(** All the keys. *)
val bindings_of : inj:'a injection -> t -> (key * 'a) sequence
(** All the bindings that come from the corresponding injection *)
(** All the bindings that come from the corresponding injection. *)
type value =
| Value : ('a injection -> 'a option) -> value
val bindings : t -> (key * value) sequence
(** Iterate on all bindings *)
(** Iterate on all bindings. *)
end
module type ORD = sig

6
src/data/CCMixset.mli
View file

@ -45,8 +45,8 @@ val get : key:'a key -> t -> 'a option
(** [get ~key set] obtains the value for [key] in [set], if any. *)
val get_exn : key:'a key -> t -> 'a
(** Same as {!get}, but can fail
@raise Not_found if the key is not present *)
(** Same as {!get}, but can fail.
@raise Not_found if the key is not present. *)
val cardinal : t -> int
(** Number of mappings *)
(** Number of mappings. *)

24
src/data/CCMixtbl.mli
View file

@ -53,49 +53,49 @@ val create_inj : unit -> 'b injection
val get : inj:'b injection -> 'a t -> 'a -> 'b option
(** Get the value corresponding to this key, if it exists and
belongs to the same key *)
belongs to the same key. *)
val set : inj:'b injection -> 'a t -> 'a -> 'b -> unit
(** Bind the key to the value, using [inj] *)
(** Bind the key to the value, using [inj]. *)
val find : inj:'b injection -> 'a t -> 'a -> 'b
(** Find the value for the given key, which must be of the right type.
@raise Not_found if either the key is not found, or if its value
doesn't belong to the right type *)
doesn't belong to the right type. *)
val length : 'a t -> int
(** Number of bindings *)
(** Number of bindings. *)
val clear : 'a t -> unit
(** Clear content of the hashtable *)
(** Clear content of the hashtable. *)
val remove : 'a t -> 'a -> unit
(** Remove the binding for this key *)
(** Remove the binding for this key. *)
val copy : 'a t -> 'a t
(** Copy of the table *)
(** Copy of the table. *)
val mem : inj:_ injection-> 'a t -> 'a -> bool
(** Is the given key in the table, with the right type? *)
val iter_keys : 'a t -> ('a -> unit) -> unit
(** Iterate on the keys of this table *)
(** Iterate on the keys of this table. *)
val fold_keys : 'a t -> 'b -> ('b -> 'a -> 'b) -> 'b
(** Fold over the keys *)
(** Fold over the keys. *)
(** {2 Iterators} *)
type 'a sequence = ('a -> unit) -> unit
val keys_seq : 'a t -> 'a sequence
(** All the keys *)
(** All the keys. *)
val bindings_of : inj:'b injection -> 'a t -> ('a * 'b) sequence
(** All the bindings that come from the corresponding injection *)
(** All the bindings that come from the corresponding injection. *)
type value =
| Value : ('b injection -> 'b option) -> value
val bindings : 'a t -> ('a * value) sequence
(** Iterate on all bindings *)
(** Iterate on all bindings. *)

25
src/data/CCMultiMap.ml
View file

@ -1,27 +1,4 @@
(*
copyright (c) 2013, simon cruanes
all rights reserved.
redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer. redistributions in binary
form must reproduce the above copyright notice, this list of conditions and the
following disclaimer in the documentation and/or other materials provided with
the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*)
(* This file is free software, part of containers. See file "license" for more details. *)
(** {1 Multimap} *)

85
src/data/CCMultiMap.mli
View file

@ -1,27 +1,4 @@
(*
copyright (c) 2013, simon cruanes
all rights reserved.
redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer. redistributions in binary
form must reproduce the above copyright notice, this list of conditions and the
following disclaimer in the documentation and/or other materials provided with
the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*)
(* This file is free software, part of containers. See file "license" for more details. *)
(** {1 Multimap} *)
@ -33,59 +10,59 @@ module type S = sig
type t
val empty : t
(** Empty multimap *)
(** Empty multimap. *)
val is_empty : t -> bool
(** Empty multimap? *)
val add : t -> key -> value -> t
(** Add a key/value binding *)
(** Add a key/value binding. *)
val remove : t -> key -> value -> t
(** Remove the binding *)
(** Remove the binding. *)
val remove_all : t -> key -> t
(** Remove the key from the map *)
(** Remove the key from the map. *)
val mem : t -> key -> bool
(** Is there a binding for this key? *)
val find : t -> key -> value list
(** List of values for this key *)
(** List of values for this key. *)
val find_iter : t -> key -> (value -> unit) -> unit
(** Iterate on bindings for this key *)
(** Iterate on bindings for this key. *)
val count : t -> key -> int
(** Number of bindings for this key *)
(** Number of bindings for this key. *)
val iter : t -> (key -> value -> unit) -> unit
(** Iterate on all key/value *)
(** Iterate on all key/value. *)
val fold : t -> 'a -> ('a -> key -> value -> 'a) -> 'a
(** Fold on all key/value *)
(** Fold on all key/value. *)
val size : t -> int
(** Number of keys *)
(** Number of keys. *)
val union : t -> t -> t
(** Union of multimaps *)
(** Union of multimaps. *)
val inter : t -> t -> t
(** Intersection of multimaps *)
(** Intersection of multimaps. *)
val diff : t -> t -> t
(** Difference of maps, ie bindings of the first that are not
in the second *)
in the second. *)
val equal : t -> t -> bool
(** Same multimap *)
(** Same multimap. *)
val compare : t -> t -> int
(** Total order on multimaps *)
(** Total order on multimaps. *)
val submap : t -> t -> bool
(** [submap m1 m2] is true iff all bindings of [m1] are also in [m2] *)
(** [submap m1 m2] is true iff all bindings of [m1] are also in [m2]. *)
val to_seq : t -> (key * value) sequence
@ -94,7 +71,7 @@ module type S = sig
val keys : t -> key sequence
val values : t -> value sequence
(** Some values may occur several times *)
(** Some values may occur several times. *)
end
module type OrderedType = sig
@ -120,22 +97,22 @@ module type BIDIR = sig
val is_empty : t -> bool
val add : t -> left -> right -> t
(** Add a binding (left,right) *)
(** Add a binding (left,right). *)
val remove : t -> left -> right -> t
(** Remove a specific binding *)
(** Remove a specific binding. *)
val cardinal_left : t -> int
(** Number of distinct left keys *)
(** Number of distinct left keys. *)
val cardinal_right : t -> int
(** Number of distinct right keys *)
(** Number of distinct right keys. *)
val remove_left : t -> left -> t
(** Remove all bindings for the left key *)
(** Remove all bindings for the left key. *)
val remove_right : t -> right -> t
(** Remove all bindings for the right key *)
(** Remove all bindings for the right key. *)
val mem_left : t -> left -> bool
(** Is the left key present in at least one pair? *)
@ -144,25 +121,25 @@ module type BIDIR = sig
(** Is the right key present in at least one pair? *)
val find_left : t -> left -> right sequence
(** Find all bindings for this given left-key *)
(** Find all bindings for this given left-key. *)
val find_right : t -> right -> left sequence
(** Find all bindings for this given right-key *)
(** Find all bindings for this given right-key. *)
val find1_left : t -> left -> right option
(** like {!find_left} but returns at most one value *)
(** Like {!find_left} but returns at most one value. *)
val find1_right : t -> right -> left option
(** like {!find_right} but returns at most one value *)
(** Like {!find_right} but returns at most one value. *)
val fold : ('a -> left -> right -> 'a) -> 'a -> t -> 'a
(** Fold on pairs *)
(** Fold on pairs. *)
val pairs : t -> (left * right) sequence
(** Iterate on pairs *)
(** Iterate on pairs. *)
val add_pairs : t -> (left * right) sequence -> t
(** Add pairs *)
(** Add pairs. *)
val seq_left : t -> left sequence
val seq_right : t -> right sequence

26
src/data/CCMultiSet.mli
View file

@ -24,31 +24,31 @@ module type S = sig
val remove : t -> elt -> t
val add_mult : t -> elt -> int -> t
(** [add_mult set x n] adds [n] occurrences of [x] to [set]
@raise Invalid_argument if [n < 0]
(** [add_mult set x n] adds [n] occurrences of [x] to [set].
@raise Invalid_argument if [n < 0].
@since 0.6 *)
val remove_mult : t -> elt -> int -> t
(** [remove_mult set x n] removes at most [n] occurrences of [x] from [set]
@raise Invalid_argument if [n < 0]
(** [remove_mult set x n] removes at most [n] occurrences of [x] from [set].
@raise Invalid_argument if [n < 0].
@since 0.6 *)
val remove_all : t -> elt -> t
(** [remove_all set x] removes all occurrences of [x] from [set]
(** [remove_all set x] removes all occurrences of [x] from [set].
@since 0.22 *)
val update : t -> elt -> (int -> int) -> t
(** [update set x f] calls [f n] where [n] is the current multiplicity
of [x] in [set] ([0] to indicate its absence); the result of [f n]
is the new multiplicity of [x].
@raise Invalid_argument if [f n < 0]
@raise Invalid_argument if [f n < 0].
@since 0.6 *)
val min : t -> elt
(** Minimal element w.r.t the total ordering on elements *)
(** Minimal element w.r.t the total ordering on elements. *)
val max : t -> elt
(** Maximal element w.r.t the total ordering on elements *)
(** Maximal element w.r.t the total ordering on elements. *)
val union : t -> t -> t
(** [union a b] contains as many occurrences of an element [x]
@ -56,25 +56,25 @@ module type S = sig
val meet : t -> t -> t
(** [meet a b] is a multiset such that
[count (meet a b) x = max (count a x) (count b x)] *)
[count (meet a b) x = max (count a x) (count b x)]. *)
val intersection : t -> t -> t
(** [intersection a b] is a multiset such that
[count (intersection a b) x = min (count a x) (count b x)] *)
[count (intersection a b) x = min (count a x) (count b x)]. *)
val diff : t -> t -> t
(** MultiSet difference.
[count (diff a b) x = max (count a x - count b x) 0] *)
[count (diff a b) x = max (count a x - count b x) 0]. *)
val contains : t -> t -> bool
(** [contains a x = (count m x > 0)] *)
(** [contains a x = (count m x > 0)]. *)
val compare : t -> t -> int
val equal : t -> t -> bool
val cardinal : t -> int
(** Number of distinct elements *)
(** Number of distinct elements. *)
val iter : t -> (int -> elt -> unit) -> unit

22
src/data/CCPersistentArray.mli
View file

@ -43,24 +43,24 @@ val make : int -> 'a -> 'a t
array entries will modify all other entries at the same time.
@raise Invalid_argument if [n < 0] or [n > Sys.max_array_length].
If the value of x is a floating-point number, then the maximum size is
only [Sys.max_array_length / 2].*)
only [Sys.max_array_length / 2]. *)
val init : int -> (int -> 'a) -> 'a t
(** [make n f] returns a persistent array of length n, with element
(** [init n f] returns a persistent array of length n, with element
[i] initialized to the result of [f i].
@raise Invalid_argument if [n < 0] or [n > Sys.max_array_length].
If the value of x is a floating-point number, then the maximum size is
only [Sys.max_array_length / 2].*)
only [Sys.max_array_length / 2]. *)
val get : 'a t -> int -> 'a
(** [get a i] returns the element with index [i] from the array [a].
@raise Invalid_argument "index out of bounds" if [n] is outside the
range [0] to [Array.length a - 1].*)
range [0] to [Array.length a - 1]. *)
val set : 'a t -> int -> 'a -> 'a t
(** [set a i v] sets the element index [i] from the array [a] to [v].
@raise Invalid_argument "index out of bounds" if [n] is outside the
range [0] to [Array.length a - 1].*)
range [0] to [Array.length a - 1]. *)
val length : 'a t -> int
(** Returns the length of the persistent array. *)
@ -76,31 +76,31 @@ val mapi : (int -> 'a -> 'b) -> 'a t -> 'b t
It is equivalent to [fun f t -> init (fun i -> f (get t i))]. *)
val iter : ('a -> unit) -> 'a t -> unit
val iteri : (int -> 'a -> unit) -> 'a t -> unit
(** [iter f t] applies function [f] to all elements of the persistent array,
in order from element [0] to element [length t - 1]. *)
val iteri : (int -> 'a -> unit) -> 'a t -> unit
val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b t -> 'a
val fold_right : ('a -> 'b -> 'b) -> 'a t -> 'b -> 'b
(** Fold on the elements of the array. *)
val append : 'a t -> 'a t -> 'a t
(** Append the two arrays
(** Append the two arrays.
@since 0.13 *)
val flatten : 'a t t -> 'a t
(** Concatenates all the sub-arrays
(** Concatenates all the sub-arrays.
@since 0.13 *)
val flat_map : ('a -> 'b t) -> 'a t -> 'b t
(** Flat map (map + concatenation)
(** Flat map (map + concatenation).
@since 0.13 *)
val to_array : 'a t -> 'a array
(** [to_array t] returns a mutable copy of [t]. *)
val of_array : 'a array -> 'a t
(** [from_array a] returns an immutable copy of [a]. *)
(** [of_array a] returns an immutable copy of [a]. *)
val to_list : 'a t -> 'a list
(** [to_list t] returns the list of elements in [t]. *)
@ -109,7 +109,7 @@ val of_list : 'a list -> 'a t
(** [of_list l] returns a fresh persistent array containing the elements of [l]. *)
val of_rev_list : 'a list -> 'a t
(** [of_rev_list l] is the same as [of_list (List.rev l)] but more efficient
(** [of_rev_list l] is the same as [of_list (List.rev l)] but more efficient.
@since 0.13 *)
(** {2 Conversions} *)

28
src/data/CCPersistentHashtbl.mli
View file

@ -27,29 +27,29 @@ module type S = sig
type 'a t
val empty : unit -> 'a t
(** Empty table. The table will be allocated at the first binding *)
(** Empty table. The table will be allocated at the first binding. *)
val create : int -> 'a t
(** Create a new hashtable, with the given initial capacity *)
(** Create a new hashtable, with the given initial capacity. *)
val is_empty : 'a t -> bool
(** Is the table empty? *)
val find : 'a t -> key -> 'a
(** Find the value for this key, or fails
@raise Not_found if the key is not present in the table *)
(** Find the value for this key, or fails.
@raise Not_found if the key is not present in the table. *)
val get_exn : key -> 'a t -> 'a
(** Synonym to {!find} with flipped arguments *)
(** Synonym to {!find} with flipped arguments. *)
val get : key -> 'a t -> 'a option
(** Safe version of !{get_exn} *)
(** Safe version of !{get_exn}. *)
val mem : 'a t -> key -> bool
(** Is the key bound? *)
val length : _ t -> int
(** Number of bindings *)
(** Number of bindings. *)
val add : 'a t -> key -> 'a -> 'a t
(** Add the binding to the table, returning a new table. The old binding
@ -67,11 +67,11 @@ module type S = sig
[key] is removed, else it returns [Some v'] and [key -> v'] is added. *)
val remove : 'a t -> key -> 'a t
(** Remove the key *)
(** Remove the key. *)
val copy : 'a t -> 'a t
(** Fresh copy of the table; the underlying structure is not shared
anymore, so using both tables alternatively will be efficient *)
anymore, so using both tables alternatively will be efficient. *)
val merge :
f:(key -> [`Left of 'a | `Right of 'b | `Both of 'a * 'b] -> 'c option) ->
@ -81,13 +81,13 @@ module type S = sig
function returns [None] the key will not appear in the result. *)
val iter : 'a t -> (key -> 'a -> unit) -> unit
(** Iterate over bindings *)
(** Iterate over bindings. *)
val fold : ('b -> key -> 'a -> 'b) -> 'b -> 'a t -> 'b
(** Fold over bindings *)
(** Fold over bindings. *)
val map : (key -> 'a -> 'b) -> 'a t -> 'b t
(** Map all values *)
(** Map all values. *)
val filter : (key -> 'a -> bool) -> 'a t -> 'a t
@ -100,7 +100,7 @@ module type S = sig
(** {3 Conversions} *)
val of_seq : (key * 'a) sequence -> 'a t
(** Add (replace) bindings from the sequence to the table *)
(** Add (replace) bindings from the sequence to the table. *)
val of_list : (key * 'a) list -> 'a t
@ -109,7 +109,7 @@ module type S = sig
val add_list : 'a t -> (key * 'a) list -> 'a t
val to_seq : 'a t -> (key * 'a) sequence
(** Sequence of the bindings of the table *)
(** Sequence of the bindings of the table. *)
val to_list : 'a t -> (key * 'a) list

62
src/data/CCRAL.mli
View file

@ -18,50 +18,50 @@ type +'a t
(** List containing elements of type 'a *)
val empty : 'a t
(** Empty list *)
(** Empty list. *)
val is_empty : _ t -> bool
(** Check whether the list is empty *)
(** Check whether the list is empty. *)
val cons : 'a -> 'a t -> 'a t
(** Add an element at the front of the list *)
(** Add an element at the front of the list. *)
val return : 'a -> 'a t
(** Singleton *)
(** Singleton. *)
val map : f:('a -> 'b) -> 'a t -> 'b t
(** Map on elements *)
(** Map on elements. *)
val mapi : f:(int -> 'a -> 'b) -> 'a t -> 'b t
(** Map with index *)
(** Map with index. *)
val hd : 'a t -> 'a
(** First element of the list, or
@raise Invalid_argument if the list is empty *)
@raise Invalid_argument if the list is empty. *)
val tl : 'a t -> 'a t
(** Remove the first element from the list, or
@raise Invalid_argument if the list is empty *)
@raise Invalid_argument if the list is empty. *)
val front : 'a t -> ('a * 'a t) option
(** Remove and return the first element of the list *)
(** Remove and return the first element of the list. *)
val front_exn : 'a t -> 'a * 'a t
(** Unsafe version of {!front}.
@raise Invalid_argument if the list is empty *)
@raise Invalid_argument if the list is empty. *)
val length : 'a t -> int
(** Number of elements. Complexity O(ln n) where n=number of elements *)
(** Number of elements. Complexity [O(ln n)] where n=number of elements. *)
val get : 'a t -> int -> 'a option
(** [get l i] accesses the [i]-th element of the list. O(log(n)). *)
(** [get l i] accesses the [i]-th element of the list. [O(log(n))]. *)
val get_exn : 'a t -> int -> 'a
(** Unsafe version of {!get}
(** Unsafe version of {!get}.
@raise Invalid_argument if the list has less than [i+1] elements. *)
val set : 'a t -> int -> 'a -> 'a t
(** [set l i v] sets the [i]-th element of the list to [v]. O(log(n)).
(** [set l i v] sets the [i]-th element of the list to [v]. [O(log(n))].
@raise Invalid_argument if the list has less than [i+1] elements. *)
val remove : 'a t -> int -> 'a t
@ -90,39 +90,39 @@ val drop_while : f:('a -> bool) -> 'a t -> 'a t
val take_drop : int -> 'a t -> 'a t * 'a t
(** [take_drop n l] splits [l] into [a, b] such that [length a = n]
if [length l >= n], and such that [append a b = l] *)
if [length l >= n], and such that [append a b = l]. *)
val iter : f:('a -> unit) -> 'a t -> unit
(** Iterate on the list's elements *)
(** Iterate on the list's elements. *)
val iteri : f:(int -> 'a -> unit) -> 'a t -> unit
val fold : f:('b -> 'a -> 'b) -> x:'b -> 'a t -> 'b
(** Fold on the list's elements *)
(** Fold on the list's elements. *)
val fold_rev : f:('b -> 'a -> 'b) -> x:'b -> 'a t -> 'b
(** Fold on the list's elements, in reverse order (starting from the tail) *)
(** Fold on the list's elements, in reverse order (starting from the tail). *)
val rev_map : f:('a -> 'b) -> 'a t -> 'b t
(** [rev_map f l] is the same as [map f (rev l)] *)
(** [rev_map f l] is the same as [map f (rev l)]. *)
val rev : 'a t -> 'a t
(** Reverse the list *)
(** Reverse the list. *)
val equal : eq:('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val compare : cmp:('a -> 'a -> int) -> 'a t -> 'a t -> int
(** Lexicographic comparison *)
(** Lexicographic comparison. *)
(** {2 Utils} *)
val make : int -> 'a -> 'a t
val repeat : int -> 'a t -> 'a t
(** [repeat n l] is [append l (append l ... l)] [n] times *)
(** [repeat n l] is [append l (append l ... l)] [n] times. *)
val range : int -> int -> int t
(** [range i j] is [i; i+1; ... ; j] or [j; j-1; ...; i] *)
(** [range i j] is [i; i+1; ... ; j] or [j; j-1; ...; i]. *)
(** {2 Conversions} *)
@ -132,19 +132,19 @@ type 'a gen = unit -> 'a option
val add_list : 'a t -> 'a list -> 'a t
val of_list : 'a list -> 'a t
(** Convert a list to a RAL. {b Caution}: non tail-rec *)
(** Convert a list to a RAL. {b Caution}: non tail-rec. *)
val to_list : 'a t -> 'a list
val of_list_map : f:('a -> 'b) -> 'a list -> 'b t
(** Combination of {!of_list} and {!map} *)
(** Combination of {!of_list} and {!map}. *)
val of_array : 'a array -> 'a t
val add_array : 'a t -> 'a array -> 'a t
val to_array : 'a t -> 'a array
(** More efficient than on usual lists *)
(** More efficient than on usual lists. *)
val add_seq : 'a t -> 'a sequence -> 'a t
@ -162,22 +162,22 @@ val to_gen : 'a t -> 'a gen
module Infix : sig
val (@+) : 'a -> 'a t -> 'a t
(** Cons (alias to {!cons}) *)
(** Cons (alias to {!cons}). *)
val (>>=) : 'a t -> ('a -> 'b t) -> 'b t
(** Alias to {!flat_map} *)
(** Alias to {!flat_map}. *)
val (>|=) : 'a t -> ('a -> 'b) -> 'b t
(** Alias to {!map} *)
(** Alias to {!map}. *)
val (<*>) : ('a -> 'b) t -> 'a t -> 'b t
(** Alias to {!app} *)
val (--) : int -> int -> int t
(** Alias to {!range} *)
(** Alias to {!range}. *)
val (--^) : int -> int -> int t
(** [a -- b] is the integer range from [a] to [b], where [b] is excluded.
(** [a --^ b] is the integer range from [a] to [b], where [b] is excluded.
@since 0.17 *)
end

36
src/data/CCRingBuffer.mli
View file

@ -28,31 +28,31 @@ module Array : sig
type t
val create : int -> t
(** Make an array of the given size, filled with dummy elements *)
(** Make an array of the given size, filled with dummy elements. *)
val length: t -> int
(** [length t] gets the total number of elements currently in [t] *)
(** [length t] gets the total number of elements currently in [t]. *)
val get: t -> int -> elt
(** [get t i] gets the element at position [i] *)
(** [get t i] gets the element at position [i]. *)
val set: t -> int -> elt -> unit
(** [set t i e] sets the element at position [i] to [e] *)
(** [set t i e] sets the element at position [i] to [e]. *)
val sub: t -> int -> int -> t
(** [sub t i len] gets the subarray of [t] from
position [i] to [i + len] *)
(** [sub t i len] gets the sub-array of [t] from
position [i] to [i + len]. *)
val copy : t -> t
(** [copy t] makes a fresh copy of the array [t] *)
(** [copy t] makes a fresh copy of the array [t]. *)
val blit : t -> int -> t -> int -> int -> unit
(** [blit t s arr i len] copies [len] elements from [arr] starting at [i]
to position [s] from [t] *)
to position [s] from [t]. *)
val iter : (elt -> unit) -> t -> unit
(** [iter f t] iterates over the array [t] invoking [f] with
the current element, in array order *)
the current element, in array order. *)
end
(** Efficient array version for the [char] type *)
@ -82,7 +82,7 @@ module type S = sig
(** [create size] creates a new bounded buffer with given size.
The underlying array is allocated immediately and no further (large)
allocation will happen from now on.
@raise Invalid_argument if the arguments is [< 1] *)
@raise Invalid_argument if the arguments is [< 1]. *)
val copy : t -> t
(** Make a fresh copy of the buffer. *)
@ -102,7 +102,7 @@ module type S = sig
a input buffer [from_buf] to the end of the buffer.
If the slice is too large for the buffer, only the last part of the array
will be copied.
@raise Invalid_argument if [o,len] is not a valid slice of [s] *)
@raise Invalid_argument if [o,len] is not a valid slice of [s]. *)
val blit_into : t -> Array.t -> int -> int -> int
(** [blit_into buf to_buf o len] copies at most [len] elements from [buf]
@ -115,7 +115,7 @@ module type S = sig
end of [into]. Erases data of [into] if there is not enough room. *)
val to_list : t -> Array.elt list
(** Extract the current content into a list *)
(** Extract the current content into a list. *)
val clear : t -> unit
(** Clear the content of the buffer. Doesn't actually destroy the content. *)
@ -136,7 +136,7 @@ module type S = sig
@raise Invalid_argument if [len > length b]. *)
val iter : t -> f:(Array.elt -> unit) -> unit
(** [iter b ~f] calls [f i t] for each element [t] in [buf] *)
(** [iter b ~f] calls [f i t] for each element [t] in [buf]. *)
val iteri : t -> f:(int -> Array.elt -> unit) -> unit
(** [iteri b ~f] calls [f i t] for each element [t] in [buf], with [i]
@ -145,12 +145,12 @@ module type S = sig
val get_front : t -> int -> Array.elt
(** [get_front buf i] returns the [i]-th element of [buf] from the front, ie
the one returned by [take_front buf] after [i-1] calls to [junk_front buf].
@raise Invalid_argument if the index is invalid (> [length buf]) *)
@raise Invalid_argument if the index is invalid (> [length buf]). *)
val get_back : t -> int -> Array.elt
(** [get_back buf i] returns the [i]-th element of [buf] from the back, ie
the one returned by [take_back buf] after [i-1] calls to [junk_back buf].
@raise Invalid_argument if the index is invalid (> [length buf]) *)
@raise Invalid_argument if the index is invalid (> [length buf]). *)
val push_back : t -> Array.elt -> unit
(** Push value at the back of [t].
@ -174,14 +174,14 @@ module type S = sig
@since 1.3 *)
val take_back : t -> Array.elt option
(** Take and remove the last value from back of [t], if any *)
(** Take and remove the last value from back of [t], if any. *)
val take_back_exn : t -> Array.elt
(** Take and remove the last value from back of [t].
@raise Empty if buffer is already empty. *)
val take_front : t -> Array.elt option
(** Take and remove the first value from front of [t], if any *)
(** Take and remove the first value from front of [t], if any. *)
val take_front_exn : t -> Array.elt
(** Take and remove the first value from front of [t].
@ -189,7 +189,7 @@ module type S = sig
val of_array : Array.t -> t
(** Create a buffer from an initial array, but doesn't take ownership
of it (stills allocates a new internal array)
of it (still allocates a new internal array).
@since 0.11 *)
val to_array : t -> Array.t

22
src/data/CCSimple_queue.mli
View file

@ -19,24 +19,24 @@ val empty : 'a t
val is_empty : 'a t -> bool
val push : 'a -> 'a t -> 'a t
(** Push element at the end of the queue *)
(** Push element at the end of the queue. *)
val snoc : 'a t -> 'a -> 'a t
(** Flip version of {!push} *)
(** Flip version of {!push}. *)
val peek : 'a t -> 'a option
(** First element of the queue *)
(** First element of the queue. *)
val peek_exn : 'a t -> 'a
(** Same as {!peek} but
@raise Invalid_argument if the queue is empty *)
@raise Invalid_argument if the queue is empty. *)
val pop : 'a t -> ('a * 'a t) option
(** Get and remove the first element *)
(** Get and remove the first element. *)
val pop_exn : 'a t -> ('a * 'a t)
(** Same as {!pop}, but fails on empty queues.
@raise Invalid_argument if the queue is empty *)
@raise Invalid_argument if the queue is empty. *)
val junk : 'a t -> 'a t
(** Remove first element. If the queue is empty, do nothing. *)
@ -47,7 +47,7 @@ val append : 'a t -> 'a t -> 'a t
Linear in the size of the second queue. *)
val map : ('a -> 'b) -> 'a t -> 'b t
(** Map values *)
(** Map values. *)
val rev : 'a t -> 'a t
(** Reverse the queue. Constant time. *)
@ -55,15 +55,15 @@ val rev : 'a t -> 'a t
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
module Infix : sig
val (>|=) : 'a t -> ('a -> 'b) -> 'b t (** Alias to {!map} *)
val (@) : 'a t -> 'a t -> 'a t (** Alias to {!append} *)
val (<::) : 'a t -> 'a -> 'a t (** Alias to {!snoc} *)
val (>|=) : 'a t -> ('a -> 'b) -> 'b t (** Alias to {!map}. *)
val (@) : 'a t -> 'a t -> 'a t (** Alias to {!append}. *)
val (<::) : 'a t -> 'a -> 'a t (** Alias to {!snoc}. *)
end
include module type of Infix
val length : 'a t -> int
(** Number of elements in the queue (linear in time) *)
(** Number of elements in the queue (linear in time). *)
val fold : ('b -> 'a -> 'b) -> 'b -> 'a t -> 'b

24
src/data/CCTrie.mli
View file

@ -32,17 +32,17 @@ module type S = sig
val is_empty : _ t -> bool
val add : key -> 'a -> 'a t -> 'a t
(** Add a binding to the trie (possibly erasing the previous one) *)
(** Add a binding to the trie (possibly erasing the previous one). *)
val remove : key -> 'a t -> 'a t
(** Remove the key, if present *)
(** Remove the key, if present. *)
val find : key -> 'a t -> 'a option
(** Find the value associated with the key, if any *)
(** Find the value associated with the key, if any. *)
val find_exn : key -> 'a t -> 'a
(** Same as {!find} but can fail.
@raise Not_found if the key is not present *)
@raise Not_found if the key is not present. *)
val longest_prefix : key -> 'a t -> key
(** [longest_prefix k m] finds the longest prefix of [k] that leads to
@ -50,7 +50,7 @@ module type S = sig
a value.
Example: if [m] has keys "abc0" and "abcd", then [longest_prefix "abc2" m]
will return "abc"
will return "abc".
@since 0.17 *)
@ -58,7 +58,7 @@ module type S = sig
(** Update the binding for the given key. The function is given
[None] if the key is absent, or [Some v] if [key] is bound to [v];
if it returns [None] the key is removed, otherwise it
returns [Some y] and [key] becomes bound to [y] *)
returns [Some y] and [key] becomes bound to [y]. *)
val fold : ('b -> key -> 'a -> 'b) -> 'b -> 'a t -> 'b
(** Fold on key/value bindings. Will use {!WORD.of_list} to rebuild keys. *)
@ -72,19 +72,19 @@ module type S = sig
@since 0.17 *)
val iter : (key -> 'a -> unit) -> 'a t -> unit
(** Same as {!fold}, but for effectful functions *)
(** Same as {!fold}, but for effectful functions. *)
val fold_values : ('b -> 'a -> 'b) -> 'b -> 'a t -> 'b
(** More efficient version of {!fold}, that doesn't keep keys *)
(** More efficient version of {!fold}, that doesn't keep keys. *)
val iter_values : ('a -> unit) -> 'a t -> unit
val merge : ('a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
(** Merge two tries together. The function is used in
case of conflicts, when a key belongs to both tries *)
case of conflicts, when a key belongs to both tries. *)
val size : _ t -> int
(** Number of bindings *)
(** Number of bindings. *)
(** {6 Conversions} *)
@ -104,11 +104,11 @@ module type S = sig
val above : key -> 'a t -> (key * 'a) sequence
(** All bindings whose key is bigger or equal to the given key, in
ascending order *)
ascending order. *)
val below : key -> 'a t -> (key * 'a) sequence
(** All bindings whose key is smaller or equal to the given key,
in decreasing order *)
in decreasing order. *)
(**/**)
val check_invariants: _ t -> bool

25
src/data/CCWBTree.mli
View file

@ -38,14 +38,14 @@ module type S = sig
val get : key -> 'a t -> 'a option
val get_exn : key -> 'a t -> 'a
(** @raise Not_found if the key is not present *)
(** @raise Not_found if the key is not present. *)
val nth : int -> 'a t -> (key * 'a) option
(** [nth i m] returns the [i]-th [key, value] in the ascending
order. Complexity is [O(log (cardinal m))] *)
order. Complexity is [O(log (cardinal m))]. *)
val nth_exn : int -> 'a t -> key * 'a
(** @raise Not_found if the index is invalid *)
(** @raise Not_found if the index is invalid. *)
val get_rank : key -> 'a t -> [`At of int | `After of int | `First]
(** [get_rank k m] looks for the rank of [k] in [m], i.e. the index
@ -60,7 +60,7 @@ module type S = sig
val update : key -> ('a option -> 'a option) -> 'a t -> 'a t
(** [update k f m] calls [f (Some v)] if [get k m = Some v], [f None]
otherwise. Then, if [f] returns [Some v'] it binds [k] to [v'],
if [f] returns [None] it removes [k] *)
if [f] returns [None] it removes [k]. *)
val cardinal : _ t -> int
@ -83,30 +83,30 @@ module type S = sig
val split : key -> 'a t -> 'a t * 'a option * 'a t
(** [split k t] returns [l, o, r] where [l] is the part of the map
with keys smaller than [k], [r] has keys bigger than [k],
and [o = Some v] if [k, v] belonged to the map *)
and [o = Some v] if [k, v] belonged to the map. *)
val merge : f:(key -> 'a option -> 'b option -> 'c option) -> 'a t -> 'b t -> 'c t
(** Similar to {!Map.S.merge} *)
(** Similar to {!Map.S.merge}. *)
val extract_min : 'a t -> key * 'a * 'a t
(** [extract_min m] returns [k, v, m'] where [k,v] is the pair with the
smallest key in [m], and [m'] does not contain [k].
@raise Not_found if the map is empty *)
@raise Not_found if the map is empty. *)
val extract_max : 'a t -> key * 'a * 'a t
(** [extract_max m] returns [k, v, m'] where [k,v] is the pair with the
highest key in [m], and [m'] does not contain [k].
@raise Not_found if the map is empty *)
@raise Not_found if the map is empty. *)
val choose : 'a t -> (key * 'a) option
val choose_exn : 'a t -> key * 'a
(** @raise Not_found if the tree is empty *)
(** @raise Not_found if the tree is empty. *)
val random_choose : Random.State.t -> 'a t -> key * 'a
(** Randomly choose a (key,value) pair within the tree, using weights
as probability weights
@raise Not_found if the tree is empty *)
as probability weights.
@raise Not_found if the tree is empty. *)
val add_list : 'a t -> (key * 'a) list -> 'a t
@ -127,7 +127,8 @@ module type S = sig
val to_gen : 'a t -> (key * 'a) gen
val pp : key printer -> 'a printer -> 'a t printer
(** Renamed from [val print] @since NEXT_RELEASE *)
(** Renamed from [val print].
@since NEXT_RELEASE *)
(**/**)
val node_ : key -> 'a -> 'a t -> 'a t -> 'a t

28
src/data/CCZipper.mli
View file

@ -10,7 +10,7 @@ type 'a t = 'a list * 'a list
with the focus on [r]. *)
val empty : 'a t
(** Empty zipper *)
(** Empty zipper. *)
val is_empty : _ t -> bool
(** Empty zipper? Returns true iff the two lists are empty. *)
@ -22,36 +22,36 @@ val is_empty : _ t -> bool
val to_list : 'a t -> 'a list
(** Convert the zipper back to a list.
[to_list (l,r)] is [List.rev_append l r] *)
[to_list (l,r)] is [List.rev_append l r]. *)
val to_rev_list : 'a t -> 'a list
(** Convert the zipper back to a {i reversed} list.
In other words, [to_list (l,r)] is [List.rev_append r l] *)
In other words, [to_list (l,r)] is [List.rev_append r l]. *)
val make : 'a list -> 'a t
(** Create a zipper pointing at the first element of the list *)
(** Create a zipper pointing at the first element of the list. *)
val left : 'a t -> 'a t
(** Go to the left, or do nothing if the zipper is already at leftmost pos *)
(** Go to the left, or do nothing if the zipper is already at leftmost pos. *)
val left_exn : 'a t -> 'a t
(** Go to the left, or
@raise Invalid_argument if the zipper is already at leftmost pos *)
@raise Invalid_argument if the zipper is already at leftmost pos. *)
val right : 'a t -> 'a t
(** Go to the right, or do nothing if the zipper is already at rightmost pos *)
(** Go to the right, or do nothing if the zipper is already at rightmost pos. *)
val right_exn : 'a t -> 'a t
(** Go to the right, or
@raise Invalid_argument if the zipper is already at rightmost pos *)
@raise Invalid_argument if the zipper is already at rightmost pos. *)
val modify : ('a option -> 'a option) -> 'a t -> 'a t
(** Modify the current element, if any, by returning a new element, or
returning [None] if the element is to be deleted *)
returning [None] if the element is to be deleted. *)
val insert : 'a -> 'a t -> 'a t
(** Insert an element at the current position. If an element was focused,
[insert x l] adds [x] just before it, and focuses on [x] *)
[insert x l] adds [x] just before it, and focuses on [x]. *)
val remove : 'a t -> 'a t
(** [remove l] removes the current element, if any. *)
@ -61,12 +61,12 @@ val is_focused : _ t -> bool
return a [Some v]? *)
val focused : 'a t -> 'a option
(** Returns the focused element, if any. [focused zip = Some _] iff
[empty zip = false] *)
(** Return the focused element, if any. [focused zip = Some _] iff
[empty zip = false]. *)
val focused_exn : 'a t -> 'a
(** Returns the focused element, or
@raise Not_found if the zipper is at an end *)
(** Return the focused element, or
@raise Not_found if the zipper is at an end. *)
val drop_before : 'a t -> 'a t
(** Drop every element on the "left" (calling {!left} then will do nothing). *)

20
src/threads/CCBlockingQueue.mli
View file

@ -15,36 +15,36 @@ val create : int -> 'a t
(** Create a new queue of size [n]. Using [n=max_int] amounts to using
an infinite queue (2^61 items is a lot to fit in memory); using [n=1]
amounts to using a box with 0 or 1 elements inside.
@raise Invalid_argument if [n < 1] *)
@raise Invalid_argument if [n < 1]. *)
val push : 'a t -> 'a -> unit
(** [push q x] pushes [x] into [q], blocking if the queue is full *)
(** [push q x] pushes [x] into [q], blocking if the queue is full. *)
val take : 'a t -> 'a
(** Take the first element, blocking if needed *)
(** Take the first element, blocking if needed. *)
val push_list : 'a t -> 'a list -> unit
(** Push items of the list, one by one *)
(** Push items of the list, one by one. *)
val take_list : 'a t -> int -> 'a list
(** [take_list n q] takes [n] elements out of [q] *)
(** [take_list n q] takes [n] elements out of [q]. *)
val try_take : 'a t -> 'a option
(** Take the first element if the queue is not empty, return [None]
otherwise *)
otherwise. *)
val try_push : 'a t -> 'a -> bool
(** [try_push q x] pushes [x] into [q] if [q] is not full, in which
case it returns [true].
If it fails because [q] is full, it returns [false] *)
If it fails because [q] is full, it returns [false]. *)
val peek : 'a t -> 'a option
(** [peek q] returns [Some x] if [x] is the first element of [q],
otherwise it returns [None] *)
otherwise it returns [None]. *)
val size : _ t -> int
(** Number of elements currently in the queue *)
(** Number of elements currently in the queue. *)
val capacity : _ t -> int
(** Number of values the queue can hold *)
(** Number of values the queue can hold. *)

32
src/threads/CCLock.mli
View file

@ -11,17 +11,17 @@ type 'a t
(** A value surrounded with a lock *)
val create : 'a -> 'a t
(** Create a new protected value *)
(** Create a new protected value. *)
val with_lock : 'a t -> ('a -> 'b) -> 'b
(** [with_lock l f] runs [f x] where [x] is the value protected with
the lock [l], in a critical section. If [f x] fails, [with_lock l f]
fails too but the lock is released *)
fails too but the lock is released. *)
val try_with_lock : 'a t -> ('a -> 'b) -> 'b option
(** [try_with_lock l f] runs [f x] in a critical section if [l] is not
locked. [x] is the value protected by the lock [l]. If [f x]
fails, [try_with_lock l f] fails too but the lock is released
fails, [try_with_lock l f] fails too but the lock is released.
@since 0.22 *)
(** Type allowing to manipulate the lock as a reference
@ -39,56 +39,56 @@ end
val with_lock_as_ref : 'a t -> f:('a LockRef.t -> 'b) -> 'b
(** [with_lock_as_ref l f] calls [f] with a reference-like object
that allows to manipulate the value of [l] safely.
The object passed to [f] must not escape the function call
The object passed to [f] must not escape the function call.
@since 0.13 *)
val update : 'a t -> ('a -> 'a) -> unit
(** [update l f] replaces the content [x] of [l] with [f x], atomically *)
(** [update l f] replaces the content [x] of [l] with [f x], atomically. *)
val update_map : 'a t -> ('a -> 'a * 'b) -> 'b
(** [update_map l f] computes [x', y = f (get l)], then puts [x'] in [l]
and returns [y]
and returns [y].
@since 0.16 *)
val mutex : _ t -> Mutex.t
(** Underlying mutex *)
(** Underlying mutex. *)
val get : 'a t -> 'a
(** Atomically get the value in the lock. The value that is returned
isn't protected! *)
val set : 'a t -> 'a -> unit
(** Atomically set the value
(** Atomically set the value.
@since 0.13 *)
val incr : int t -> unit
(** Atomically increment the value
(** Atomically increment the value.
@since 0.13 *)
val decr : int t -> unit
(** Atomically decrement the value
(** Atomically decrement the value.
@since 0.13 *)
val incr_then_get : int t -> int
(** [incr_then_get x] increments [x], and return its new value
(** [incr_then_get x] increments [x], and returns its new value.
@since 0.16 *)
val get_then_incr : int t -> int
(** [get_then_incr x] increments [x], and return its previous value
(** [get_then_incr x] increments [x], and returns its previous value.
@since 0.16 *)
val decr_then_get : int t -> int
(** [decr_then_get x] decrements [x], and return its new value
(** [decr_then_get x] decrements [x], and returns its new value.
@since 0.16 *)
val get_then_decr : int t -> int
(** [get_then_decr x] decrements [x], and return its previous value
(** [get_then_decr x] decrements [x], and returns its previous value.
@since 0.16 *)
val get_then_set : bool t -> bool
(** [get_then_set b] sets [b] to [true], and return the old value
(** [get_then_set b] sets [b] to [true], and returns the old value.
@since 0.16 *)
val get_then_clear : bool t -> bool
(** [get_then_clear b] sets [b] to [false], and return the old value
(** [get_then_clear b] sets [b] to [false], and returns the old value.
@since 0.16 *)

40
src/threads/CCPool.mli
View file

@ -13,7 +13,7 @@ type +'a state =
module type PARAM = sig
val max_size : int
(** Maximum number of threads in the pool *)
(** Maximum number of threads in the pool. *)
end
exception Stopped
@ -21,10 +21,10 @@ exception Stopped
(** {2 Create a new Pool} *)
module Make(P : PARAM) : sig
val run : (unit -> _) -> unit
(** [run f] schedules [f] for being executed in the thread pool *)
(** [run f] schedules [f] for being executed in the thread pool. *)
val run1 : ('a -> _) -> 'a -> unit
(** [run1 f x] is similar to [run (fun () -> f x)] *)
(** [run1 f x] is similar to [run (fun () -> f x)]. *)
val run2 : ('a -> 'b -> _) -> 'a -> 'b -> unit
@ -33,7 +33,7 @@ module Make(P : PARAM) : sig
val set_exn_handler : (exn -> unit) -> unit
val active : unit -> bool
(** [active ()] is true as long as [stop()] has not been called yet *)
(** [active ()] is true as long as [stop()] has not been called yet. *)
val stop : unit -> unit
(** After calling [stop ()], Most functions will raise Stopped.
@ -52,10 +52,10 @@ module Make(P : PARAM) : sig
(** {2 Constructors} *)
val return : 'a -> 'a t
(** Future that is already computed *)
(** Future that is already computed. *)
val fail : exn -> 'a t
(** Future that fails immediately *)
(** Future that fails immediately. *)
val make : (unit -> 'a) -> 'a t
(** Create a future, representing a value that will be computed by
@ -70,10 +70,10 @@ module Make(P : PARAM) : sig
val get : 'a t -> 'a
(** Blocking get: wait for the future to be evaluated, and get the value,
or the exception that failed the future is returned.
raise e if the future failed with e *)
raise e if the future failed with e. *)
val state : 'a t -> 'a state
(** State of the future *)
(** State of the future. *)
val is_done : 'a t -> bool
(** Is the future evaluated (success/failure)? *)
@ -96,10 +96,10 @@ module Make(P : PARAM) : sig
Might be evaluated now if the future is already done. *)
val flat_map : ('a -> 'b t) -> 'a t -> 'b t
(** Monadic combination of futures *)
(** Monadic combination of futures. *)
val and_then : 'a t -> (unit -> 'b t) -> 'b t
(** Wait for the first future to succeed, then launch the second *)
(** Wait for the first future to succeed, then launch the second. *)
val sequence_a : 'a t array -> 'a array t
(** Future that waits for all previous futures to terminate. If any future
@ -119,25 +119,25 @@ module Make(P : PARAM) : sig
val choose_a : 'a t array -> 'a t
(** Choose among those futures (the first to terminate). Behaves like
the first future that terminates, by failing if the future fails *)
the first future that terminates, by failing if the future fails. *)
val choose_l : 'a t list -> 'a t
(** Choose among those futures (the first to terminate). Behaves like
the first future that terminates, by failing if the future fails *)
the first future that terminates, by failing if the future fails. *)
val map : ('a -> 'b) -> 'a t -> 'b t
(** Maps the value inside the future. The function doesn't run in its
own task; if it can take time, use {!flat_map} or {!map_async} *)
(** Map the value inside the future. The function doesn't run in its
own task; if it can take time, use {!flat_map} or {!map_async}. *)
val map_async : ('a -> 'b) -> 'a t -> 'b t
(** Maps the value inside the future, to be computed in a separated job. *)
(** Map the value inside the future, to be computed in a separated job. *)
val app : ('a -> 'b) t -> 'a t -> 'b t
(** [app f x] applies the result of [f] to the result of [x] *)
(** [app f x] applies the result of [f] to the result of [x]. *)
val app_async : ('a -> 'b) t -> 'a t -> 'b t
(** [app f x] applies the result of [f] to the result of [x], in
a separated job scheduled in the pool *)
(** [app_async f x] applies the result of [f] to the result of [x], in
a separated job scheduled in the pool. *)
val sleep : float -> unit t
(** Future that returns with success in the given amount of seconds. Blocks
@ -156,9 +156,9 @@ module Make(P : PARAM) : sig
val (>>) : 'a t -> (unit -> 'b t) -> 'b t
val (>|=) : 'a t -> ('a -> 'b) -> 'b t
(** Alias to {!map} *)
(** Alias to {!map}. *)
val (<*>): ('a -> 'b) t -> 'a t -> 'b t
(** Alias to {!app} *)
(** Alias to {!app}. *)
end
end

14
src/threads/CCSemaphore.mli
View file

@ -8,23 +8,23 @@ type t
(** A semaphore *)
val create : int -> t
(** [create n] creates a semaphore with initial value [n]
@raise Invalid_argument if [n <= 0] *)
(** [create n] creates a semaphore with initial value [n].
@raise Invalid_argument if [n <= 0]. *)
val get : t -> int
(** Current value *)
(** Current value. *)
val acquire : int -> t -> unit
(** [acquire n s] blocks until [get s >= n], then atomically
sets [s := !s - n] *)
sets [s := !s - n]. *)
val release : int -> t -> unit
(** [release n s] atomically sets [s := !s + n] *)
(** [release n s] atomically sets [s := !s + n]. *)
val with_acquire : n:int -> t -> f:(unit -> 'a) -> 'a
(** [with_acquire ~n s ~f] first acquires [s] with [n] units,
calls [f ()], and then release [s] with [n] units.
Safely release the semaphore even if [f ()] fails *)
calls [f ()], and then releases [s] with [n] units.
Safely release the semaphore even if [f ()] fails. *)
val wait_until_at_least : n:int -> t -> f:(unit -> 'a) -> 'a
(** [wait_until_at_least ~n s ~f] waits until [get s >= n], then calls [f ()]

18
src/threads/CCThread.mli
View file

@ -8,7 +8,7 @@
type t = Thread.t
val spawn : (unit -> _) -> t
(** [spawn f] creates a new thread that runs [f ()] *)
(** [spawn f] creates a new thread that runs [f ()]. *)
val spawn1 : ('a -> _) -> 'a -> t
(** [spawn1 f x] is like [spawn (fun () -> f x)].
@ -19,16 +19,16 @@ val spawn2 : ('a -> 'b -> _) -> 'a -> 'b -> t
@since 0.16 *)
val detach : (unit -> 'a) -> unit
(** [detach f] is the same as [ignore (spawn f)] *)
(** [detach f] is the same as [ignore (spawn f)]. *)
(** {2 Array of threads} *)
module Arr : sig
val spawn : int -> (int -> 'a) -> t array
(** [A.spawn n f] creates an array [res] of length [n], such that
[res.(i) = spawn (fun () -> f i)] *)
(** [Arr.spawn n f] creates an array [res] of length [n], such that
[res.(i) = spawn (fun () -> f i)]. *)
val join : t array -> unit
(** [A.join a] joins every thread in [a] *)
(** [Arr.join a] joins every thread in [a]. *)
end
(** {2 Single-Use Barrier} *)
@ -38,18 +38,18 @@ module Barrier : sig
(** Barrier, used to synchronize threads *)
val create : unit -> t
(** Create a barrier *)
(** Create a barrier. *)
val reset : t -> unit
(** Reset to initial (non-triggered) state *)
(** Reset to initial (non-triggered) state. *)
val wait : t -> unit
(** [wait b] waits for barrier [b] to be activated by [activate b].
All threads calling this wait until [activate b] is called.
If [b] is already activated, [wait b] does nothing *)
If [b] is already activated, [wait b] does nothing. *)
val activate : t -> unit
(** [activate b] unblocks all threads that were waiting on [b] *)
(** [activate b] unblocks all threads that were waiting on [b]. *)
val activated : t -> bool
(** [activated b] returns [true] iff [activate b] was called, and [reset b]

12
src/threads/CCTimer.mli
View file

@ -14,17 +14,17 @@ val create : unit -> t
val set_exn_handler : t -> (exn -> unit) -> unit
(** [set_exn_handler timer f] registers [f] so that any exception
raised by a task scheduled in [timer] is given to [f] *)
raised by a task scheduled in [timer] is given to [f]. *)
exception Stopped
val after : t -> float -> f:(unit -> _) -> unit
(** Call the callback [f] after the given number of seconds.
@raise Stopped if the timer was stopped *)
@raise Stopped if the timer was stopped. *)
val at : t -> float -> f:(unit -> _) -> unit
(** Create a future that evaluates to [()] at the given Unix timestamp
@raise Stopped if the timer was stopped *)
(** Create a future that evaluates to [()] at the given Unix timestamp.
@raise Stopped if the timer was stopped. *)
exception ExitEvery
@ -33,11 +33,11 @@ val every : ?delay:float -> t -> float -> f:(unit -> _) -> unit
[f()] can raise ExitEvery to stop the cycle.
@param delay if provided, the first call to [f ()] is delayed by
that many seconds.
@raise Stopped if the timer was stopped *)
@raise Stopped if the timer was stopped. *)
val stop : t -> unit
(** Stop the given timer, cancelling pending tasks. Idempotent.
From now on, calling most other operations on the timer will raise Stopped. *)
val active : t -> bool
(** Returns [true] until [stop t] has been called. *)
(** Return [true] until [stop t] has been called. *)