module IO:sig..end
val lines_of : ?mode:int -> ?flags:Pervasives.open_flag list -> string -> string Sequence.tlines_of filename reads all lines of the given file. It raises the
+ same exception as would opening the file and read from it, except
+ from End_of_file (which is caught). The file is always properly
+ closed.
+ Every time the sequence is iterated on, the file is opened again, so
+ different iterations might return different resultsmode : default 0o644flags : default: [Open_rdonly]val chunks_of : ?mode:int ->
?flags:Pervasives.open_flag list -> ?size:int -> string -> string Sequence.tsize from the file. The last chunk might be
+ smaller. Behaves like Sequence.IO.lines_of regarding errors and options.
+ Every time the sequence is iterated on, the file is opened again, so
+ different iterations might return different resultsval write_to : ?mode:int ->
?flags:Pervasives.open_flag list -> string -> string Sequence.t -> unitwrite_to filename seq writes all strings from seq into the given
+ file. It takes care of opening and closing the file.mode : default 0o644flags : used by open_out_gen. Default: [Open_creat;Open_wronly].val write_bytes_to : ?mode:int ->
?flags:Pervasives.open_flag list -> string -> Bytes.t Sequence.t -> unitval write_lines : ?mode:int ->
?flags:Pervasives.open_flag list -> string -> string Sequence.t -> unit
+
+val write_bytes_lines : ?mode:int ->
?flags:Pervasives.open_flag list -> string -> Bytes.t Sequence.t -> unit'a. If you give it a func
Sequence of pairs of values of type 'a and 'b.type+ + +'aequal ='a -> 'a -> bool
type+'ahash ='a -> int
val init : (int -> 'a) -> 'a tinit f is the infinite sequence f 0; f 1; f 2; ….val cons : 'a -> 'a t -> 'a tcons x l yields x, then yields from l.
Same as append (singleton x) lval fold_map : ('acc -> 'a -> 'acc * 'b) -> 'acc -> 'a t -> 'b tfold_map f acc l is like Sequence.map, but it carries some state as in
+ Sequence.fold. The state is not returned, it is just used to thread some
+ information to the map function.val fold_filter_map : ('acc -> 'a -> 'acc * 'b option) -> 'acc -> 'a t -> 'b tfold_filter_map f acc l is a Sequence.fold_map-like function, but the
+ function can choose to skip an element by retuning None.val map : ('a -> 'b) -> 'a t -> 'b tN
Since 0.5
+val find_map : ('a -> 'b option) -> 'a t -> 'b option
+
+val findi : (int -> 'a -> 'b option) -> 'a t -> 'b option
+
+val find_mapi : (int -> 'a -> 'b option) -> 'a t -> 'b option
+
+val find_pred : ('a -> bool) -> 'a t -> 'a option
+find_pred p l finds the first element of l that satisfies p,
+ or returns None if no element satisfies p
+Since 0.9
+
+
+val find_pred_exn : ('a -> bool) -> 'a t -> 'a
+
val length : 'a t -> int
How long is the sequence? Forces the sequence.
@@ -235,7 +287,7 @@ Monadic bind. Intuitively, it applies the function to every
val flat_map_l : ('a -> 'b list) -> 'a t -> 'b t
Convenience function combining Sequence.flat_map and Sequence.of_list
-Since NEXT_RELEASE
+Since 0.9
val filter_map : ('a -> 'b option) -> 'a t -> 'b t
@@ -282,6 +334,11 @@ Sort the sequence. Eager, O(n) ram and O(n ln(n)) time.
Sort the sequence and remove duplicates. Eager, same as sort
+val sorted : ?cmp:('a -> 'a -> int) -> 'a t -> bool
+
val group_succ_by : ?eq:('a -> 'a -> bool) -> 'a t -> 'a list t
Group equal consecutive elements.
Formerly synonym to group.
@@ -294,6 +351,12 @@ Group equal elements, disregarding their order of appearance.
Since 0.6
+val count : ?hash:('a -> int) ->
?eq:('a -> 'a -> bool) -> 'a t -> ('a * int) t
+Map each distinct element to its number of occurrences in the whole seq.
+ Similar to group_by seq |> map (fun l->List.hd l, List.length l)
+Since 0.10
+
+
val uniq : ?eq:('a -> 'a -> bool) -> 'a t -> 'a t
Remove consecutive duplicate elements. Basically this is
like fun seq -> map List.hd (group seq).
@@ -306,6 +369,18 @@ Cartesian product of the sequences. When calling product a b<
beforehand.
+val diagonal_l : 'a list -> ('a * 'a) t
+All pairs of distinct positions of the list. diagonal l will
+ return the sequence of all List.nth i l, List.nth j l if i < j.
+Since 0.9
+
+
+val diagonal : 'a t -> ('a * 'a) t
+All pairs of distinct positions of the sequence.
+ Iterates only once on the sequence, which must be finite.
+Since 0.9
+
+
val product2 : 'a t -> 'b t -> ('a, 'b) t2
Binary version of Sequence.product. Same requirements.
Since 0.5
@@ -318,6 +393,62 @@ Binary version of Sequence
iterations.
+val join_by : ?eq:'key equal ->
?hash:'key hash ->
('a -> 'key) ->
('b -> 'key) ->
merge:('key -> 'a -> 'b -> 'c option) ->
'a t -> 'b t -> 'c t
+join key1 key2 ~merge is a binary operation
+ that takes two sequences a and b, projects their
+ elements resp. with key1 and key2, and combine
+ values (x,y) from (a,b) with the same key
+ using merge. If merge returns None, the combination
+ of values is discarded.
+Since 0.10
+
+
+val join_all_by : ?eq:'key equal ->
?hash:'key hash ->
('a -> 'key) ->
('b -> 'key) ->
merge:('key -> 'a list -> 'b list -> 'c option) ->
'a t -> 'b t -> 'c t
+join_all_by key1 key2 ~merge is a binary operation
+ that takes two sequences a and b, projects their
+ elements resp. with key1 and key2, and, for each key k
+ occurring in at least one of them:
+- compute the list
l1 of elements of a that map to k
+- compute the list
l2 of elements of b that map to k
+- call
merge k l1 l2. If merge returns None, the combination
+ of values is discarded, otherwise it returns Some c
+ and c is inserted in the result.
+
+
+Since 0.10
+
+
+val group_join_by : ?eq:'a equal ->
?hash:'a hash ->
('b -> 'a) -> 'a t -> 'b t -> ('a * 'b list) t
+group_join_by key2 associates to every element x of
+ the first sequence, all the elements y of the second
+ sequence such that eq x (key y). Elements of the first
+ sequences without corresponding values in the second one
+ are mapped to []
+Since 0.10
+
+
+val inter : ?eq:'a equal ->
?hash:'a hash -> 'a t -> 'a t -> 'a t
+Intersection of two collections. Each element will occur at most once
+ in the result. Eager.
+Since 0.10
+
+
+val union : ?eq:'a equal ->
?hash:'a hash -> 'a t -> 'a t -> 'a t
+Union of two collections. Each element will occur at most once
+ in the result. Eager.
+Since 0.10
+
+
+val diff : ?eq:'a equal ->
?hash:'a hash -> 'a t -> 'a t -> 'a t
+Set difference. Eager.
+Since 0.10
+
+
+val subset : ?eq:'a equal ->
?hash:'a hash -> 'a t -> 'a t -> bool
+subset a b returns true if all elements of a belong to b. Eager.
+Since 0.10
+
+
val unfoldr : ('b -> ('a * 'b) option) -> 'b -> 'a t
unfoldr f b will apply f to b. If it
yields Some (x,b') then x is returned
@@ -334,11 +465,23 @@ Max element of the sequence, using the given comparison function.
element otherwise
+val max_exn : ?lt:('a -> 'a -> bool) -> 'a t -> 'a
+
val min : ?lt:('a -> 'a -> bool) -> 'a t -> 'a option
Min element of the sequence, using the given comparison function.
see Sequence.max for more details.
+val min_exn : ?lt:('a -> 'a -> bool) -> 'a t -> 'a
+
val head : 'a t -> 'a option
First element, if any, otherwise None
Since 0.5.1
diff --git a/api/SequenceLabels.IO.html b/api/SequenceLabels.IO.html
new file mode 100644
index 0000000..8fa3a0a
--- /dev/null
+++ b/api/SequenceLabels.IO.html
@@ -0,0 +1,58 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+SequenceLabels.IO
+
+
+
+Module SequenceLabels.IO
+
+module IO: sig .. end
+
+val lines_of : ?mode:int ->
?flags:Pervasives.open_flag list -> string -> string SequenceLabels.t
+lines_of filename reads all lines of the given file. It raises the
+ same exception as would opening the file and read from it, except
+ from End_of_file (which is caught). The file is always properly
+ closed.
+ Every time the sequence is iterated on, the file is opened again, so
+ different iterations might return different results
+
+mode : default 0o644
+flags : default: [Open_rdonly]
+
+val chunks_of : ?mode:int ->
?flags:Pervasives.open_flag list ->
?size:int -> string -> string SequenceLabels.t
+Read chunks of the given size from the file. The last chunk might be
+ smaller. Behaves like SequenceLabels.IO.lines_of regarding errors and options.
+ Every time the sequence is iterated on, the file is opened again, so
+ different iterations might return different results
+
+
+val write_to : ?mode:int ->
?flags:Pervasives.open_flag list -> string -> string SequenceLabels.t -> unit
+write_to filename seq writes all strings from seq into the given
+ file. It takes care of opening and closing the file.
+
+mode : default 0o644
+flags : used by open_out_gen. Default: [Open_creat;Open_wronly].
+
+val write_bytes_to : ?mode:int ->
?flags:Pervasives.open_flag list ->
string -> Bytes.t SequenceLabels.t -> unit
+
+
+val write_lines : ?mode:int ->
?flags:Pervasives.open_flag list -> string -> string SequenceLabels.t -> unit
+
+val write_bytes_lines : ?mode:int ->
?flags:Pervasives.open_flag list ->
string -> Bytes.t SequenceLabels.t -> unit
\ No newline at end of file
diff --git a/api/SequenceLabels.Infix.html b/api/SequenceLabels.Infix.html
new file mode 100644
index 0000000..9fe69a2
--- /dev/null
+++ b/api/SequenceLabels.Infix.html
@@ -0,0 +1,54 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+SequenceLabels.Infix
+
+
+
+Module SequenceLabels.Infix
+
+module Infix: sig .. end
+
+val (--) : int -> int -> int SequenceLabels.t
+a -- b is the range of integers from a to b, both included,
+ in increasing order. It will therefore be empty if a > b.
+
+
+val (--^) : int -> int -> int SequenceLabels.t
+a --^ b is the range of integers from b to a, both included,
+ in decreasing order (starts from a).
+ It will therefore be empty if a < b.
+
+
+val (>>=) : 'a SequenceLabels.t -> ('a -> 'b SequenceLabels.t) -> 'b SequenceLabels.t
+Monadic bind (infix version of SequenceLabels.flat_map
+
+
+val (>|=) : 'a SequenceLabels.t -> ('a -> 'b) -> 'b SequenceLabels.t
+Infix version of SequenceLabels.map
+
+
+val (<*>) : ('a -> 'b) SequenceLabels.t -> 'a SequenceLabels.t -> 'b SequenceLabels.t
+Applicative operator (product+application)
+
+
+val (<+>) : 'a SequenceLabels.t -> 'a SequenceLabels.t -> 'a SequenceLabels.t
+Concatenation of sequences
+
+
\ No newline at end of file
diff --git a/api/SequenceLabels.Map.Adapt.html b/api/SequenceLabels.Map.Adapt.html
new file mode 100644
index 0000000..69b7756
--- /dev/null
+++ b/api/SequenceLabels.Map.Adapt.html
@@ -0,0 +1,50 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+SequenceLabels.Map.Adapt
+
+
+
+Functor SequenceLabels.Map.Adapt
+
+module Adapt:
+Adapt a pre-existing Map module to make it sequence-aware
+
+
+
+Parameters:
+
+
+
+
+M
+:
+Map.S
+
+
+
+
+
+
+include Map.S
+
+val to_seq : 'a SequenceLabels.t -> (key * 'a) SequenceLabels.sequence
+val of_seq : (key * 'a) SequenceLabels.sequence -> 'a SequenceLabels.t
+val keys : 'a SequenceLabels.t -> key SequenceLabels.sequence
+val values : 'a SequenceLabels.t -> 'a SequenceLabels.sequence
+val to_list : 'a SequenceLabels.t -> (key * 'a) list
+val of_list : (key * 'a) list -> 'a SequenceLabels.t
\ No newline at end of file
diff --git a/api/SequenceLabels.Map.Make.html b/api/SequenceLabels.Map.Make.html
new file mode 100644
index 0000000..1e3a2d2
--- /dev/null
+++ b/api/SequenceLabels.Map.Make.html
@@ -0,0 +1,50 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+SequenceLabels.Map.Make
+
+
+
+Functor SequenceLabels.Map.Make
+
+module Make:
+Create an enriched Map module, with sequence-aware functions
+
+
+
+Parameters:
+
+
+
+
+V
+:
+Map.OrderedType
+
+
+
+
+
+
+include Map.S
+
+val to_seq : 'a SequenceLabels.t -> (key * 'a) SequenceLabels.sequence
+val of_seq : (key * 'a) SequenceLabels.sequence -> 'a SequenceLabels.t
+val keys : 'a SequenceLabels.t -> key SequenceLabels.sequence
+val values : 'a SequenceLabels.t -> 'a SequenceLabels.sequence
+val to_list : 'a SequenceLabels.t -> (key * 'a) list
+val of_list : (key * 'a) list -> 'a SequenceLabels.t
\ No newline at end of file
diff --git a/api/SequenceLabels.Map.S.html b/api/SequenceLabels.Map.S.html
new file mode 100644
index 0000000..6c4dcf4
--- /dev/null
+++ b/api/SequenceLabels.Map.S.html
@@ -0,0 +1,31 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+SequenceLabels.Map.S
+
+
+
+Module type SequenceLabels.Map.S
+
+module type S = sig .. end
+
+include Map.S
+
+val to_seq : 'a SequenceLabels.t -> (key * 'a) SequenceLabels.sequence
+val of_seq : (key * 'a) SequenceLabels.sequence -> 'a SequenceLabels.t
+val keys : 'a SequenceLabels.t -> key SequenceLabels.sequence
+val values : 'a SequenceLabels.t -> 'a SequenceLabels.sequence
+val to_list : 'a SequenceLabels.t -> (key * 'a) list
+val of_list : (key * 'a) list -> 'a SequenceLabels.t
\ No newline at end of file
diff --git a/api/SequenceLabels.Map.html b/api/SequenceLabels.Map.html
new file mode 100644
index 0000000..9843ddf
--- /dev/null
+++ b/api/SequenceLabels.Map.html
@@ -0,0 +1,36 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+SequenceLabels.Map
+
+
+
+Module SequenceLabels.Map
+
+module Map: sig .. end
+
+module type S = sig .. end
+module Adapt:
+Adapt a pre-existing Map module to make it sequence-aware
+
+
+module Make:
+Create an enriched Map module, with sequence-aware functions
+
+
\ No newline at end of file
diff --git a/api/SequenceLabels.Set.Adapt.html b/api/SequenceLabels.Set.Adapt.html
new file mode 100644
index 0000000..8dee383
--- /dev/null
+++ b/api/SequenceLabels.Set.Adapt.html
@@ -0,0 +1,48 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+SequenceLabels.Set.Adapt
+
+
+
+Functor SequenceLabels.Set.Adapt
+
+module Adapt:
+Create an enriched Set module from the given one
+
+
+
+Parameters:
+
+
+
+
+X
+:
+Set.S
+
+
+
+
+
+
+include Set.S
+
+val of_seq : elt SequenceLabels.sequence -> SequenceLabels.t
+val to_seq : SequenceLabels.t -> elt SequenceLabels.sequence
+val to_list : SequenceLabels.t -> elt list
+val of_list : elt list -> SequenceLabels.t
\ No newline at end of file
diff --git a/api/SequenceLabels.Set.Make.html b/api/SequenceLabels.Set.Make.html
new file mode 100644
index 0000000..e4122e5
--- /dev/null
+++ b/api/SequenceLabels.Set.Make.html
@@ -0,0 +1,48 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+SequenceLabels.Set.Make
+
+
+
+Functor SequenceLabels.Set.Make
+
+module Make:
+Functor to build an extended Set module from an ordered type
+
+
+
+Parameters:
+
+
+
+
+X
+:
+Set.OrderedType
+
+
+
+
+
+
+include Set.S
+
+val of_seq : elt SequenceLabels.sequence -> SequenceLabels.t
+val to_seq : SequenceLabels.t -> elt SequenceLabels.sequence
+val to_list : SequenceLabels.t -> elt list
+val of_list : elt list -> SequenceLabels.t
\ No newline at end of file
diff --git a/api/SequenceLabels.Set.S.html b/api/SequenceLabels.Set.S.html
new file mode 100644
index 0000000..dc20498
--- /dev/null
+++ b/api/SequenceLabels.Set.S.html
@@ -0,0 +1,29 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+SequenceLabels.Set.S
+
+
+
+Module type SequenceLabels.Set.S
+
+module type S = sig .. end
+
+include Set.S
+
+val of_seq : elt SequenceLabels.sequence -> SequenceLabels.t
+val to_seq : SequenceLabels.t -> elt SequenceLabels.sequence
+val to_list : SequenceLabels.t -> elt list
+val of_list : elt list -> SequenceLabels.t
\ No newline at end of file
diff --git a/api/SequenceLabels.Set.html b/api/SequenceLabels.Set.html
new file mode 100644
index 0000000..71d0be3
--- /dev/null
+++ b/api/SequenceLabels.Set.html
@@ -0,0 +1,34 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+SequenceLabels.Set
+
+
+
+Module SequenceLabels.Set
+
+module Set: sig .. end
+
+module type S = sig .. end
+module Adapt:
+Create an enriched Set module from the given one
+
+
+module Make:
+Functor to build an extended Set module from an ordered type
+
+
\ No newline at end of file
diff --git a/api/SequenceLabels.html b/api/SequenceLabels.html
new file mode 100644
index 0000000..2b0dc12
--- /dev/null
+++ b/api/SequenceLabels.html
@@ -0,0 +1,696 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+SequenceLabels
+
+
+
+Module SequenceLabels
+
+module SequenceLabels: sig .. end
+Simple and Efficient Iterators
+
+
+ Version of Sequence with labels
+Since 0.5.5
+
+
+
+type 'a t = ('a -> unit) -> unit
+
+A sequence of values of type 'a. If you give it a function 'a -> unit
+ it will be applied to every element of the sequence successively.
+
+
+
+type 'a sequence = 'a t
+
+
+type ('a, 'b) t2 = ('a -> 'b -> unit) -> unit
+
+Sequence of pairs of values of type 'a and 'b.
+
+
+
+Build a sequence
+
+val from_iter : (('a -> unit) -> unit) -> 'a t
+Build a sequence from a iter function
+
+
+val from_fun : (unit -> 'a option) -> 'a t
+Call the function repeatedly until it returns None. This
+ sequence is transient, use SequenceLabels.persistent if needed!
+
+
+val empty : 'a t
+Empty sequence. It contains no element.
+
+
+val singleton : 'a -> 'a t
+Singleton sequence, with exactly one element.
+
+
+val doubleton : 'a -> 'a -> 'a t
+Sequence with exactly two elements
+
+
+val init : f:(int -> 'a) -> 'a t
+init f is the infinite sequence f 0; f 1; f 2; ….
+Since 0.9
+
+
+val cons : 'a -> 'a t -> 'a t
+cons x l yields x, then yields from l.
+ Same as append (singleton x) l
+
+
+val snoc : 'a t -> 'a -> 'a t
+
+val return : 'a -> 'a t
+Synonym to SequenceLabels.singleton
+
+
+val pure : 'a -> 'a t
+Synonym to SequenceLabels.singleton
+
+
+val repeat : 'a -> 'a t
+Infinite sequence of the same element. You may want to look
+ at SequenceLabels.take and the likes if you iterate on it.
+
+
+val iterate : ('a -> 'a) -> 'a -> 'a t
+iterate f x is the infinite sequence x, f(x), f(f(x)), ...
+
+
+val forever : (unit -> 'b) -> 'b t
+Sequence that calls the given function to produce elements.
+ The sequence may be transient (depending on the function), and definitely
+ is infinite. You may want to use SequenceLabels.take and SequenceLabels.persistent.
+
+
+val cycle : 'a t -> 'a t
+Cycle forever through the given sequence. Assume the given sequence can
+ be traversed any amount of times (not transient). This yields an
+ infinite sequence, you should use something like SequenceLabels.take not to loop
+ forever.
+
+
+Consume a sequence
+
+val iter : f:('a -> unit) -> 'a t -> unit
+Consume the sequence, passing all its arguments to the function.
+ Basically iter f seq is just seq f.
+
+
+val iteri : f:(int -> 'a -> unit) -> 'a t -> unit
+Iterate on elements and their index in the sequence
+
+
+val fold : f:('a -> 'b -> 'a) -> init:'a -> 'b t -> 'a
+Fold over elements of the sequence, consuming it
+
+
+val foldi : f:('a -> int -> 'b -> 'a) -> init:'a -> 'b t -> 'a
+Fold over elements of the sequence and their index, consuming it
+
+
+val fold_map : f:('acc -> 'a -> 'acc * 'b) ->
init:'acc -> 'a t -> 'b t
+fold_map f acc l is like SequenceLabels.map, but it carries some state as in
+ SequenceLabels.fold. The state is not returned, it is just used to thread some
+ information to the map function.
+Since 0.9
+
+
+val fold_filter_map : f:('acc -> 'a -> 'acc * 'b option) ->
init:'acc -> 'a t -> 'b t
+fold_filter_map f acc l is a SequenceLabels.fold_map-like function, but the
+ function can choose to skip an element by retuning None.
+Since 0.9
+
+
+val map : f:('a -> 'b) -> 'a t -> 'b t
+Map objects of the sequence into other elements, lazily
+
+
+val mapi : f:(int -> 'a -> 'b) -> 'a t -> 'b t
+Map objects, along with their index in the sequence
+
+
+val map_by_2 : f:('a -> 'a -> 'a) -> 'a t -> 'a t
+Map objects two by two. lazily.
+ The last element is kept in the sequence if the count is odd.
+Since 0.7
+
+
+val for_all : f:('a -> bool) -> 'a t -> bool
+Do all elements satisfy the predicate?
+
+
+val exists : f:('a -> bool) -> 'a t -> bool
+Exists there some element satisfying the predicate?
+
+
+val mem : ?eq:('a -> 'a -> bool) -> x:'a -> 'a t -> bool
+Is the value a member of the sequence?
+
+eq : the equality predicate to use (default (=))
+
+val find : f:('a -> 'b option) -> 'a t -> 'b option
+Find the first element on which the function doesn't return None
+
+
+val findi : f:(int -> 'a -> 'b option) -> 'a t -> 'b option
+
+val find_pred : f:('a -> bool) -> 'a t -> 'a option
+find_pred p l finds the first element of l that satisfies p,
+ or returns None if no element satisfies p
+Since 0.9
+
+
+val find_pred_exn : f:('a -> bool) -> 'a t -> 'a
+Unsafe version of SequenceLabels.find_pred
+Since 0.9
+Raises Not_found if no such element is found
+
+
+val length : 'a t -> int
+How long is the sequence? Forces the sequence.
+
+
+val is_empty : 'a t -> bool
+Is the sequence empty? Forces the sequence.
+
+
+Transform a sequence
+
+val filter : f:('a -> bool) -> 'a t -> 'a t
+Filter on elements of the sequence
+
+
+val append : 'a t -> 'a t -> 'a t
+Append two sequences. Iterating on the result is like iterating
+ on the first, then on the second.
+
+
+val concat : 'a t t -> 'a t
+Concatenate a sequence of sequences into one sequence.
+
+
+val flatten : 'a t t -> 'a t
+Alias for SequenceLabels.concat
+
+
+val flat_map : f:('a -> 'b t) -> 'a t -> 'b t
+Alias to flatMap with a more explicit name
+
+
+val flat_map_l : f:('a -> 'b list) -> 'a t -> 'b t
+
+val filter_map : f:('a -> 'b option) -> 'a t -> 'b t
+Alias to fmap with a more explicit name
+
+
+val intersperse : x:'a -> 'a t -> 'a t
+Insert the single element between every element of the sequence
+
+
+Caching
+
+val persistent : 'a t -> 'a t
+Iterate on the sequence, storing elements in an efficient internal structure..
+ The resulting sequence can be iterated on as many times as needed.
+ Note: calling persistent on an already persistent sequence
+ will still make a new copy of the sequence!
+
+
+val persistent_lazy : 'a t -> 'a t
+Lazy version of SequenceLabels.persistent. When calling persistent_lazy s,
+ a new sequence s' is immediately returned (without actually consuming
+ s) in constant time; the first time s' is iterated on,
+ it also consumes s and caches its content into a inner data
+ structure that will back s' for future iterations.
+
+
+ warning: on the first traversal of s', if the traversal
+ is interrupted prematurely (SequenceLabels.take, etc.) then s' will not be
+ memorized, and the next call to s' will traverse s again.
+
+
+Misc
+
+val sort : ?cmp:('a -> 'a -> int) -> 'a t -> 'a t
+Sort the sequence. Eager, O(n) ram and O(n ln(n)) time.
+ It iterates on elements of the argument sequence immediately,
+ before it sorts them.
+
+
+val sort_uniq : ?cmp:('a -> 'a -> int) -> 'a t -> 'a t
+Sort the sequence and remove duplicates. Eager, same as sort
+
+
+val sorted : ?cmp:('a -> 'a -> int) -> 'a t -> bool
+
+val group_succ_by : ?eq:('a -> 'a -> bool) -> 'a t -> 'a list t
+Group equal consecutive elements.
+ Formerly synonym to group.
+Since 0.6
+
+
+val group_by : ?hash:('a -> int) ->
?eq:('a -> 'a -> bool) -> 'a t -> 'a list t
+Group equal elements, disregarding their order of appearance.
+ The result sequence is traversable as many times as required.
+Since 0.6
+
+
+val count : ?hash:('a -> int) ->
?eq:('a -> 'a -> bool) -> 'a t -> ('a * int) t
+Map each distinct element to its number of occurrences in the whole seq.
+ Similar to group_by seq |> map (fun l->List.hd l, List.length l)
+Since 0.10
+
+
+val uniq : ?eq:('a -> 'a -> bool) -> 'a t -> 'a t
+Remove consecutive duplicate elements. Basically this is
+ like fun seq -> map List.hd (group seq).
+
+
+val product : 'a t -> 'b t -> ('a * 'b) t
+Cartesian product of the sequences. When calling product a b,
+ the caller MUST ensure that b can be traversed as many times
+ as required (several times), possibly by calling SequenceLabels.persistent on it
+ beforehand.
+
+
+val diagonal_l : 'a list -> ('a * 'a) t
+All pairs of distinct positions of the list. diagonal l will
+ return the sequence of all List.nth i l, List.nth j l if i < j.
+Since 0.9
+
+
+val diagonal : 'a t -> ('a * 'a) t
+All pairs of distinct positions of the sequence.
+ Iterates only once on the sequence, which must be finite.
+Since 0.9
+
+
+val product2 : 'a t -> 'b t -> ('a, 'b) t2
+Binary version of SequenceLabels.product. Same requirements.
+
+
+val join : join_row:('a -> 'b -> 'c option) ->
'a t -> 'b t -> 'c t
+join ~join_row a b combines every element of a with every
+ element of b using join_row. If join_row returns None, then
+ the two elements do not combine. Assume that b allows for multiple
+ iterations.
+
+
+val unfoldr : ('b -> ('a * 'b) option) -> 'b -> 'a t
+unfoldr f b will apply f to b. If it
+ yields Some (x,b') then x is returned
+ and unfoldr recurses with b'.
+
+
+val scan : ('b -> 'a -> 'b) -> 'b -> 'a t -> 'b t
+Sequence of intermediate results
+
+
+val max : ?lt:('a -> 'a -> bool) -> 'a t -> 'a option
+Max element of the sequence, using the given comparison function.
+Returns None if the sequence is empty, Some m where m is the maximal
+ element otherwise
+
+
+val min : ?lt:('a -> 'a -> bool) -> 'a t -> 'a option
+Min element of the sequence, using the given comparison function.
+ see SequenceLabels.max for more details.
+
+
+val head : 'a t -> 'a option
+First element, if any, otherwise None
+
+
+val head_exn : 'a t -> 'a
+First element, if any, fails
+Raises Invalid_argument if the sequence is empty
+
+
+val take : int -> 'a t -> 'a t
+Take at most n elements from the sequence. Works on infinite
+ sequences.
+
+
+val take_while : f:('a -> bool) -> 'a t -> 'a t
+Take elements while they satisfy the predicate, then stops iterating.
+ Will work on an infinite sequence s if the predicate is false for at
+ least one element of s.
+
+
+val fold_while : f:('a -> 'b -> 'a * [ `Continue | `Stop ]) ->
init:'a -> 'b t -> 'a
+Folds over elements of the sequence, stopping early if the accumulator
+ returns ('a, `Stop)
+
+
+val drop : int -> 'a t -> 'a t
+Drop the n first elements of the sequence. Lazy.
+
+
+val drop_while : f:('a -> bool) -> 'a t -> 'a t
+Predicate version of SequenceLabels.drop
+
+
+val rev : 'a t -> 'a t
+Reverse the sequence. O(n) memory and time, needs the
+ sequence to be finite. The result is persistent and does
+ not depend on the input being repeatable.
+
+
+Binary sequences
+
+val empty2 : ('a, 'b) t2
+val is_empty2 : ('a, 'b) t2 -> bool
+val length2 : ('a, 'b) t2 -> int
+val zip : ('a, 'b) t2 -> ('a * 'b) t
+val unzip : ('a * 'b) t -> ('a, 'b) t2
+val zip_i : 'a t -> (int, 'a) t2
+Zip elements of the sequence with their index in the sequence
+
+
+val fold2 : f:('c -> 'a -> 'b -> 'c) -> init:'c -> ('a, 'b) t2 -> 'c
+val iter2 : f:('a -> 'b -> unit) -> ('a, 'b) t2 -> unit
+val map2 : f:('a -> 'b -> 'c) -> ('a, 'b) t2 -> 'c t
+val map2_2 : ('a -> 'b -> 'c) ->
('a -> 'b -> 'd) -> ('a, 'b) t2 -> ('c, 'd) t2
+map2_2 f g seq2 maps each x, y of seq2 into f x y, g x y
+
+
+Basic data structures converters
+
+val to_list : 'a t -> 'a list
+Convert the sequence into a list. Preserves order of elements.
+ This function is tail-recursive, but consumes 2*n memory.
+ If order doesn't matter to you, consider SequenceLabels.to_rev_list.
+
+
+val to_rev_list : 'a t -> 'a list
+Get the list of the reversed sequence (more efficient than SequenceLabels.to_list)
+
+
+val of_list : 'a list -> 'a t
+val on_list : ('a t -> 'b t) -> 'a list -> 'b list
+on_list f l is equivalent to to_list @@ f @@ of_list l.
+
+
+val to_opt : 'a t -> 'a option
+Alias to SequenceLabels.head
+
+
+val to_array : 'a t -> 'a array
+Convert to an array. Currently not very efficient because
+ an intermediate list is used.
+
+
+val of_array : 'a array -> 'a t
+val of_array_i : 'a array -> (int * 'a) t
+Elements of the array, with their index
+
+
+val of_array2 : 'a array -> (int, 'a) t2
+val array_slice : 'a array -> int -> int -> 'a t
+array_slice a i j Sequence of elements whose indexes range
+ from i to j
+
+
+val of_opt : 'a option -> 'a t
+Iterate on 0 or 1 values.
+
+
+val of_stream : 'a Stream.t -> 'a t
+Sequence of elements of a stream (usable only once)
+
+
+val to_stream : 'a t -> 'a Stream.t
+Convert to a stream. linear in memory and time (a copy is made in memory)
+
+
+val to_stack : 'a Stack.t -> 'a t -> unit
+Push elements of the sequence on the stack
+
+
+val of_stack : 'a Stack.t -> 'a t
+Sequence of elements of the stack (same order as Stack.iter)
+
+
+val to_queue : 'a Queue.t -> 'a t -> unit
+Push elements of the sequence into the queue
+
+
+val of_queue : 'a Queue.t -> 'a t
+Sequence of elements contained in the queue, FIFO order
+
+
+val hashtbl_add : ('a, 'b) Hashtbl.t -> ('a * 'b) t -> unit
+Add elements of the sequence to the hashtable, with
+ Hashtbl.add
+
+
+val hashtbl_replace : ('a, 'b) Hashtbl.t -> ('a * 'b) t -> unit
+Add elements of the sequence to the hashtable, with
+ Hashtbl.replace (erases conflicting bindings)
+
+
+val to_hashtbl : ('a * 'b) t -> ('a, 'b) Hashtbl.t
+Build a hashtable from a sequence of key/value pairs
+
+
+val to_hashtbl2 : ('a, 'b) t2 -> ('a, 'b) Hashtbl.t
+Build a hashtable from a sequence of key/value pairs
+
+
+val of_hashtbl : ('a, 'b) Hashtbl.t -> ('a * 'b) t
+Sequence of key/value pairs from the hashtable
+
+
+val of_hashtbl2 : ('a, 'b) Hashtbl.t -> ('a, 'b) t2
+Sequence of key/value pairs from the hashtable
+
+
+val hashtbl_keys : ('a, 'b) Hashtbl.t -> 'a t
+val hashtbl_values : ('a, 'b) Hashtbl.t -> 'b t
+val of_str : string -> char t
+val to_str : char t -> string
+val concat_str : string t -> string
+Concatenate strings together, eagerly.
+ Also see SequenceLabels.intersperse to add a separator.
+
+
+exception OneShotSequence
+
+Raised when the user tries to iterate several times on
+ a transient iterator
+
+
+val of_in_channel : Pervasives.in_channel -> char t
+Iterates on characters of the input (can block when one
+ iterates over the sequence). If you need to iterate
+ several times on this sequence, use SequenceLabels.persistent.
+Raises OneShotSequence when used more than once.
+
+
+val to_buffer : char t -> Buffer.t -> unit
+Copy content of the sequence into the buffer
+
+
+val int_range : start:int -> stop:int -> int t
+Iterator on integers in start...stop by steps 1. Also see
+ (--) for an infix version.
+
+
+val int_range_dec : start:int -> stop:int -> int t
+Iterator on decreasing integers in stop...start by steps -1.
+ See (--^) for an infix version
+
+
+val int_range_by : step:int -> start:int -> stop:int -> int t
+int_range_by ~step ~start:i ~stop:j is the range starting at i, including j,
+ where the difference between successive elements is step.
+ use a negative step for a decreasing sequence.
+Since 0.9
+Raises Invalid_argument if step=0
+
+
+val bools : bool t
+Iterates on true and false
+Since 0.9
+
+
+val of_set : (module Set.S with type elt = 'a and type t = 'b) ->
'b -> 'a t
+Convert the given set to a sequence. The set module must be provided.
+
+
+val to_set : (module Set.S with type elt = 'a and type t = 'b) ->
'a t -> 'b
+Convert the sequence to a set, given the proper set module
+
+
+type 'a gen = unit -> 'a option
+
+
+type 'a klist = unit -> [ `Cons of 'a * 'a klist | `Nil ]
+
+
+val of_gen : 'a gen -> 'a t
+Traverse eagerly the generator and build a sequence from it
+
+
+val to_gen : 'a t -> 'a gen
+Make the sequence persistent (O(n)) and then iterate on it. Eager.
+
+
+val of_klist : 'a klist -> 'a t
+Iterate on the lazy list
+
+
+val to_klist : 'a t -> 'a klist
+Make the sequence persistent and then iterate on it. Eager.
+
+
+Functorial conversions between sets and sequences
+
+module Set: sig .. end
+Conversion between maps and sequences.
+
+module Map: sig .. end
+Infinite sequences of random values
+
+val random_int : int -> int t
+Infinite sequence of random integers between 0 and
+ the given higher bound (see Random.int)
+
+
+val random_bool : bool t
+Infinite sequence of random bool values
+
+
+val random_float : float -> float t
+val random_array : 'a array -> 'a t
+Sequence of choices of an element in the array
+
+
+val random_list : 'a list -> 'a t
+Infinite sequence of random elements of the list. Basically the
+ same as SequenceLabels.random_array.
+
+
+val shuffle : 'a t -> 'a t
+shuffle seq returns a perfect shuffle of seq.
+ Uses O(length seq) memory and time. Eager.
+Since 0.7
+
+
+val shuffle_buffer : n:int -> 'a t -> 'a t
+shuffle_buffer n seq returns a sequence of element of seq in random
+ order. The shuffling is not uniform. Uses O(n) memory.
+
+
+ The first n elements of the sequence are consumed immediately. The
+ rest is consumed lazily.
+Since 0.7
+
+
+Sampling
+
+val sample : n:int -> 'a t -> 'a array
+sample n seq returns k samples of seq, with uniform probability.
+ It will consume the sequence and use O(n) memory.
+
+
+ It returns an array of size min (length seq) n.
+Since 0.7
+
+
+Infix functions
+
+module Infix: sig .. end
+include SequenceLabels.Infix
+
+Pretty printing of sequences
+
+val pp_seq : ?sep:string ->
(Format.formatter -> 'a -> unit) ->
Format.formatter -> 'a t -> unit
+Pretty print a sequence of 'a, using the given pretty printer
+ to print each elements. An optional separator string can be provided.
+
+
+val pp_buf : ?sep:string ->
(Buffer.t -> 'a -> unit) -> Buffer.t -> 'a t -> unit
+Print into a buffer
+
+
+val to_string : ?sep:string -> ('a -> string) -> 'a t -> string
+Print into a string
+
+
+Basic IO
+
+
+ Very basic interface to manipulate files as sequence of chunks/lines. The
+ sequences take care of opening and closing files properly; every time
+ one iterates over a sequence, the file is opened/closed again.
+
+
+ Example: copy a file "a" into file "b", removing blank lines:
+
+
+
Sequence.(IO.lines_of "a" |> filter (fun l-> l<> "") |> IO.write_lines "b");;
+
+
+
+ By chunks of 4096 bytes:
+
+
+
Sequence.IO.(chunks_of ~size:4096 "a" |> write_to "b");;
+
+
+
+ Read the lines of a file into a list:
+
+
+
Sequence.IO.lines "a" |> Sequence.to_list
+
+
+module IO: sig .. end
\ No newline at end of file
diff --git a/api/html.stamp b/api/html.stamp
index 3a9bf8f..0f61c54 100644
--- a/api/html.stamp
+++ b/api/html.stamp
@@ -1 +1 @@
-f0710dfe44cf0fb5dacae3bfdb0e21a2
\ No newline at end of file
+01e4b44957fc72253f7d3ad77531bb1e
\ No newline at end of file
diff --git a/api/index.html b/api/index.html
index 260626a..df5de79 100644
--- a/api/index.html
+++ b/api/index.html
@@ -3,6 +3,7 @@
+
diff --git a/api/index_attributes.html b/api/index_attributes.html
index 7a57b12..fd87078 100644
--- a/api/index_attributes.html
+++ b/api/index_attributes.html
@@ -2,6 +2,7 @@
+
diff --git a/api/index_class_types.html b/api/index_class_types.html
index 3563748..b770b72 100644
--- a/api/index_class_types.html
+++ b/api/index_class_types.html
@@ -2,6 +2,7 @@
+
diff --git a/api/index_classes.html b/api/index_classes.html
index dbe98c3..18291c9 100644
--- a/api/index_classes.html
+++ b/api/index_classes.html
@@ -2,6 +2,7 @@
+
diff --git a/api/index_exceptions.html b/api/index_exceptions.html
index f9d6d72..3f869fd 100644
--- a/api/index_exceptions.html
+++ b/api/index_exceptions.html
@@ -2,6 +2,7 @@
+
diff --git a/api/index_extensions.html b/api/index_extensions.html
new file mode 100644
index 0000000..dd40036
--- /dev/null
+++ b/api/index_extensions.html
@@ -0,0 +1,22 @@
+
+
+
+
+
+
+
+
+
+
+
+
+Index of extensions
+
+
+
+Index of extensions
+
+
+
+
\ No newline at end of file
diff --git a/api/index_methods.html b/api/index_methods.html
index d5ae037..2077d4a 100644
--- a/api/index_methods.html
+++ b/api/index_methods.html
@@ -2,6 +2,7 @@
+
diff --git a/api/index_module_types.html b/api/index_module_types.html
index b03b43f..cbb64b0 100644
--- a/api/index_module_types.html
+++ b/api/index_module_types.html
@@ -2,6 +2,7 @@
+
diff --git a/api/index_modules.html b/api/index_modules.html
index 05b00e0..f919368 100644
--- a/api/index_modules.html
+++ b/api/index_modules.html
@@ -2,6 +2,7 @@
+
diff --git a/api/index_types.html b/api/index_types.html
index 744fe08..8808614 100644
--- a/api/index_types.html
+++ b/api/index_types.html
@@ -2,6 +2,7 @@
+
@@ -16,11 +17,17 @@
Index of types
+
Eequal [Sequence]
+
Ggen [SequenceLabels]
gen [Sequence]
Hhash [Sequence]
+
Kklist [SequenceLabels]
Bbools [SequenceLabels]
+
+Iterates on true and false
+
+ bools [Sequence]
Iterates on true and false
@@ -151,6 +157,16 @@ Concatenate strings together, eagerly.
cons x l yields x, then yields from l.
count [SequenceLabels]
+
+Map each distinct element to its number of occurrences in the whole seq.
+
+ count [Sequence]
+
+Map each distinct element to its number of occurrences in the whole seq.
+
+ cycle [SequenceLabels]
Cycle forever through the given sequence.
@@ -162,6 +178,31 @@ Cycle forever through the given sequence.
Ddiagonal [SequenceLabels]
+
+All pairs of distinct positions of the sequence.
+
+ diagonal [Sequence]
+
+All pairs of distinct positions of the sequence.
+
+ diagonal_l [SequenceLabels]
+
+All pairs of distinct positions of the list.
+
+ diagonal_l [Sequence]
+
+All pairs of distinct positions of the list.
+
+ diff [Sequence]
+
+Set difference.
+
+ doubleton [SequenceLabels]
Sequence with exactly two elements
@@ -249,6 +290,48 @@ Find the first element on which the function doesn't return N
Find the first element on which the function doesn't return None
find_map [Sequence]
+
+Alias to Sequence.find
+
+ find_mapi [Sequence]
+
+Alias to Sequence.findi
+
+ find_pred [SequenceLabels]
+
+find_pred p l finds the first element of l that satisfies p,
+ or returns None if no element satisfies p
+
+ find_pred [Sequence]
+
+find_pred p l finds the first element of l that satisfies p,
+ or returns None if no element satisfies p
+
+ find_pred_exn [SequenceLabels]
+
+Unsafe version of SequenceLabels.find_pred
+
+ find_pred_exn [Sequence]
+
+Unsafe version of Sequence.find_pred
+
+ findi [SequenceLabels]
+
+Indexed version of SequenceLabels.find
+
+ findi [Sequence]
+
+Indexed version of Sequence.find
+
+ flat_map [SequenceLabels]
Alias to flatMap with a more explicit name
@@ -293,6 +376,30 @@ Fold over elements of the sequence, consuming it
fold2 [Sequence]
fold_filter_map [SequenceLabels]
+
+fold_filter_map f acc l is a SequenceLabels.fold_map-like function, but the
+ function can choose to skip an element by retuning None.
+
+ fold_filter_map [Sequence]
+
+fold_filter_map f acc l is a Sequence.fold_map-like function, but the
+ function can choose to skip an element by retuning None.
+
+ fold_map [SequenceLabels]
+
+fold_map f acc l is like SequenceLabels.map, but it carries some state as in
+ SequenceLabels.fold.
+
+ fold_map [Sequence]
+
+ fold_while [SequenceLabels]
Folds over elements of the sequence, stopping early if the accumulator
@@ -366,6 +473,13 @@ Group equal elements, disregarding their order of appearance.
Group equal elements, disregarding their order of appearance.
group_join_by [Sequence]
+
+group_join_by key2 associates to every element x of
+ the first sequence, all the elements y of the second
+ sequence such that eq x (key y).
+
+ group_succ_by [SequenceLabels]
Group equal consecutive elements.
@@ -430,6 +544,16 @@ First element, if any, fails
Iinit [SequenceLabels]
+
+init f is the infinite sequence f 0; f 1; f 2; ….
+
+ init [Sequence]
+
+init f is the infinite sequence f 0; f 1; f 2; ….
+
+ int_range [SequenceLabels]
Iterator on integers in start...stop by steps 1.
@@ -462,6 +586,11 @@ Iterator on decreasing integers in stop...start by ste
Iterator on decreasing integers in stop...start by steps -1.
inter [Sequence]
+
+Intersection of two collections.
+
+ intersperse [SequenceLabels]
Insert the single element between every element of the sequence
@@ -533,6 +662,20 @@ Iterate on elements and their index in the sequence
element of b using join_row.
join_all_by [Sequence]
+
+join_all_by key1 key2 ~merge is a binary operation
+ that takes two sequences a and b, projects their
+ elements resp.
+
+ join_by [Sequence]
+
+join key1 key2 ~merge is a binary operation
+ that takes two sequences a and b, projects their
+ elements resp.
+
+
Kkeys [SequenceLabels.Map.S]
max_exn [Sequence]
+
+Unsafe version of Sequence.max
+
+ mem [SequenceLabels]
Is the value a member of the sequence?
@@ -638,6 +786,11 @@ Min element of the sequence, using the given comparison function.
Min element of the sequence, using the given comparison function.
min_exn [Sequence]
+
+Unsafe version of Sequence.min
+
+
Oof_array [SequenceLabels]
sorted [SequenceLabels]
+
+Checks whether the sequence is sorted.
+
+ sorted [Sequence]
+
+Checks whether the sequence is sorted.
+
+ subset [Sequence]
+
+subset a b returns true if all elements of a belong to b.
+
+
Ttake [SequenceLabels]
@@ -1218,6 +1386,11 @@ Print into a string
unfoldr f b will apply f to b.
union [Sequence]
+
+Union of two collections.
+
+ uniq [SequenceLabels]
Remove consecutive duplicate elements.
diff --git a/api/type_Sequence.IO.html b/api/type_Sequence.IO.html
new file mode 100644
index 0000000..9891a95
--- /dev/null
+++ b/api/type_Sequence.IO.html
@@ -0,0 +1,35 @@
+
+
+
+
+
+
+
+
+
+
+
+Sequence.IO
+
+
+sig
+ val lines_of :
+ ?mode:int ->
+ ?flags:Pervasives.open_flag list -> string -> string Sequence.t
+ val chunks_of :
+ ?mode:int ->
+ ?flags:Pervasives.open_flag list ->
+ ?size:int -> string -> string Sequence.t
+ val write_to :
+ ?mode:int ->
+ ?flags:Pervasives.open_flag list -> string -> string Sequence.t -> unit
+ val write_bytes_to :
+ ?mode:int ->
+ ?flags:Pervasives.open_flag list -> string -> Bytes.t Sequence.t -> unit
+ val write_lines :
+ ?mode:int ->
+ ?flags:Pervasives.open_flag list -> string -> string Sequence.t -> unit
+ val write_bytes_lines :
+ ?mode:int ->
+ ?flags:Pervasives.open_flag list -> string -> Bytes.t Sequence.t -> unit
+end
\ No newline at end of file
diff --git a/api/type_Sequence.Infix.html b/api/type_Sequence.Infix.html
index 25d4c7a..f4e10ae 100644
--- a/api/type_Sequence.Infix.html
+++ b/api/type_Sequence.Infix.html
@@ -1,6 +1,7 @@
+
@@ -11,11 +12,11 @@
Sequence.Infix
-sig
- val ( -- ) : int -> int -> int Sequence.t
- val ( --^ ) : int -> int -> int Sequence.t
- val ( >>= ) : 'a Sequence.t -> ('a -> 'b Sequence.t) -> 'b Sequence.t
- val ( >|= ) : 'a Sequence.t -> ('a -> 'b) -> 'b Sequence.t
- val ( <*> ) : ('a -> 'b) Sequence.t -> 'a Sequence.t -> 'b Sequence.t
- val ( <+> ) : 'a Sequence.t -> 'a Sequence.t -> 'a Sequence.t
+sig
+ val ( -- ) : int -> int -> int Sequence.t
+ val ( --^ ) : int -> int -> int Sequence.t
+ val ( >>= ) : 'a Sequence.t -> ('a -> 'b Sequence.t) -> 'b Sequence.t
+ val ( >|= ) : 'a Sequence.t -> ('a -> 'b) -> 'b Sequence.t
+ val ( <*> ) : ('a -> 'b) Sequence.t -> 'a Sequence.t -> 'b Sequence.t
+ val ( <+> ) : 'a Sequence.t -> 'a Sequence.t -> 'a Sequence.t
end
\ No newline at end of file
diff --git a/api/type_Sequence.Map.Adapt.html b/api/type_Sequence.Map.Adapt.html
index 1506e16..7c7f5d4 100644
--- a/api/type_Sequence.Map.Adapt.html
+++ b/api/type_Sequence.Map.Adapt.html
@@ -1,6 +1,7 @@
+
@@ -11,40 +12,40 @@
Sequence.Map.Adapt
-functor (M : Map.S) ->
- sig
- type key = M.key
- type 'a t = 'a M.t
- val empty : 'a t
- val is_empty : 'a t -> bool
- val mem : key -> 'a t -> bool
- val add : key -> 'a -> 'a t -> 'a t
- val singleton : key -> 'a -> 'a t
- val remove : key -> 'a t -> 'a t
- val merge :
- (key -> 'a option -> 'b option -> 'c option) -> 'a t -> 'b t -> 'c t
- val union : (key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
- val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
- val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
- val iter : (key -> 'a -> unit) -> 'a t -> unit
- val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
- val for_all : (key -> 'a -> bool) -> 'a t -> bool
- val exists : (key -> 'a -> bool) -> 'a t -> bool
- val filter : (key -> 'a -> bool) -> 'a t -> 'a t
- val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
- val cardinal : 'a t -> int
- val bindings : 'a t -> (key * 'a) list
- val min_binding : 'a t -> key * 'a
- val max_binding : 'a t -> key * 'a
- val choose : 'a t -> key * 'a
- val split : key -> 'a t -> 'a t * 'a option * 'a t
- val find : key -> 'a t -> 'a
- val map : ('a -> 'b) -> 'a t -> 'b t
- val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
- val to_seq : 'a t -> (key * 'a) sequence
- val of_seq : (key * 'a) sequence -> 'a t
- val keys : 'a t -> key sequence
- val values : 'a t -> 'a sequence
- val to_list : 'a t -> (key * 'a) list
- val of_list : (key * 'a) list -> 'a t
+functor (M : Map.S) ->
+ sig
+ type key = M.key
+ type 'a t = 'a M.t
+ val empty : 'a t
+ val is_empty : 'a t -> bool
+ val mem : key -> 'a t -> bool
+ val add : key -> 'a -> 'a t -> 'a t
+ val singleton : key -> 'a -> 'a t
+ val remove : key -> 'a t -> 'a t
+ val merge :
+ (key -> 'a option -> 'b option -> 'c option) -> 'a t -> 'b t -> 'c t
+ val union : (key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
+ val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
+ val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
+ val iter : (key -> 'a -> unit) -> 'a t -> unit
+ val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
+ val for_all : (key -> 'a -> bool) -> 'a t -> bool
+ val exists : (key -> 'a -> bool) -> 'a t -> bool
+ val filter : (key -> 'a -> bool) -> 'a t -> 'a t
+ val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
+ val cardinal : 'a t -> int
+ val bindings : 'a t -> (key * 'a) list
+ val min_binding : 'a t -> key * 'a
+ val max_binding : 'a t -> key * 'a
+ val choose : 'a t -> key * 'a
+ val split : key -> 'a t -> 'a t * 'a option * 'a t
+ val find : key -> 'a t -> 'a
+ val map : ('a -> 'b) -> 'a t -> 'b t
+ val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
+ val to_seq : 'a t -> (key * 'a) sequence
+ val of_seq : (key * 'a) sequence -> 'a t
+ val keys : 'a t -> key sequence
+ val values : 'a t -> 'a sequence
+ val to_list : 'a t -> (key * 'a) list
+ val of_list : (key * 'a) list -> 'a t
end
\ No newline at end of file
diff --git a/api/type_Sequence.Map.Make.html b/api/type_Sequence.Map.Make.html
index 267d7c3..dd7ef04 100644
--- a/api/type_Sequence.Map.Make.html
+++ b/api/type_Sequence.Map.Make.html
@@ -1,6 +1,7 @@
+
@@ -11,40 +12,40 @@
Sequence.Map.Make
-functor (V : Map.OrderedType) ->
- sig
- type key = V.t
- type +'a t
- val empty : 'a t
- val is_empty : 'a t -> bool
- val mem : key -> 'a t -> bool
- val add : key -> 'a -> 'a t -> 'a t
- val singleton : key -> 'a -> 'a t
- val remove : key -> 'a t -> 'a t
- val merge :
- (key -> 'a option -> 'b option -> 'c option) -> 'a t -> 'b t -> 'c t
- val union : (key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
- val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
- val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
- val iter : (key -> 'a -> unit) -> 'a t -> unit
- val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
- val for_all : (key -> 'a -> bool) -> 'a t -> bool
- val exists : (key -> 'a -> bool) -> 'a t -> bool
- val filter : (key -> 'a -> bool) -> 'a t -> 'a t
- val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
- val cardinal : 'a t -> int
- val bindings : 'a t -> (key * 'a) list
- val min_binding : 'a t -> key * 'a
- val max_binding : 'a t -> key * 'a
- val choose : 'a t -> key * 'a
- val split : key -> 'a t -> 'a t * 'a option * 'a t
- val find : key -> 'a t -> 'a
- val map : ('a -> 'b) -> 'a t -> 'b t
- val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
- val to_seq : 'a t -> (key * 'a) sequence
- val of_seq : (key * 'a) sequence -> 'a t
- val keys : 'a t -> key sequence
- val values : 'a t -> 'a sequence
- val to_list : 'a t -> (key * 'a) list
- val of_list : (key * 'a) list -> 'a t
+functor (V : Map.OrderedType) ->
+ sig
+ type key = V.t
+ type +'a t
+ val empty : 'a t
+ val is_empty : 'a t -> bool
+ val mem : key -> 'a t -> bool
+ val add : key -> 'a -> 'a t -> 'a t
+ val singleton : key -> 'a -> 'a t
+ val remove : key -> 'a t -> 'a t
+ val merge :
+ (key -> 'a option -> 'b option -> 'c option) -> 'a t -> 'b t -> 'c t
+ val union : (key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
+ val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
+ val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
+ val iter : (key -> 'a -> unit) -> 'a t -> unit
+ val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
+ val for_all : (key -> 'a -> bool) -> 'a t -> bool
+ val exists : (key -> 'a -> bool) -> 'a t -> bool
+ val filter : (key -> 'a -> bool) -> 'a t -> 'a t
+ val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
+ val cardinal : 'a t -> int
+ val bindings : 'a t -> (key * 'a) list
+ val min_binding : 'a t -> key * 'a
+ val max_binding : 'a t -> key * 'a
+ val choose : 'a t -> key * 'a
+ val split : key -> 'a t -> 'a t * 'a option * 'a t
+ val find : key -> 'a t -> 'a
+ val map : ('a -> 'b) -> 'a t -> 'b t
+ val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
+ val to_seq : 'a t -> (key * 'a) sequence
+ val of_seq : (key * 'a) sequence -> 'a t
+ val keys : 'a t -> key sequence
+ val values : 'a t -> 'a sequence
+ val to_list : 'a t -> (key * 'a) list
+ val of_list : (key * 'a) list -> 'a t
end
\ No newline at end of file
diff --git a/api/type_Sequence.Map.S.html b/api/type_Sequence.Map.S.html
index ffd18a4..5c7eff9 100644
--- a/api/type_Sequence.Map.S.html
+++ b/api/type_Sequence.Map.S.html
@@ -1,6 +1,7 @@
+
@@ -11,39 +12,39 @@
Sequence.Map.S
-sig
- type key
- type +'a t
- val empty : 'a t
- val is_empty : 'a t -> bool
- val mem : key -> 'a t -> bool
- val add : key -> 'a -> 'a t -> 'a t
- val singleton : key -> 'a -> 'a t
- val remove : key -> 'a t -> 'a t
- val merge :
- (key -> 'a option -> 'b option -> 'c option) -> 'a t -> 'b t -> 'c t
- val union : (key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
- val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
- val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
- val iter : (key -> 'a -> unit) -> 'a t -> unit
- val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
- val for_all : (key -> 'a -> bool) -> 'a t -> bool
- val exists : (key -> 'a -> bool) -> 'a t -> bool
- val filter : (key -> 'a -> bool) -> 'a t -> 'a t
- val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
- val cardinal : 'a t -> int
- val bindings : 'a t -> (key * 'a) list
- val min_binding : 'a t -> key * 'a
- val max_binding : 'a t -> key * 'a
- val choose : 'a t -> key * 'a
- val split : key -> 'a t -> 'a t * 'a option * 'a t
- val find : key -> 'a t -> 'a
- val map : ('a -> 'b) -> 'a t -> 'b t
- val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
- val to_seq : 'a Sequence.t -> (key * 'a) Sequence.sequence
- val of_seq : (key * 'a) Sequence.sequence -> 'a Sequence.t
- val keys : 'a Sequence.t -> key Sequence.sequence
- val values : 'a Sequence.t -> 'a Sequence.sequence
- val to_list : 'a Sequence.t -> (key * 'a) list
- val of_list : (key * 'a) list -> 'a Sequence.t
+sig
+ type key
+ type +'a t
+ val empty : 'a t
+ val is_empty : 'a t -> bool
+ val mem : key -> 'a t -> bool
+ val add : key -> 'a -> 'a t -> 'a t
+ val singleton : key -> 'a -> 'a t
+ val remove : key -> 'a t -> 'a t
+ val merge :
+ (key -> 'a option -> 'b option -> 'c option) -> 'a t -> 'b t -> 'c t
+ val union : (key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
+ val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
+ val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
+ val iter : (key -> 'a -> unit) -> 'a t -> unit
+ val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
+ val for_all : (key -> 'a -> bool) -> 'a t -> bool
+ val exists : (key -> 'a -> bool) -> 'a t -> bool
+ val filter : (key -> 'a -> bool) -> 'a t -> 'a t
+ val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
+ val cardinal : 'a t -> int
+ val bindings : 'a t -> (key * 'a) list
+ val min_binding : 'a t -> key * 'a
+ val max_binding : 'a t -> key * 'a
+ val choose : 'a t -> key * 'a
+ val split : key -> 'a t -> 'a t * 'a option * 'a t
+ val find : key -> 'a t -> 'a
+ val map : ('a -> 'b) -> 'a t -> 'b t
+ val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
+ val to_seq : 'a Sequence.t -> (key * 'a) Sequence.sequence
+ val of_seq : (key * 'a) Sequence.sequence -> 'a Sequence.t
+ val keys : 'a Sequence.t -> key Sequence.sequence
+ val values : 'a Sequence.t -> 'a Sequence.sequence
+ val to_list : 'a Sequence.t -> (key * 'a) list
+ val of_list : (key * 'a) list -> 'a Sequence.t
end
\ No newline at end of file
diff --git a/api/type_Sequence.Map.html b/api/type_Sequence.Map.html
index 5079a3e..04cea8a 100644
--- a/api/type_Sequence.Map.html
+++ b/api/type_Sequence.Map.html
@@ -1,6 +1,7 @@
+
@@ -11,120 +12,120 @@
Sequence.Map
-sig
- module type S =
- sig
- type key
- type +'a t
- val empty : 'a t
- val is_empty : 'a t -> bool
- val mem : key -> 'a t -> bool
- val add : key -> 'a -> 'a t -> 'a t
- val singleton : key -> 'a -> 'a t
- val remove : key -> 'a t -> 'a t
- val merge :
- (key -> 'a option -> 'b option -> 'c option) -> 'a t -> 'b t -> 'c t
- val union : (key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
- val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
- val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
- val iter : (key -> 'a -> unit) -> 'a t -> unit
- val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
- val for_all : (key -> 'a -> bool) -> 'a t -> bool
- val exists : (key -> 'a -> bool) -> 'a t -> bool
- val filter : (key -> 'a -> bool) -> 'a t -> 'a t
- val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
- val cardinal : 'a t -> int
- val bindings : 'a t -> (key * 'a) list
- val min_binding : 'a t -> key * 'a
- val max_binding : 'a t -> key * 'a
- val choose : 'a t -> key * 'a
- val split : key -> 'a t -> 'a t * 'a option * 'a t
- val find : key -> 'a t -> 'a
- val map : ('a -> 'b) -> 'a t -> 'b t
- val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
- val to_seq : 'a Sequence.t -> (key * 'a) Sequence.sequence
- val of_seq : (key * 'a) Sequence.sequence -> 'a Sequence.t
- val keys : 'a Sequence.t -> key Sequence.sequence
- val values : 'a Sequence.t -> 'a Sequence.sequence
- val to_list : 'a Sequence.t -> (key * 'a) list
- val of_list : (key * 'a) list -> 'a Sequence.t
- end
- module Adapt :
- functor (M : Map.S) ->
- sig
- type key = M.key
- type 'a t = 'a M.t
- val empty : 'a t
- val is_empty : 'a t -> bool
- val mem : key -> 'a t -> bool
- val add : key -> 'a -> 'a t -> 'a t
- val singleton : key -> 'a -> 'a t
- val remove : key -> 'a t -> 'a t
- val merge :
- (key -> 'a option -> 'b option -> 'c option) ->
- 'a t -> 'b t -> 'c t
- val union : (key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
- val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
- val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
- val iter : (key -> 'a -> unit) -> 'a t -> unit
- val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
- val for_all : (key -> 'a -> bool) -> 'a t -> bool
- val exists : (key -> 'a -> bool) -> 'a t -> bool
- val filter : (key -> 'a -> bool) -> 'a t -> 'a t
- val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
- val cardinal : 'a t -> int
- val bindings : 'a t -> (key * 'a) list
- val min_binding : 'a t -> key * 'a
- val max_binding : 'a t -> key * 'a
- val choose : 'a t -> key * 'a
- val split : key -> 'a t -> 'a t * 'a option * 'a t
- val find : key -> 'a t -> 'a
- val map : ('a -> 'b) -> 'a t -> 'b t
- val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
- val to_seq : 'a t -> (key * 'a) sequence
- val of_seq : (key * 'a) sequence -> 'a t
- val keys : 'a t -> key sequence
- val values : 'a t -> 'a sequence
- val to_list : 'a t -> (key * 'a) list
- val of_list : (key * 'a) list -> 'a t
- end
- module Make :
- functor (V : Map.OrderedType) ->
- sig
- type key = V.t
- type +'a t
- val empty : 'a t
- val is_empty : 'a t -> bool
- val mem : key -> 'a t -> bool
- val add : key -> 'a -> 'a t -> 'a t
- val singleton : key -> 'a -> 'a t
- val remove : key -> 'a t -> 'a t
- val merge :
- (key -> 'a option -> 'b option -> 'c option) ->
- 'a t -> 'b t -> 'c t
- val union : (key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
- val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
- val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
- val iter : (key -> 'a -> unit) -> 'a t -> unit
- val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
- val for_all : (key -> 'a -> bool) -> 'a t -> bool
- val exists : (key -> 'a -> bool) -> 'a t -> bool
- val filter : (key -> 'a -> bool) -> 'a t -> 'a t
- val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
- val cardinal : 'a t -> int
- val bindings : 'a t -> (key * 'a) list
- val min_binding : 'a t -> key * 'a
- val max_binding : 'a t -> key * 'a
- val choose : 'a t -> key * 'a
- val split : key -> 'a t -> 'a t * 'a option * 'a t
- val find : key -> 'a t -> 'a
- val map : ('a -> 'b) -> 'a t -> 'b t
- val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
- val to_seq : 'a t -> (key * 'a) sequence
- val of_seq : (key * 'a) sequence -> 'a t
- val keys : 'a t -> key sequence
- val values : 'a t -> 'a sequence
- val to_list : 'a t -> (key * 'a) list
- val of_list : (key * 'a) list -> 'a t
- end
+sig
+ module type S =
+ sig
+ type key
+ type +'a t
+ val empty : 'a t
+ val is_empty : 'a t -> bool
+ val mem : key -> 'a t -> bool
+ val add : key -> 'a -> 'a t -> 'a t
+ val singleton : key -> 'a -> 'a t
+ val remove : key -> 'a t -> 'a t
+ val merge :
+ (key -> 'a option -> 'b option -> 'c option) -> 'a t -> 'b t -> 'c t
+ val union : (key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
+ val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
+ val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
+ val iter : (key -> 'a -> unit) -> 'a t -> unit
+ val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
+ val for_all : (key -> 'a -> bool) -> 'a t -> bool
+ val exists : (key -> 'a -> bool) -> 'a t -> bool
+ val filter : (key -> 'a -> bool) -> 'a t -> 'a t
+ val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
+ val cardinal : 'a t -> int
+ val bindings : 'a t -> (key * 'a) list
+ val min_binding : 'a t -> key * 'a
+ val max_binding : 'a t -> key * 'a
+ val choose : 'a t -> key * 'a
+ val split : key -> 'a t -> 'a t * 'a option * 'a t
+ val find : key -> 'a t -> 'a
+ val map : ('a -> 'b) -> 'a t -> 'b t
+ val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
+ val to_seq : 'a Sequence.t -> (key * 'a) Sequence.sequence
+ val of_seq : (key * 'a) Sequence.sequence -> 'a Sequence.t
+ val keys : 'a Sequence.t -> key Sequence.sequence
+ val values : 'a Sequence.t -> 'a Sequence.sequence
+ val to_list : 'a Sequence.t -> (key * 'a) list
+ val of_list : (key * 'a) list -> 'a Sequence.t
+ end
+ module Adapt :
+ functor (M : Map.S) ->
+ sig
+ type key = M.key
+ type 'a t = 'a M.t
+ val empty : 'a t
+ val is_empty : 'a t -> bool
+ val mem : key -> 'a t -> bool
+ val add : key -> 'a -> 'a t -> 'a t
+ val singleton : key -> 'a -> 'a t
+ val remove : key -> 'a t -> 'a t
+ val merge :
+ (key -> 'a option -> 'b option -> 'c option) ->
+ 'a t -> 'b t -> 'c t
+ val union : (key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
+ val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
+ val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
+ val iter : (key -> 'a -> unit) -> 'a t -> unit
+ val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
+ val for_all : (key -> 'a -> bool) -> 'a t -> bool
+ val exists : (key -> 'a -> bool) -> 'a t -> bool
+ val filter : (key -> 'a -> bool) -> 'a t -> 'a t
+ val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
+ val cardinal : 'a t -> int
+ val bindings : 'a t -> (key * 'a) list
+ val min_binding : 'a t -> key * 'a
+ val max_binding : 'a t -> key * 'a
+ val choose : 'a t -> key * 'a
+ val split : key -> 'a t -> 'a t * 'a option * 'a t
+ val find : key -> 'a t -> 'a
+ val map : ('a -> 'b) -> 'a t -> 'b t
+ val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
+ val to_seq : 'a t -> (key * 'a) sequence
+ val of_seq : (key * 'a) sequence -> 'a t
+ val keys : 'a t -> key sequence
+ val values : 'a t -> 'a sequence
+ val to_list : 'a t -> (key * 'a) list
+ val of_list : (key * 'a) list -> 'a t
+ end
+ module Make :
+ functor (V : Map.OrderedType) ->
+ sig
+ type key = V.t
+ type +'a t
+ val empty : 'a t
+ val is_empty : 'a t -> bool
+ val mem : key -> 'a t -> bool
+ val add : key -> 'a -> 'a t -> 'a t
+ val singleton : key -> 'a -> 'a t
+ val remove : key -> 'a t -> 'a t
+ val merge :
+ (key -> 'a option -> 'b option -> 'c option) ->
+ 'a t -> 'b t -> 'c t
+ val union : (key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
+ val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
+ val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
+ val iter : (key -> 'a -> unit) -> 'a t -> unit
+ val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
+ val for_all : (key -> 'a -> bool) -> 'a t -> bool
+ val exists : (key -> 'a -> bool) -> 'a t -> bool
+ val filter : (key -> 'a -> bool) -> 'a t -> 'a t
+ val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
+ val cardinal : 'a t -> int
+ val bindings : 'a t -> (key * 'a) list
+ val min_binding : 'a t -> key * 'a
+ val max_binding : 'a t -> key * 'a
+ val choose : 'a t -> key * 'a
+ val split : key -> 'a t -> 'a t * 'a option * 'a t
+ val find : key -> 'a t -> 'a
+ val map : ('a -> 'b) -> 'a t -> 'b t
+ val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
+ val to_seq : 'a t -> (key * 'a) sequence
+ val of_seq : (key * 'a) sequence -> 'a t
+ val keys : 'a t -> key sequence
+ val values : 'a t -> 'a sequence
+ val to_list : 'a t -> (key * 'a) list
+ val of_list : (key * 'a) list -> 'a t
+ end
end
\ No newline at end of file
diff --git a/api/type_Sequence.Set.Adapt.html b/api/type_Sequence.Set.Adapt.html
index 4a8c1b9..aa48f34 100644
--- a/api/type_Sequence.Set.Adapt.html
+++ b/api/type_Sequence.Set.Adapt.html
@@ -1,6 +1,7 @@
+
@@ -11,37 +12,38 @@
Sequence.Set.Adapt
-functor (X : Set.S) ->
- sig
- type elt = X.elt
- type t = X.t
- val empty : t
- val is_empty : t -> bool
- val mem : elt -> t -> bool
- val add : elt -> t -> t
- val singleton : elt -> t
- val remove : elt -> t -> t
- val union : t -> t -> t
- val inter : t -> t -> t
- val diff : t -> t -> t
- val compare : t -> t -> int
- val equal : t -> t -> bool
- val subset : t -> t -> bool
- val iter : (elt -> unit) -> t -> unit
- val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
- val for_all : (elt -> bool) -> t -> bool
- val exists : (elt -> bool) -> t -> bool
- val filter : (elt -> bool) -> t -> t
- val partition : (elt -> bool) -> t -> t * t
- val cardinal : t -> int
- val elements : t -> elt list
- val min_elt : t -> elt
- val max_elt : t -> elt
- val choose : t -> elt
- val split : elt -> t -> t * bool * t
- val find : elt -> t -> elt
- val of_seq : elt sequence -> t
- val to_seq : t -> elt sequence
- val to_list : t -> elt list
- val of_list : elt list -> t
+functor (X : Set.S) ->
+ sig
+ type elt = X.elt
+ type t = X.t
+ val empty : t
+ val is_empty : t -> bool
+ val mem : elt -> t -> bool
+ val add : elt -> t -> t
+ val singleton : elt -> t
+ val remove : elt -> t -> t
+ val union : t -> t -> t
+ val inter : t -> t -> t
+ val diff : t -> t -> t
+ val compare : t -> t -> int
+ val equal : t -> t -> bool
+ val subset : t -> t -> bool
+ val iter : (elt -> unit) -> t -> unit
+ val map : (elt -> elt) -> t -> t
+ val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
+ val for_all : (elt -> bool) -> t -> bool
+ val exists : (elt -> bool) -> t -> bool
+ val filter : (elt -> bool) -> t -> t
+ val partition : (elt -> bool) -> t -> t * t
+ val cardinal : t -> int
+ val elements : t -> elt list
+ val min_elt : t -> elt
+ val max_elt : t -> elt
+ val choose : t -> elt
+ val split : elt -> t -> t * bool * t
+ val find : elt -> t -> elt
+ val of_seq : elt sequence -> t
+ val to_seq : t -> elt sequence
+ val to_list : t -> elt list
+ val of_list : elt list -> t
end
\ No newline at end of file
diff --git a/api/type_Sequence.Set.Make.html b/api/type_Sequence.Set.Make.html
index 532541b..f01fac9 100644
--- a/api/type_Sequence.Set.Make.html
+++ b/api/type_Sequence.Set.Make.html
@@ -1,6 +1,7 @@
+
@@ -11,37 +12,38 @@
Sequence.Set.Make
-functor (X : Set.OrderedType) ->
- sig
- type elt = X.t
- type t
- val empty : t
- val is_empty : t -> bool
- val mem : elt -> t -> bool
- val add : elt -> t -> t
- val singleton : elt -> t
- val remove : elt -> t -> t
- val union : t -> t -> t
- val inter : t -> t -> t
- val diff : t -> t -> t
- val compare : t -> t -> int
- val equal : t -> t -> bool
- val subset : t -> t -> bool
- val iter : (elt -> unit) -> t -> unit
- val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
- val for_all : (elt -> bool) -> t -> bool
- val exists : (elt -> bool) -> t -> bool
- val filter : (elt -> bool) -> t -> t
- val partition : (elt -> bool) -> t -> t * t
- val cardinal : t -> int
- val elements : t -> elt list
- val min_elt : t -> elt
- val max_elt : t -> elt
- val choose : t -> elt
- val split : elt -> t -> t * bool * t
- val find : elt -> t -> elt
- val of_seq : elt sequence -> t
- val to_seq : t -> elt sequence
- val to_list : t -> elt list
- val of_list : elt list -> t
+functor (X : Set.OrderedType) ->
+ sig
+ type elt = X.t
+ type t
+ val empty : t
+ val is_empty : t -> bool
+ val mem : elt -> t -> bool
+ val add : elt -> t -> t
+ val singleton : elt -> t
+ val remove : elt -> t -> t
+ val union : t -> t -> t
+ val inter : t -> t -> t
+ val diff : t -> t -> t
+ val compare : t -> t -> int
+ val equal : t -> t -> bool
+ val subset : t -> t -> bool
+ val iter : (elt -> unit) -> t -> unit
+ val map : (elt -> elt) -> t -> t
+ val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
+ val for_all : (elt -> bool) -> t -> bool
+ val exists : (elt -> bool) -> t -> bool
+ val filter : (elt -> bool) -> t -> t
+ val partition : (elt -> bool) -> t -> t * t
+ val cardinal : t -> int
+ val elements : t -> elt list
+ val min_elt : t -> elt
+ val max_elt : t -> elt
+ val choose : t -> elt
+ val split : elt -> t -> t * bool * t
+ val find : elt -> t -> elt
+ val of_seq : elt sequence -> t
+ val to_seq : t -> elt sequence
+ val to_list : t -> elt list
+ val of_list : elt list -> t
end
\ No newline at end of file
diff --git a/api/type_Sequence.Set.S.html b/api/type_Sequence.Set.S.html
index 660cd6a..7676b02 100644
--- a/api/type_Sequence.Set.S.html
+++ b/api/type_Sequence.Set.S.html
@@ -1,6 +1,7 @@
+
@@ -11,36 +12,37 @@
Sequence.Set.S
-sig
- type elt
- type t
- val empty : t
- val is_empty : t -> bool
- val mem : elt -> t -> bool
- val add : elt -> t -> t
- val singleton : elt -> t
- val remove : elt -> t -> t
- val union : t -> t -> t
- val inter : t -> t -> t
- val diff : t -> t -> t
- val compare : t -> t -> int
- val equal : t -> t -> bool
- val subset : t -> t -> bool
- val iter : (elt -> unit) -> t -> unit
- val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
- val for_all : (elt -> bool) -> t -> bool
- val exists : (elt -> bool) -> t -> bool
- val filter : (elt -> bool) -> t -> t
- val partition : (elt -> bool) -> t -> t * t
- val cardinal : t -> int
- val elements : t -> elt list
- val min_elt : t -> elt
- val max_elt : t -> elt
- val choose : t -> elt
- val split : elt -> t -> t * bool * t
- val find : elt -> t -> elt
- val of_seq : elt Sequence.sequence -> Sequence.t
- val to_seq : Sequence.t -> elt Sequence.sequence
- val to_list : Sequence.t -> elt list
- val of_list : elt list -> Sequence.t
+sig
+ type elt
+ type t
+ val empty : t
+ val is_empty : t -> bool
+ val mem : elt -> t -> bool
+ val add : elt -> t -> t
+ val singleton : elt -> t
+ val remove : elt -> t -> t
+ val union : t -> t -> t
+ val inter : t -> t -> t
+ val diff : t -> t -> t
+ val compare : t -> t -> int
+ val equal : t -> t -> bool
+ val subset : t -> t -> bool
+ val iter : (elt -> unit) -> t -> unit
+ val map : (elt -> elt) -> t -> t
+ val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
+ val for_all : (elt -> bool) -> t -> bool
+ val exists : (elt -> bool) -> t -> bool
+ val filter : (elt -> bool) -> t -> t
+ val partition : (elt -> bool) -> t -> t * t
+ val cardinal : t -> int
+ val elements : t -> elt list
+ val min_elt : t -> elt
+ val max_elt : t -> elt
+ val choose : t -> elt
+ val split : elt -> t -> t * bool * t
+ val find : elt -> t -> elt
+ val of_seq : elt Sequence.sequence -> Sequence.t
+ val to_seq : Sequence.t -> elt Sequence.sequence
+ val to_list : Sequence.t -> elt list
+ val of_list : elt list -> Sequence.t
end
\ No newline at end of file
diff --git a/api/type_Sequence.Set.html b/api/type_Sequence.Set.html
index 60550bc..eeae71d 100644
--- a/api/type_Sequence.Set.html
+++ b/api/type_Sequence.Set.html
@@ -1,6 +1,7 @@
+
@@ -11,109 +12,112 @@
Sequence.Set
-sig
- module type S =
- sig
- type elt
- type t
- val empty : t
- val is_empty : t -> bool
- val mem : elt -> t -> bool
- val add : elt -> t -> t
- val singleton : elt -> t
- val remove : elt -> t -> t
- val union : t -> t -> t
- val inter : t -> t -> t
- val diff : t -> t -> t
- val compare : t -> t -> int
- val equal : t -> t -> bool
- val subset : t -> t -> bool
- val iter : (elt -> unit) -> t -> unit
- val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
- val for_all : (elt -> bool) -> t -> bool
- val exists : (elt -> bool) -> t -> bool
- val filter : (elt -> bool) -> t -> t
- val partition : (elt -> bool) -> t -> t * t
- val cardinal : t -> int
- val elements : t -> elt list
- val min_elt : t -> elt
- val max_elt : t -> elt
- val choose : t -> elt
- val split : elt -> t -> t * bool * t
- val find : elt -> t -> elt
- val of_seq : elt Sequence.sequence -> Sequence.t
- val to_seq : Sequence.t -> elt Sequence.sequence
- val to_list : Sequence.t -> elt list
- val of_list : elt list -> Sequence.t
- end
- module Adapt :
- functor (X : Set.S) ->
- sig
- type elt = X.elt
- type t = X.t
- val empty : t
- val is_empty : t -> bool
- val mem : elt -> t -> bool
- val add : elt -> t -> t
- val singleton : elt -> t
- val remove : elt -> t -> t
- val union : t -> t -> t
- val inter : t -> t -> t
- val diff : t -> t -> t
- val compare : t -> t -> int
- val equal : t -> t -> bool
- val subset : t -> t -> bool
- val iter : (elt -> unit) -> t -> unit
- val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
- val for_all : (elt -> bool) -> t -> bool
- val exists : (elt -> bool) -> t -> bool
- val filter : (elt -> bool) -> t -> t
- val partition : (elt -> bool) -> t -> t * t
- val cardinal : t -> int
- val elements : t -> elt list
- val min_elt : t -> elt
- val max_elt : t -> elt
- val choose : t -> elt
- val split : elt -> t -> t * bool * t
- val find : elt -> t -> elt
- val of_seq : elt sequence -> t
- val to_seq : t -> elt sequence
- val to_list : t -> elt list
- val of_list : elt list -> t
- end
- module Make :
- functor (X : Set.OrderedType) ->
- sig
- type elt = X.t
- type t
- val empty : t
- val is_empty : t -> bool
- val mem : elt -> t -> bool
- val add : elt -> t -> t
- val singleton : elt -> t
- val remove : elt -> t -> t
- val union : t -> t -> t
- val inter : t -> t -> t
- val diff : t -> t -> t
- val compare : t -> t -> int
- val equal : t -> t -> bool
- val subset : t -> t -> bool
- val iter : (elt -> unit) -> t -> unit
- val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
- val for_all : (elt -> bool) -> t -> bool
- val exists : (elt -> bool) -> t -> bool
- val filter : (elt -> bool) -> t -> t
- val partition : (elt -> bool) -> t -> t * t
- val cardinal : t -> int
- val elements : t -> elt list
- val min_elt : t -> elt
- val max_elt : t -> elt
- val choose : t -> elt
- val split : elt -> t -> t * bool * t
- val find : elt -> t -> elt
- val of_seq : elt sequence -> t
- val to_seq : t -> elt sequence
- val to_list : t -> elt list
- val of_list : elt list -> t
- end
+sig
+ module type S =
+ sig
+ type elt
+ type t
+ val empty : t
+ val is_empty : t -> bool
+ val mem : elt -> t -> bool
+ val add : elt -> t -> t
+ val singleton : elt -> t
+ val remove : elt -> t -> t
+ val union : t -> t -> t
+ val inter : t -> t -> t
+ val diff : t -> t -> t
+ val compare : t -> t -> int
+ val equal : t -> t -> bool
+ val subset : t -> t -> bool
+ val iter : (elt -> unit) -> t -> unit
+ val map : (elt -> elt) -> t -> t
+ val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
+ val for_all : (elt -> bool) -> t -> bool
+ val exists : (elt -> bool) -> t -> bool
+ val filter : (elt -> bool) -> t -> t
+ val partition : (elt -> bool) -> t -> t * t
+ val cardinal : t -> int
+ val elements : t -> elt list
+ val min_elt : t -> elt
+ val max_elt : t -> elt
+ val choose : t -> elt
+ val split : elt -> t -> t * bool * t
+ val find : elt -> t -> elt
+ val of_seq : elt Sequence.sequence -> Sequence.t
+ val to_seq : Sequence.t -> elt Sequence.sequence
+ val to_list : Sequence.t -> elt list
+ val of_list : elt list -> Sequence.t
+ end
+ module Adapt :
+ functor (X : Set.S) ->
+ sig
+ type elt = X.elt
+ type t = X.t
+ val empty : t
+ val is_empty : t -> bool
+ val mem : elt -> t -> bool
+ val add : elt -> t -> t
+ val singleton : elt -> t
+ val remove : elt -> t -> t
+ val union : t -> t -> t
+ val inter : t -> t -> t
+ val diff : t -> t -> t
+ val compare : t -> t -> int
+ val equal : t -> t -> bool
+ val subset : t -> t -> bool
+ val iter : (elt -> unit) -> t -> unit
+ val map : (elt -> elt) -> t -> t
+ val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
+ val for_all : (elt -> bool) -> t -> bool
+ val exists : (elt -> bool) -> t -> bool
+ val filter : (elt -> bool) -> t -> t
+ val partition : (elt -> bool) -> t -> t * t
+ val cardinal : t -> int
+ val elements : t -> elt list
+ val min_elt : t -> elt
+ val max_elt : t -> elt
+ val choose : t -> elt
+ val split : elt -> t -> t * bool * t
+ val find : elt -> t -> elt
+ val of_seq : elt sequence -> t
+ val to_seq : t -> elt sequence
+ val to_list : t -> elt list
+ val of_list : elt list -> t
+ end
+ module Make :
+ functor (X : Set.OrderedType) ->
+ sig
+ type elt = X.t
+ type t
+ val empty : t
+ val is_empty : t -> bool
+ val mem : elt -> t -> bool
+ val add : elt -> t -> t
+ val singleton : elt -> t
+ val remove : elt -> t -> t
+ val union : t -> t -> t
+ val inter : t -> t -> t
+ val diff : t -> t -> t
+ val compare : t -> t -> int
+ val equal : t -> t -> bool
+ val subset : t -> t -> bool
+ val iter : (elt -> unit) -> t -> unit
+ val map : (elt -> elt) -> t -> t
+ val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
+ val for_all : (elt -> bool) -> t -> bool
+ val exists : (elt -> bool) -> t -> bool
+ val filter : (elt -> bool) -> t -> t
+ val partition : (elt -> bool) -> t -> t * t
+ val cardinal : t -> int
+ val elements : t -> elt list
+ val min_elt : t -> elt
+ val max_elt : t -> elt
+ val choose : t -> elt
+ val split : elt -> t -> t * bool * t
+ val find : elt -> t -> elt
+ val of_seq : elt sequence -> t
+ val to_seq : t -> elt sequence
+ val to_list : t -> elt list
+ val of_list : elt list -> t
+ end
end
\ No newline at end of file
diff --git a/api/type_Sequence.html b/api/type_Sequence.html
index 73f7f4a..b03e143 100644
--- a/api/type_Sequence.html
+++ b/api/type_Sequence.html
@@ -1,6 +1,7 @@
+
@@ -11,412 +12,466 @@
Sequence
-sig
- type 'a t = ('a -> unit) -> unit
- type 'a sequence = 'a Sequence.t
- type ('a, 'b) t2 = ('a -> 'b -> unit) -> unit
- val from_iter : (('a -> unit) -> unit) -> 'a Sequence.t
- val from_fun : (unit -> 'a option) -> 'a Sequence.t
- val empty : 'a Sequence.t
- val singleton : 'a -> 'a Sequence.t
- val doubleton : 'a -> 'a -> 'a Sequence.t
- val cons : 'a -> 'a Sequence.t -> 'a Sequence.t
- val snoc : 'a Sequence.t -> 'a -> 'a Sequence.t
- val return : 'a -> 'a Sequence.t
- val pure : 'a -> 'a Sequence.t
- val repeat : 'a -> 'a Sequence.t
- val iterate : ('a -> 'a) -> 'a -> 'a Sequence.t
- val forever : (unit -> 'b) -> 'b Sequence.t
- val cycle : 'a Sequence.t -> 'a Sequence.t
- val iter : ('a -> unit) -> 'a Sequence.t -> unit
- val iteri : (int -> 'a -> unit) -> 'a Sequence.t -> unit
- val fold : ('a -> 'b -> 'a) -> 'a -> 'b Sequence.t -> 'a
- val foldi : ('a -> int -> 'b -> 'a) -> 'a -> 'b Sequence.t -> 'a
- val map : ('a -> 'b) -> 'a Sequence.t -> 'b Sequence.t
- val mapi : (int -> 'a -> 'b) -> 'a Sequence.t -> 'b Sequence.t
- val map_by_2 : ('a -> 'a -> 'a) -> 'a Sequence.t -> 'a Sequence.t
- val for_all : ('a -> bool) -> 'a Sequence.t -> bool
- val exists : ('a -> bool) -> 'a Sequence.t -> bool
- val mem : ?eq:('a -> 'a -> bool) -> 'a -> 'a Sequence.t -> bool
- val find : ('a -> 'b option) -> 'a Sequence.t -> 'b option
- val length : 'a Sequence.t -> int
- val is_empty : 'a Sequence.t -> bool
- val filter : ('a -> bool) -> 'a Sequence.t -> 'a Sequence.t
- val append : 'a Sequence.t -> 'a Sequence.t -> 'a Sequence.t
- val concat : 'a Sequence.t Sequence.t -> 'a Sequence.t
- val flatten : 'a Sequence.t Sequence.t -> 'a Sequence.t
- val flat_map : ('a -> 'b Sequence.t) -> 'a Sequence.t -> 'b Sequence.t
- val flat_map_l : ('a -> 'b list) -> 'a Sequence.t -> 'b Sequence.t
- val filter_map : ('a -> 'b option) -> 'a Sequence.t -> 'b Sequence.t
- val intersperse : 'a -> 'a Sequence.t -> 'a Sequence.t
- val persistent : 'a Sequence.t -> 'a Sequence.t
- val persistent_lazy : 'a Sequence.t -> 'a Sequence.t
- val sort : ?cmp:('a -> 'a -> int) -> 'a Sequence.t -> 'a Sequence.t
- val sort_uniq : ?cmp:('a -> 'a -> int) -> 'a Sequence.t -> 'a Sequence.t
- val group_succ_by :
- ?eq:('a -> 'a -> bool) -> 'a Sequence.t -> 'a list Sequence.t
- val group_by :
- ?hash:('a -> int) ->
- ?eq:('a -> 'a -> bool) -> 'a Sequence.t -> 'a list Sequence.t
- val uniq : ?eq:('a -> 'a -> bool) -> 'a Sequence.t -> 'a Sequence.t
- val product : 'a Sequence.t -> 'b Sequence.t -> ('a * 'b) Sequence.t
- val product2 : 'a Sequence.t -> 'b Sequence.t -> ('a, 'b) Sequence.t2
- val join :
- join_row:('a -> 'b -> 'c option) ->
- 'a Sequence.t -> 'b Sequence.t -> 'c Sequence.t
- val unfoldr : ('b -> ('a * 'b) option) -> 'b -> 'a Sequence.t
- val scan : ('b -> 'a -> 'b) -> 'b -> 'a Sequence.t -> 'b Sequence.t
- val max : ?lt:('a -> 'a -> bool) -> 'a Sequence.t -> 'a option
- val min : ?lt:('a -> 'a -> bool) -> 'a Sequence.t -> 'a option
- val head : 'a Sequence.t -> 'a option
- val head_exn : 'a Sequence.t -> 'a
- val take : int -> 'a Sequence.t -> 'a Sequence.t
- val take_while : ('a -> bool) -> 'a Sequence.t -> 'a Sequence.t
- val fold_while :
- ('a -> 'b -> 'a * [ `Continue | `Stop ]) -> 'a -> 'b Sequence.t -> 'a
- val drop : int -> 'a Sequence.t -> 'a Sequence.t
- val drop_while : ('a -> bool) -> 'a Sequence.t -> 'a Sequence.t
- val rev : 'a Sequence.t -> 'a Sequence.t
- val empty2 : ('a, 'b) Sequence.t2
- val is_empty2 : ('a, 'b) Sequence.t2 -> bool
- val length2 : ('a, 'b) Sequence.t2 -> int
- val zip : ('a, 'b) Sequence.t2 -> ('a * 'b) Sequence.t
- val unzip : ('a * 'b) Sequence.t -> ('a, 'b) Sequence.t2
- val zip_i : 'a Sequence.t -> (int, 'a) Sequence.t2
- val fold2 : ('c -> 'a -> 'b -> 'c) -> 'c -> ('a, 'b) Sequence.t2 -> 'c
- val iter2 : ('a -> 'b -> unit) -> ('a, 'b) Sequence.t2 -> unit
- val map2 : ('a -> 'b -> 'c) -> ('a, 'b) Sequence.t2 -> 'c Sequence.t
- val map2_2 :
- ('a -> 'b -> 'c) ->
- ('a -> 'b -> 'd) -> ('a, 'b) Sequence.t2 -> ('c, 'd) Sequence.t2
- val to_list : 'a Sequence.t -> 'a list
- val to_rev_list : 'a Sequence.t -> 'a list
- val of_list : 'a list -> 'a Sequence.t
- val on_list : ('a Sequence.t -> 'b Sequence.t) -> 'a list -> 'b list
- val to_opt : 'a Sequence.t -> 'a option
- val to_array : 'a Sequence.t -> 'a array
- val of_array : 'a array -> 'a Sequence.t
- val of_array_i : 'a array -> (int * 'a) Sequence.t
- val of_array2 : 'a array -> (int, 'a) Sequence.t2
- val array_slice : 'a array -> int -> int -> 'a Sequence.t
- val of_opt : 'a option -> 'a Sequence.t
- val of_stream : 'a Stream.t -> 'a Sequence.t
- val to_stream : 'a Sequence.t -> 'a Stream.t
- val to_stack : 'a Stack.t -> 'a Sequence.t -> unit
- val of_stack : 'a Stack.t -> 'a Sequence.t
- val to_queue : 'a Queue.t -> 'a Sequence.t -> unit
- val of_queue : 'a Queue.t -> 'a Sequence.t
- val hashtbl_add : ('a, 'b) Hashtbl.t -> ('a * 'b) Sequence.t -> unit
- val hashtbl_replace : ('a, 'b) Hashtbl.t -> ('a * 'b) Sequence.t -> unit
- val to_hashtbl : ('a * 'b) Sequence.t -> ('a, 'b) Hashtbl.t
- val to_hashtbl2 : ('a, 'b) Sequence.t2 -> ('a, 'b) Hashtbl.t
- val of_hashtbl : ('a, 'b) Hashtbl.t -> ('a * 'b) Sequence.t
- val of_hashtbl2 : ('a, 'b) Hashtbl.t -> ('a, 'b) Sequence.t2
- val hashtbl_keys : ('a, 'b) Hashtbl.t -> 'a Sequence.t
- val hashtbl_values : ('a, 'b) Hashtbl.t -> 'b Sequence.t
- val of_str : string -> char Sequence.t
- val to_str : char Sequence.t -> string
- val concat_str : string Sequence.t -> string
- exception OneShotSequence
- val of_in_channel : Pervasives.in_channel -> char Sequence.t
- val to_buffer : char Sequence.t -> Buffer.t -> unit
- val int_range : start:int -> stop:int -> int Sequence.t
- val int_range_dec : start:int -> stop:int -> int Sequence.t
- val int_range_by : step:int -> int -> int -> int Sequence.t
- val bools : bool Sequence.t
- val of_set :
- (module Set.S with type elt = 'a and type t = 'b) -> 'b -> 'a Sequence.t
- val to_set :
- (module Set.S with type elt = 'a and type t = 'b) -> 'a Sequence.t -> 'b
- type 'a gen = unit -> 'a option
- type 'a klist = unit -> [ `Cons of 'a * 'a Sequence.klist | `Nil ]
- val of_gen : 'a Sequence.gen -> 'a Sequence.t
- val to_gen : 'a Sequence.t -> 'a Sequence.gen
- val of_klist : 'a Sequence.klist -> 'a Sequence.t
- val to_klist : 'a Sequence.t -> 'a Sequence.klist
- module Set :
- sig
- module type S =
- sig
- type elt
- type t
- val empty : t
- val is_empty : t -> bool
- val mem : elt -> t -> bool
- val add : elt -> t -> t
- val singleton : elt -> t
- val remove : elt -> t -> t
- val union : t -> t -> t
- val inter : t -> t -> t
- val diff : t -> t -> t
- val compare : t -> t -> int
- val equal : t -> t -> bool
- val subset : t -> t -> bool
- val iter : (elt -> unit) -> t -> unit
- val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
- val for_all : (elt -> bool) -> t -> bool
- val exists : (elt -> bool) -> t -> bool
- val filter : (elt -> bool) -> t -> t
- val partition : (elt -> bool) -> t -> t * t
- val cardinal : t -> int
- val elements : t -> elt list
- val min_elt : t -> elt
- val max_elt : t -> elt
- val choose : t -> elt
- val split : elt -> t -> t * bool * t
- val find : elt -> t -> elt
- val of_seq : elt Sequence.sequence -> Sequence.t
- val to_seq : Sequence.t -> elt Sequence.sequence
- val to_list : Sequence.t -> elt list
- val of_list : elt list -> Sequence.t
- end
- module Adapt :
- functor (X : Set.S) ->
- sig
- type elt = X.elt
- type t = X.t
- val empty : t
- val is_empty : t -> bool
- val mem : elt -> t -> bool
- val add : elt -> t -> t
- val singleton : elt -> t
- val remove : elt -> t -> t
- val union : t -> t -> t
- val inter : t -> t -> t
- val diff : t -> t -> t
- val compare : t -> t -> int
- val equal : t -> t -> bool
- val subset : t -> t -> bool
- val iter : (elt -> unit) -> t -> unit
- val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
- val for_all : (elt -> bool) -> t -> bool
- val exists : (elt -> bool) -> t -> bool
- val filter : (elt -> bool) -> t -> t
- val partition : (elt -> bool) -> t -> t * t
- val cardinal : t -> int
- val elements : t -> elt list
- val min_elt : t -> elt
- val max_elt : t -> elt
- val choose : t -> elt
- val split : elt -> t -> t * bool * t
- val find : elt -> t -> elt
- val of_seq : elt sequence -> t
- val to_seq : t -> elt sequence
- val to_list : t -> elt list
- val of_list : elt list -> t
- end
- module Make :
- functor (X : Set.OrderedType) ->
- sig
- type elt = X.t
- type t
- val empty : t
- val is_empty : t -> bool
- val mem : elt -> t -> bool
- val add : elt -> t -> t
- val singleton : elt -> t
- val remove : elt -> t -> t
- val union : t -> t -> t
- val inter : t -> t -> t
- val diff : t -> t -> t
- val compare : t -> t -> int
- val equal : t -> t -> bool
- val subset : t -> t -> bool
- val iter : (elt -> unit) -> t -> unit
- val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
- val for_all : (elt -> bool) -> t -> bool
- val exists : (elt -> bool) -> t -> bool
- val filter : (elt -> bool) -> t -> t
- val partition : (elt -> bool) -> t -> t * t
- val cardinal : t -> int
- val elements : t -> elt list
- val min_elt : t -> elt
- val max_elt : t -> elt
- val choose : t -> elt
- val split : elt -> t -> t * bool * t
- val find : elt -> t -> elt
- val of_seq : elt sequence -> t
- val to_seq : t -> elt sequence
- val to_list : t -> elt list
- val of_list : elt list -> t
- end
- end
- module Map :
- sig
- module type S =
- sig
- type key
- type +'a t
- val empty : 'a t
- val is_empty : 'a t -> bool
- val mem : key -> 'a t -> bool
- val add : key -> 'a -> 'a t -> 'a t
- val singleton : key -> 'a -> 'a t
- val remove : key -> 'a t -> 'a t
- val merge :
- (key -> 'a option -> 'b option -> 'c option) ->
- 'a t -> 'b t -> 'c t
- val union : (key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
- val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
- val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
- val iter : (key -> 'a -> unit) -> 'a t -> unit
- val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
- val for_all : (key -> 'a -> bool) -> 'a t -> bool
- val exists : (key -> 'a -> bool) -> 'a t -> bool
- val filter : (key -> 'a -> bool) -> 'a t -> 'a t
- val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
- val cardinal : 'a t -> int
- val bindings : 'a t -> (key * 'a) list
- val min_binding : 'a t -> key * 'a
- val max_binding : 'a t -> key * 'a
- val choose : 'a t -> key * 'a
- val split : key -> 'a t -> 'a t * 'a option * 'a t
- val find : key -> 'a t -> 'a
- val map : ('a -> 'b) -> 'a t -> 'b t
- val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
- val to_seq : 'a Sequence.t -> (key * 'a) Sequence.sequence
- val of_seq : (key * 'a) Sequence.sequence -> 'a Sequence.t
- val keys : 'a Sequence.t -> key Sequence.sequence
- val values : 'a Sequence.t -> 'a Sequence.sequence
- val to_list : 'a Sequence.t -> (key * 'a) list
- val of_list : (key * 'a) list -> 'a Sequence.t
- end
- module Adapt :
- functor (M : Map.S) ->
- sig
- type key = M.key
- type 'a t = 'a M.t
- val empty : 'a t
- val is_empty : 'a t -> bool
- val mem : key -> 'a t -> bool
- val add : key -> 'a -> 'a t -> 'a t
- val singleton : key -> 'a -> 'a t
- val remove : key -> 'a t -> 'a t
- val merge :
- (key -> 'a option -> 'b option -> 'c option) ->
- 'a t -> 'b t -> 'c t
- val union :
- (key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
- val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
- val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
- val iter : (key -> 'a -> unit) -> 'a t -> unit
- val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
- val for_all : (key -> 'a -> bool) -> 'a t -> bool
- val exists : (key -> 'a -> bool) -> 'a t -> bool
- val filter : (key -> 'a -> bool) -> 'a t -> 'a t
- val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
- val cardinal : 'a t -> int
- val bindings : 'a t -> (key * 'a) list
- val min_binding : 'a t -> key * 'a
- val max_binding : 'a t -> key * 'a
- val choose : 'a t -> key * 'a
- val split : key -> 'a t -> 'a t * 'a option * 'a t
- val find : key -> 'a t -> 'a
- val map : ('a -> 'b) -> 'a t -> 'b t
- val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
- val to_seq : 'a t -> (key * 'a) sequence
- val of_seq : (key * 'a) sequence -> 'a t
- val keys : 'a t -> key sequence
- val values : 'a t -> 'a sequence
- val to_list : 'a t -> (key * 'a) list
- val of_list : (key * 'a) list -> 'a t
- end
- module Make :
- functor (V : Map.OrderedType) ->
- sig
- type key = V.t
- type +'a t
- val empty : 'a t
- val is_empty : 'a t -> bool
- val mem : key -> 'a t -> bool
- val add : key -> 'a -> 'a t -> 'a t
- val singleton : key -> 'a -> 'a t
- val remove : key -> 'a t -> 'a t
- val merge :
- (key -> 'a option -> 'b option -> 'c option) ->
- 'a t -> 'b t -> 'c t
- val union :
- (key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
- val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
- val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
- val iter : (key -> 'a -> unit) -> 'a t -> unit
- val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
- val for_all : (key -> 'a -> bool) -> 'a t -> bool
- val exists : (key -> 'a -> bool) -> 'a t -> bool
- val filter : (key -> 'a -> bool) -> 'a t -> 'a t
- val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
- val cardinal : 'a t -> int
- val bindings : 'a t -> (key * 'a) list
- val min_binding : 'a t -> key * 'a
- val max_binding : 'a t -> key * 'a
- val choose : 'a t -> key * 'a
- val split : key -> 'a t -> 'a t * 'a option * 'a t
- val find : key -> 'a t -> 'a
- val map : ('a -> 'b) -> 'a t -> 'b t
- val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
- val to_seq : 'a t -> (key * 'a) sequence
- val of_seq : (key * 'a) sequence -> 'a t
- val keys : 'a t -> key sequence
- val values : 'a t -> 'a sequence
- val to_list : 'a t -> (key * 'a) list
- val of_list : (key * 'a) list -> 'a t
- end
- end
- val random_int : int -> int Sequence.t
- val random_bool : bool Sequence.t
- val random_float : float -> float Sequence.t
- val random_array : 'a array -> 'a Sequence.t
- val random_list : 'a list -> 'a Sequence.t
- val shuffle : 'a Sequence.t -> 'a Sequence.t
- val shuffle_buffer : int -> 'a Sequence.t -> 'a Sequence.t
- val sample : int -> 'a Sequence.t -> 'a array
- module Infix :
- sig
- val ( -- ) : int -> int -> int Sequence.t
- val ( --^ ) : int -> int -> int Sequence.t
- val ( >>= ) : 'a Sequence.t -> ('a -> 'b Sequence.t) -> 'b Sequence.t
- val ( >|= ) : 'a Sequence.t -> ('a -> 'b) -> 'b Sequence.t
- val ( <*> ) : ('a -> 'b) Sequence.t -> 'a Sequence.t -> 'b Sequence.t
- val ( <+> ) : 'a Sequence.t -> 'a Sequence.t -> 'a Sequence.t
- end
- val ( -- ) : int -> int -> int t
- val ( --^ ) : int -> int -> int t
- val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
- val ( >|= ) : 'a t -> ('a -> 'b) -> 'b t
- val ( <*> ) : ('a -> 'b) t -> 'a t -> 'b t
- val ( <+> ) : 'a t -> 'a t -> 'a t
- val pp_seq :
- ?sep:string ->
- (Format.formatter -> 'a -> unit) ->
- Format.formatter -> 'a Sequence.t -> unit
- val pp_buf :
- ?sep:string ->
- (Buffer.t -> 'a -> unit) -> Buffer.t -> 'a Sequence.t -> unit
- val to_string : ?sep:string -> ('a -> string) -> 'a Sequence.t -> string
- module IO :
- sig
- val lines_of :
- ?mode:int ->
- ?flags:Pervasives.open_flag list -> string -> string Sequence.t
- val chunks_of :
- ?mode:int ->
- ?flags:Pervasives.open_flag list ->
- ?size:int -> string -> string Sequence.t
- val write_to :
- ?mode:int ->
- ?flags:Pervasives.open_flag list ->
- string -> string Sequence.t -> unit
- val write_bytes_to :
- ?mode:int ->
- ?flags:Pervasives.open_flag list ->
- string -> Bytes.t Sequence.t -> unit
- val write_lines :
- ?mode:int ->
- ?flags:Pervasives.open_flag list ->
- string -> string Sequence.t -> unit
- val write_bytes_lines :
- ?mode:int ->
- ?flags:Pervasives.open_flag list ->
- string -> Bytes.t Sequence.t -> unit
- end
+sig
+ type 'a t = ('a -> unit) -> unit
+ type 'a sequence = 'a Sequence.t
+ type ('a, 'b) t2 = ('a -> 'b -> unit) -> unit
+ type 'a equal = 'a -> 'a -> bool
+ type 'a hash = 'a -> int
+ val from_iter : (('a -> unit) -> unit) -> 'a Sequence.t
+ val from_fun : (unit -> 'a option) -> 'a Sequence.t
+ val empty : 'a Sequence.t
+ val singleton : 'a -> 'a Sequence.t
+ val doubleton : 'a -> 'a -> 'a Sequence.t
+ val init : (int -> 'a) -> 'a Sequence.t
+ val cons : 'a -> 'a Sequence.t -> 'a Sequence.t
+ val snoc : 'a Sequence.t -> 'a -> 'a Sequence.t
+ val return : 'a -> 'a Sequence.t
+ val pure : 'a -> 'a Sequence.t
+ val repeat : 'a -> 'a Sequence.t
+ val iterate : ('a -> 'a) -> 'a -> 'a Sequence.t
+ val forever : (unit -> 'b) -> 'b Sequence.t
+ val cycle : 'a Sequence.t -> 'a Sequence.t
+ val iter : ('a -> unit) -> 'a Sequence.t -> unit
+ val iteri : (int -> 'a -> unit) -> 'a Sequence.t -> unit
+ val fold : ('a -> 'b -> 'a) -> 'a -> 'b Sequence.t -> 'a
+ val foldi : ('a -> int -> 'b -> 'a) -> 'a -> 'b Sequence.t -> 'a
+ val fold_map :
+ ('acc -> 'a -> 'acc * 'b) -> 'acc -> 'a Sequence.t -> 'b Sequence.t
+ val fold_filter_map :
+ ('acc -> 'a -> 'acc * 'b option) ->
+ 'acc -> 'a Sequence.t -> 'b Sequence.t
+ val map : ('a -> 'b) -> 'a Sequence.t -> 'b Sequence.t
+ val mapi : (int -> 'a -> 'b) -> 'a Sequence.t -> 'b Sequence.t
+ val map_by_2 : ('a -> 'a -> 'a) -> 'a Sequence.t -> 'a Sequence.t
+ val for_all : ('a -> bool) -> 'a Sequence.t -> bool
+ val exists : ('a -> bool) -> 'a Sequence.t -> bool
+ val mem : ?eq:('a -> 'a -> bool) -> 'a -> 'a Sequence.t -> bool
+ val find : ('a -> 'b option) -> 'a Sequence.t -> 'b option
+ val find_map : ('a -> 'b option) -> 'a Sequence.t -> 'b option
+ val findi : (int -> 'a -> 'b option) -> 'a Sequence.t -> 'b option
+ val find_mapi : (int -> 'a -> 'b option) -> 'a Sequence.t -> 'b option
+ val find_pred : ('a -> bool) -> 'a Sequence.t -> 'a option
+ val find_pred_exn : ('a -> bool) -> 'a Sequence.t -> 'a
+ val length : 'a Sequence.t -> int
+ val is_empty : 'a Sequence.t -> bool
+ val filter : ('a -> bool) -> 'a Sequence.t -> 'a Sequence.t
+ val append : 'a Sequence.t -> 'a Sequence.t -> 'a Sequence.t
+ val concat : 'a Sequence.t Sequence.t -> 'a Sequence.t
+ val flatten : 'a Sequence.t Sequence.t -> 'a Sequence.t
+ val flat_map : ('a -> 'b Sequence.t) -> 'a Sequence.t -> 'b Sequence.t
+ val flat_map_l : ('a -> 'b list) -> 'a Sequence.t -> 'b Sequence.t
+ val filter_map : ('a -> 'b option) -> 'a Sequence.t -> 'b Sequence.t
+ val intersperse : 'a -> 'a Sequence.t -> 'a Sequence.t
+ val persistent : 'a Sequence.t -> 'a Sequence.t
+ val persistent_lazy : 'a Sequence.t -> 'a Sequence.t
+ val sort : ?cmp:('a -> 'a -> int) -> 'a Sequence.t -> 'a Sequence.t
+ val sort_uniq : ?cmp:('a -> 'a -> int) -> 'a Sequence.t -> 'a Sequence.t
+ val sorted : ?cmp:('a -> 'a -> int) -> 'a Sequence.t -> bool
+ val group_succ_by :
+ ?eq:('a -> 'a -> bool) -> 'a Sequence.t -> 'a list Sequence.t
+ val group_by :
+ ?hash:('a -> int) ->
+ ?eq:('a -> 'a -> bool) -> 'a Sequence.t -> 'a list Sequence.t
+ val count :
+ ?hash:('a -> int) ->
+ ?eq:('a -> 'a -> bool) -> 'a Sequence.t -> ('a * int) Sequence.t
+ val uniq : ?eq:('a -> 'a -> bool) -> 'a Sequence.t -> 'a Sequence.t
+ val product : 'a Sequence.t -> 'b Sequence.t -> ('a * 'b) Sequence.t
+ val diagonal_l : 'a list -> ('a * 'a) Sequence.t
+ val diagonal : 'a Sequence.t -> ('a * 'a) Sequence.t
+ val product2 : 'a Sequence.t -> 'b Sequence.t -> ('a, 'b) Sequence.t2
+ val join :
+ join_row:('a -> 'b -> 'c option) ->
+ 'a Sequence.t -> 'b Sequence.t -> 'c Sequence.t
+ val join_by :
+ ?eq:'key Sequence.equal ->
+ ?hash:'key Sequence.hash ->
+ ('a -> 'key) ->
+ ('b -> 'key) ->
+ merge:('key -> 'a -> 'b -> 'c option) ->
+ 'a Sequence.t -> 'b Sequence.t -> 'c Sequence.t
+ val join_all_by :
+ ?eq:'key Sequence.equal ->
+ ?hash:'key Sequence.hash ->
+ ('a -> 'key) ->
+ ('b -> 'key) ->
+ merge:('key -> 'a list -> 'b list -> 'c option) ->
+ 'a Sequence.t -> 'b Sequence.t -> 'c Sequence.t
+ val group_join_by :
+ ?eq:'a Sequence.equal ->
+ ?hash:'a Sequence.hash ->
+ ('b -> 'a) -> 'a Sequence.t -> 'b Sequence.t -> ('a * 'b list) Sequence.t
+ val inter :
+ ?eq:'a Sequence.equal ->
+ ?hash:'a Sequence.hash -> 'a Sequence.t -> 'a Sequence.t -> 'a Sequence.t
+ val union :
+ ?eq:'a Sequence.equal ->
+ ?hash:'a Sequence.hash -> 'a Sequence.t -> 'a Sequence.t -> 'a Sequence.t
+ val diff :
+ ?eq:'a Sequence.equal ->
+ ?hash:'a Sequence.hash -> 'a Sequence.t -> 'a Sequence.t -> 'a Sequence.t
+ val subset :
+ ?eq:'a Sequence.equal ->
+ ?hash:'a Sequence.hash -> 'a Sequence.t -> 'a Sequence.t -> bool
+ val unfoldr : ('b -> ('a * 'b) option) -> 'b -> 'a Sequence.t
+ val scan : ('b -> 'a -> 'b) -> 'b -> 'a Sequence.t -> 'b Sequence.t
+ val max : ?lt:('a -> 'a -> bool) -> 'a Sequence.t -> 'a option
+ val max_exn : ?lt:('a -> 'a -> bool) -> 'a Sequence.t -> 'a
+ val min : ?lt:('a -> 'a -> bool) -> 'a Sequence.t -> 'a option
+ val min_exn : ?lt:('a -> 'a -> bool) -> 'a Sequence.t -> 'a
+ val head : 'a Sequence.t -> 'a option
+ val head_exn : 'a Sequence.t -> 'a
+ val take : int -> 'a Sequence.t -> 'a Sequence.t
+ val take_while : ('a -> bool) -> 'a Sequence.t -> 'a Sequence.t
+ val fold_while :
+ ('a -> 'b -> 'a * [ `Continue | `Stop ]) -> 'a -> 'b Sequence.t -> 'a
+ val drop : int -> 'a Sequence.t -> 'a Sequence.t
+ val drop_while : ('a -> bool) -> 'a Sequence.t -> 'a Sequence.t
+ val rev : 'a Sequence.t -> 'a Sequence.t
+ val empty2 : ('a, 'b) Sequence.t2
+ val is_empty2 : ('a, 'b) Sequence.t2 -> bool
+ val length2 : ('a, 'b) Sequence.t2 -> int
+ val zip : ('a, 'b) Sequence.t2 -> ('a * 'b) Sequence.t
+ val unzip : ('a * 'b) Sequence.t -> ('a, 'b) Sequence.t2
+ val zip_i : 'a Sequence.t -> (int, 'a) Sequence.t2
+ val fold2 : ('c -> 'a -> 'b -> 'c) -> 'c -> ('a, 'b) Sequence.t2 -> 'c
+ val iter2 : ('a -> 'b -> unit) -> ('a, 'b) Sequence.t2 -> unit
+ val map2 : ('a -> 'b -> 'c) -> ('a, 'b) Sequence.t2 -> 'c Sequence.t
+ val map2_2 :
+ ('a -> 'b -> 'c) ->
+ ('a -> 'b -> 'd) -> ('a, 'b) Sequence.t2 -> ('c, 'd) Sequence.t2
+ val to_list : 'a Sequence.t -> 'a list
+ val to_rev_list : 'a Sequence.t -> 'a list
+ val of_list : 'a list -> 'a Sequence.t
+ val on_list : ('a Sequence.t -> 'b Sequence.t) -> 'a list -> 'b list
+ val to_opt : 'a Sequence.t -> 'a option
+ val to_array : 'a Sequence.t -> 'a array
+ val of_array : 'a array -> 'a Sequence.t
+ val of_array_i : 'a array -> (int * 'a) Sequence.t
+ val of_array2 : 'a array -> (int, 'a) Sequence.t2
+ val array_slice : 'a array -> int -> int -> 'a Sequence.t
+ val of_opt : 'a option -> 'a Sequence.t
+ val of_stream : 'a Stream.t -> 'a Sequence.t
+ val to_stream : 'a Sequence.t -> 'a Stream.t
+ val to_stack : 'a Stack.t -> 'a Sequence.t -> unit
+ val of_stack : 'a Stack.t -> 'a Sequence.t
+ val to_queue : 'a Queue.t -> 'a Sequence.t -> unit
+ val of_queue : 'a Queue.t -> 'a Sequence.t
+ val hashtbl_add : ('a, 'b) Hashtbl.t -> ('a * 'b) Sequence.t -> unit
+ val hashtbl_replace : ('a, 'b) Hashtbl.t -> ('a * 'b) Sequence.t -> unit
+ val to_hashtbl : ('a * 'b) Sequence.t -> ('a, 'b) Hashtbl.t
+ val to_hashtbl2 : ('a, 'b) Sequence.t2 -> ('a, 'b) Hashtbl.t
+ val of_hashtbl : ('a, 'b) Hashtbl.t -> ('a * 'b) Sequence.t
+ val of_hashtbl2 : ('a, 'b) Hashtbl.t -> ('a, 'b) Sequence.t2
+ val hashtbl_keys : ('a, 'b) Hashtbl.t -> 'a Sequence.t
+ val hashtbl_values : ('a, 'b) Hashtbl.t -> 'b Sequence.t
+ val of_str : string -> char Sequence.t
+ val to_str : char Sequence.t -> string
+ val concat_str : string Sequence.t -> string
+ exception OneShotSequence
+ val of_in_channel : Pervasives.in_channel -> char Sequence.t
+ val to_buffer : char Sequence.t -> Buffer.t -> unit
+ val int_range : start:int -> stop:int -> int Sequence.t
+ val int_range_dec : start:int -> stop:int -> int Sequence.t
+ val int_range_by : step:int -> int -> int -> int Sequence.t
+ val bools : bool Sequence.t
+ val of_set :
+ (module Set.S with type elt = 'a and type t = 'b) -> 'b -> 'a Sequence.t
+ val to_set :
+ (module Set.S with type elt = 'a and type t = 'b) -> 'a Sequence.t -> 'b
+ type 'a gen = unit -> 'a option
+ type 'a klist = unit -> [ `Cons of 'a * 'a Sequence.klist | `Nil ]
+ val of_gen : 'a Sequence.gen -> 'a Sequence.t
+ val to_gen : 'a Sequence.t -> 'a Sequence.gen
+ val of_klist : 'a Sequence.klist -> 'a Sequence.t
+ val to_klist : 'a Sequence.t -> 'a Sequence.klist
+ module Set :
+ sig
+ module type S =
+ sig
+ type elt
+ type t
+ val empty : t
+ val is_empty : t -> bool
+ val mem : elt -> t -> bool
+ val add : elt -> t -> t
+ val singleton : elt -> t
+ val remove : elt -> t -> t
+ val union : t -> t -> t
+ val inter : t -> t -> t
+ val diff : t -> t -> t
+ val compare : t -> t -> int
+ val equal : t -> t -> bool
+ val subset : t -> t -> bool
+ val iter : (elt -> unit) -> t -> unit
+ val map : (elt -> elt) -> t -> t
+ val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
+ val for_all : (elt -> bool) -> t -> bool
+ val exists : (elt -> bool) -> t -> bool
+ val filter : (elt -> bool) -> t -> t
+ val partition : (elt -> bool) -> t -> t * t
+ val cardinal : t -> int
+ val elements : t -> elt list
+ val min_elt : t -> elt
+ val max_elt : t -> elt
+ val choose : t -> elt
+ val split : elt -> t -> t * bool * t
+ val find : elt -> t -> elt
+ val of_seq : elt Sequence.sequence -> Sequence.t
+ val to_seq : Sequence.t -> elt Sequence.sequence
+ val to_list : Sequence.t -> elt list
+ val of_list : elt list -> Sequence.t
+ end
+ module Adapt :
+ functor (X : Set.S) ->
+ sig
+ type elt = X.elt
+ type t = X.t
+ val empty : t
+ val is_empty : t -> bool
+ val mem : elt -> t -> bool
+ val add : elt -> t -> t
+ val singleton : elt -> t
+ val remove : elt -> t -> t
+ val union : t -> t -> t
+ val inter : t -> t -> t
+ val diff : t -> t -> t
+ val compare : t -> t -> int
+ val equal : t -> t -> bool
+ val subset : t -> t -> bool
+ val iter : (elt -> unit) -> t -> unit
+ val map : (elt -> elt) -> t -> t
+ val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
+ val for_all : (elt -> bool) -> t -> bool
+ val exists : (elt -> bool) -> t -> bool
+ val filter : (elt -> bool) -> t -> t
+ val partition : (elt -> bool) -> t -> t * t
+ val cardinal : t -> int
+ val elements : t -> elt list
+ val min_elt : t -> elt
+ val max_elt : t -> elt
+ val choose : t -> elt
+ val split : elt -> t -> t * bool * t
+ val find : elt -> t -> elt
+ val of_seq : elt sequence -> t
+ val to_seq : t -> elt sequence
+ val to_list : t -> elt list
+ val of_list : elt list -> t
+ end
+ module Make :
+ functor (X : Set.OrderedType) ->
+ sig
+ type elt = X.t
+ type t
+ val empty : t
+ val is_empty : t -> bool
+ val mem : elt -> t -> bool
+ val add : elt -> t -> t
+ val singleton : elt -> t
+ val remove : elt -> t -> t
+ val union : t -> t -> t
+ val inter : t -> t -> t
+ val diff : t -> t -> t
+ val compare : t -> t -> int
+ val equal : t -> t -> bool
+ val subset : t -> t -> bool
+ val iter : (elt -> unit) -> t -> unit
+ val map : (elt -> elt) -> t -> t
+ val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
+ val for_all : (elt -> bool) -> t -> bool
+ val exists : (elt -> bool) -> t -> bool
+ val filter : (elt -> bool) -> t -> t
+ val partition : (elt -> bool) -> t -> t * t
+ val cardinal : t -> int
+ val elements : t -> elt list
+ val min_elt : t -> elt
+ val max_elt : t -> elt
+ val choose : t -> elt
+ val split : elt -> t -> t * bool * t
+ val find : elt -> t -> elt
+ val of_seq : elt sequence -> t
+ val to_seq : t -> elt sequence
+ val to_list : t -> elt list
+ val of_list : elt list -> t
+ end
+ end
+ module Map :
+ sig
+ module type S =
+ sig
+ type key
+ type +'a t
+ val empty : 'a t
+ val is_empty : 'a t -> bool
+ val mem : key -> 'a t -> bool
+ val add : key -> 'a -> 'a t -> 'a t
+ val singleton : key -> 'a -> 'a t
+ val remove : key -> 'a t -> 'a t
+ val merge :
+ (key -> 'a option -> 'b option -> 'c option) ->
+ 'a t -> 'b t -> 'c t
+ val union : (key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
+ val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
+ val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
+ val iter : (key -> 'a -> unit) -> 'a t -> unit
+ val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
+ val for_all : (key -> 'a -> bool) -> 'a t -> bool
+ val exists : (key -> 'a -> bool) -> 'a t -> bool
+ val filter : (key -> 'a -> bool) -> 'a t -> 'a t
+ val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
+ val cardinal : 'a t -> int
+ val bindings : 'a t -> (key * 'a) list
+ val min_binding : 'a t -> key * 'a
+ val max_binding : 'a t -> key * 'a
+ val choose : 'a t -> key * 'a
+ val split : key -> 'a t -> 'a t * 'a option * 'a t
+ val find : key -> 'a t -> 'a
+ val map : ('a -> 'b) -> 'a t -> 'b t
+ val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
+ val to_seq : 'a Sequence.t -> (key * 'a) Sequence.sequence
+ val of_seq : (key * 'a) Sequence.sequence -> 'a Sequence.t
+ val keys : 'a Sequence.t -> key Sequence.sequence
+ val values : 'a Sequence.t -> 'a Sequence.sequence
+ val to_list : 'a Sequence.t -> (key * 'a) list
+ val of_list : (key * 'a) list -> 'a Sequence.t
+ end
+ module Adapt :
+ functor (M : Map.S) ->
+ sig
+ type key = M.key
+ type 'a t = 'a M.t
+ val empty : 'a t
+ val is_empty : 'a t -> bool
+ val mem : key -> 'a t -> bool
+ val add : key -> 'a -> 'a t -> 'a t
+ val singleton : key -> 'a -> 'a t
+ val remove : key -> 'a t -> 'a t
+ val merge :
+ (key -> 'a option -> 'b option -> 'c option) ->
+ 'a t -> 'b t -> 'c t
+ val union :
+ (key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
+ val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
+ val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
+ val iter : (key -> 'a -> unit) -> 'a t -> unit
+ val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
+ val for_all : (key -> 'a -> bool) -> 'a t -> bool
+ val exists : (key -> 'a -> bool) -> 'a t -> bool
+ val filter : (key -> 'a -> bool) -> 'a t -> 'a t
+ val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
+ val cardinal : 'a t -> int
+ val bindings : 'a t -> (key * 'a) list
+ val min_binding : 'a t -> key * 'a
+ val max_binding : 'a t -> key * 'a
+ val choose : 'a t -> key * 'a
+ val split : key -> 'a t -> 'a t * 'a option * 'a t
+ val find : key -> 'a t -> 'a
+ val map : ('a -> 'b) -> 'a t -> 'b t
+ val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
+ val to_seq : 'a t -> (key * 'a) sequence
+ val of_seq : (key * 'a) sequence -> 'a t
+ val keys : 'a t -> key sequence
+ val values : 'a t -> 'a sequence
+ val to_list : 'a t -> (key * 'a) list
+ val of_list : (key * 'a) list -> 'a t
+ end
+ module Make :
+ functor (V : Map.OrderedType) ->
+ sig
+ type key = V.t
+ type +'a t
+ val empty : 'a t
+ val is_empty : 'a t -> bool
+ val mem : key -> 'a t -> bool
+ val add : key -> 'a -> 'a t -> 'a t
+ val singleton : key -> 'a -> 'a t
+ val remove : key -> 'a t -> 'a t
+ val merge :
+ (key -> 'a option -> 'b option -> 'c option) ->
+ 'a t -> 'b t -> 'c t
+ val union :
+ (key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
+ val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
+ val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
+ val iter : (key -> 'a -> unit) -> 'a t -> unit
+ val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
+ val for_all : (key -> 'a -> bool) -> 'a t -> bool
+ val exists : (key -> 'a -> bool) -> 'a t -> bool
+ val filter : (key -> 'a -> bool) -> 'a t -> 'a t
+ val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
+ val cardinal : 'a t -> int
+ val bindings : 'a t -> (key * 'a) list
+ val min_binding : 'a t -> key * 'a
+ val max_binding : 'a t -> key * 'a
+ val choose : 'a t -> key * 'a
+ val split : key -> 'a t -> 'a t * 'a option * 'a t
+ val find : key -> 'a t -> 'a
+ val map : ('a -> 'b) -> 'a t -> 'b t
+ val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
+ val to_seq : 'a t -> (key * 'a) sequence
+ val of_seq : (key * 'a) sequence -> 'a t
+ val keys : 'a t -> key sequence
+ val values : 'a t -> 'a sequence
+ val to_list : 'a t -> (key * 'a) list
+ val of_list : (key * 'a) list -> 'a t
+ end
+ end
+ val random_int : int -> int Sequence.t
+ val random_bool : bool Sequence.t
+ val random_float : float -> float Sequence.t
+ val random_array : 'a array -> 'a Sequence.t
+ val random_list : 'a list -> 'a Sequence.t
+ val shuffle : 'a Sequence.t -> 'a Sequence.t
+ val shuffle_buffer : int -> 'a Sequence.t -> 'a Sequence.t
+ val sample : int -> 'a Sequence.t -> 'a array
+ module Infix :
+ sig
+ val ( -- ) : int -> int -> int Sequence.t
+ val ( --^ ) : int -> int -> int Sequence.t
+ val ( >>= ) : 'a Sequence.t -> ('a -> 'b Sequence.t) -> 'b Sequence.t
+ val ( >|= ) : 'a Sequence.t -> ('a -> 'b) -> 'b Sequence.t
+ val ( <*> ) : ('a -> 'b) Sequence.t -> 'a Sequence.t -> 'b Sequence.t
+ val ( <+> ) : 'a Sequence.t -> 'a Sequence.t -> 'a Sequence.t
+ end
+ val ( -- ) : int -> int -> int t
+ val ( --^ ) : int -> int -> int t
+ val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
+ val ( >|= ) : 'a t -> ('a -> 'b) -> 'b t
+ val ( <*> ) : ('a -> 'b) t -> 'a t -> 'b t
+ val ( <+> ) : 'a t -> 'a t -> 'a t
+ val pp_seq :
+ ?sep:string ->
+ (Format.formatter -> 'a -> unit) ->
+ Format.formatter -> 'a Sequence.t -> unit
+ val pp_buf :
+ ?sep:string ->
+ (Buffer.t -> 'a -> unit) -> Buffer.t -> 'a Sequence.t -> unit
+ val to_string : ?sep:string -> ('a -> string) -> 'a Sequence.t -> string
+ module IO :
+ sig
+ val lines_of :
+ ?mode:int ->
+ ?flags:Pervasives.open_flag list -> string -> string Sequence.t
+ val chunks_of :
+ ?mode:int ->
+ ?flags:Pervasives.open_flag list ->
+ ?size:int -> string -> string Sequence.t
+ val write_to :
+ ?mode:int ->
+ ?flags:Pervasives.open_flag list ->
+ string -> string Sequence.t -> unit
+ val write_bytes_to :
+ ?mode:int ->
+ ?flags:Pervasives.open_flag list ->
+ string -> Bytes.t Sequence.t -> unit
+ val write_lines :
+ ?mode:int ->
+ ?flags:Pervasives.open_flag list ->
+ string -> string Sequence.t -> unit
+ val write_bytes_lines :
+ ?mode:int ->
+ ?flags:Pervasives.open_flag list ->
+ string -> Bytes.t Sequence.t -> unit
+ end
end
\ No newline at end of file
diff --git a/api/type_SequenceLabels.IO.html b/api/type_SequenceLabels.IO.html
new file mode 100644
index 0000000..79e2cd1
--- /dev/null
+++ b/api/type_SequenceLabels.IO.html
@@ -0,0 +1,39 @@
+
+
+
+
+
+
+
+
+
+
+
+SequenceLabels.IO
+
+
+sig
+ val lines_of :
+ ?mode:int ->
+ ?flags:Pervasives.open_flag list -> string -> string SequenceLabels.t
+ val chunks_of :
+ ?mode:int ->
+ ?flags:Pervasives.open_flag list ->
+ ?size:int -> string -> string SequenceLabels.t
+ val write_to :
+ ?mode:int ->
+ ?flags:Pervasives.open_flag list ->
+ string -> string SequenceLabels.t -> unit
+ val write_bytes_to :
+ ?mode:int ->
+ ?flags:Pervasives.open_flag list ->
+ string -> Bytes.t SequenceLabels.t -> unit
+ val write_lines :
+ ?mode:int ->
+ ?flags:Pervasives.open_flag list ->
+ string -> string SequenceLabels.t -> unit
+ val write_bytes_lines :
+ ?mode:int ->
+ ?flags:Pervasives.open_flag list ->
+ string -> Bytes.t SequenceLabels.t -> unit
+end
\ No newline at end of file
diff --git a/api/type_SequenceLabels.Infix.html b/api/type_SequenceLabels.Infix.html
new file mode 100644
index 0000000..52db5d5
--- /dev/null
+++ b/api/type_SequenceLabels.Infix.html
@@ -0,0 +1,25 @@
+
+
+
+
+
+
+
+
+
+
+
+SequenceLabels.Infix
+
+
+sig
+ val ( -- ) : int -> int -> int SequenceLabels.t
+ val ( --^ ) : int -> int -> int SequenceLabels.t
+ val ( >>= ) :
+ 'a SequenceLabels.t -> ('a -> 'b SequenceLabels.t) -> 'b SequenceLabels.t
+ val ( >|= ) : 'a SequenceLabels.t -> ('a -> 'b) -> 'b SequenceLabels.t
+ val ( <*> ) :
+ ('a -> 'b) SequenceLabels.t -> 'a SequenceLabels.t -> 'b SequenceLabels.t
+ val ( <+> ) :
+ 'a SequenceLabels.t -> 'a SequenceLabels.t -> 'a SequenceLabels.t
+end
\ No newline at end of file
diff --git a/api/type_SequenceLabels.Map.Adapt.html b/api/type_SequenceLabels.Map.Adapt.html
new file mode 100644
index 0000000..5f4e5da
--- /dev/null
+++ b/api/type_SequenceLabels.Map.Adapt.html
@@ -0,0 +1,51 @@
+
+
+
+
+
+
+
+
+
+
+
+SequenceLabels.Map.Adapt
+
+
+functor (M : Map.S) ->
+ sig
+ type key = M.key
+ type 'a t = 'a M.t
+ val empty : 'a t
+ val is_empty : 'a t -> bool
+ val mem : key -> 'a t -> bool
+ val add : key -> 'a -> 'a t -> 'a t
+ val singleton : key -> 'a -> 'a t
+ val remove : key -> 'a t -> 'a t
+ val merge :
+ (key -> 'a option -> 'b option -> 'c option) -> 'a t -> 'b t -> 'c t
+ val union : (key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
+ val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
+ val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
+ val iter : (key -> 'a -> unit) -> 'a t -> unit
+ val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
+ val for_all : (key -> 'a -> bool) -> 'a t -> bool
+ val exists : (key -> 'a -> bool) -> 'a t -> bool
+ val filter : (key -> 'a -> bool) -> 'a t -> 'a t
+ val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
+ val cardinal : 'a t -> int
+ val bindings : 'a t -> (key * 'a) list
+ val min_binding : 'a t -> key * 'a
+ val max_binding : 'a t -> key * 'a
+ val choose : 'a t -> key * 'a
+ val split : key -> 'a t -> 'a t * 'a option * 'a t
+ val find : key -> 'a t -> 'a
+ val map : ('a -> 'b) -> 'a t -> 'b t
+ val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
+ val to_seq : 'a t -> (key * 'a) sequence
+ val of_seq : (key * 'a) sequence -> 'a t
+ val keys : 'a t -> key sequence
+ val values : 'a t -> 'a sequence
+ val to_list : 'a t -> (key * 'a) list
+ val of_list : (key * 'a) list -> 'a t
+ end
\ No newline at end of file
diff --git a/api/type_SequenceLabels.Map.Make.html b/api/type_SequenceLabels.Map.Make.html
new file mode 100644
index 0000000..47fa995
--- /dev/null
+++ b/api/type_SequenceLabels.Map.Make.html
@@ -0,0 +1,51 @@
+
+
+
+
+
+
+
+
+
+
+
+SequenceLabels.Map.Make
+
+
+functor (V : Map.OrderedType) ->
+ sig
+ type key = V.t
+ type +'a t
+ val empty : 'a t
+ val is_empty : 'a t -> bool
+ val mem : key -> 'a t -> bool
+ val add : key -> 'a -> 'a t -> 'a t
+ val singleton : key -> 'a -> 'a t
+ val remove : key -> 'a t -> 'a t
+ val merge :
+ (key -> 'a option -> 'b option -> 'c option) -> 'a t -> 'b t -> 'c t
+ val union : (key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
+ val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
+ val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
+ val iter : (key -> 'a -> unit) -> 'a t -> unit
+ val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
+ val for_all : (key -> 'a -> bool) -> 'a t -> bool
+ val exists : (key -> 'a -> bool) -> 'a t -> bool
+ val filter : (key -> 'a -> bool) -> 'a t -> 'a t
+ val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
+ val cardinal : 'a t -> int
+ val bindings : 'a t -> (key * 'a) list
+ val min_binding : 'a t -> key * 'a
+ val max_binding : 'a t -> key * 'a
+ val choose : 'a t -> key * 'a
+ val split : key -> 'a t -> 'a t * 'a option * 'a t
+ val find : key -> 'a t -> 'a
+ val map : ('a -> 'b) -> 'a t -> 'b t
+ val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
+ val to_seq : 'a t -> (key * 'a) sequence
+ val of_seq : (key * 'a) sequence -> 'a t
+ val keys : 'a t -> key sequence
+ val values : 'a t -> 'a sequence
+ val to_list : 'a t -> (key * 'a) list
+ val of_list : (key * 'a) list -> 'a t
+ end
\ No newline at end of file
diff --git a/api/type_SequenceLabels.Map.S.html b/api/type_SequenceLabels.Map.S.html
new file mode 100644
index 0000000..15a9b05
--- /dev/null
+++ b/api/type_SequenceLabels.Map.S.html
@@ -0,0 +1,50 @@
+
+
+
+
+
+
+
+
+
+
+
+SequenceLabels.Map.S
+
+
+sig
+ type key
+ type +'a t
+ val empty : 'a t
+ val is_empty : 'a t -> bool
+ val mem : key -> 'a t -> bool
+ val add : key -> 'a -> 'a t -> 'a t
+ val singleton : key -> 'a -> 'a t
+ val remove : key -> 'a t -> 'a t
+ val merge :
+ (key -> 'a option -> 'b option -> 'c option) -> 'a t -> 'b t -> 'c t
+ val union : (key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
+ val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
+ val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
+ val iter : (key -> 'a -> unit) -> 'a t -> unit
+ val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
+ val for_all : (key -> 'a -> bool) -> 'a t -> bool
+ val exists : (key -> 'a -> bool) -> 'a t -> bool
+ val filter : (key -> 'a -> bool) -> 'a t -> 'a t
+ val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
+ val cardinal : 'a t -> int
+ val bindings : 'a t -> (key * 'a) list
+ val min_binding : 'a t -> key * 'a
+ val max_binding : 'a t -> key * 'a
+ val choose : 'a t -> key * 'a
+ val split : key -> 'a t -> 'a t * 'a option * 'a t
+ val find : key -> 'a t -> 'a
+ val map : ('a -> 'b) -> 'a t -> 'b t
+ val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
+ val to_seq : 'a SequenceLabels.t -> (key * 'a) SequenceLabels.sequence
+ val of_seq : (key * 'a) SequenceLabels.sequence -> 'a SequenceLabels.t
+ val keys : 'a SequenceLabels.t -> key SequenceLabels.sequence
+ val values : 'a SequenceLabels.t -> 'a SequenceLabels.sequence
+ val to_list : 'a SequenceLabels.t -> (key * 'a) list
+ val of_list : (key * 'a) list -> 'a SequenceLabels.t
+end
\ No newline at end of file
diff --git a/api/type_SequenceLabels.Map.html b/api/type_SequenceLabels.Map.html
new file mode 100644
index 0000000..f7f1675
--- /dev/null
+++ b/api/type_SequenceLabels.Map.html
@@ -0,0 +1,131 @@
+
+
+
+
+
+
+
+
+
+
+
+SequenceLabels.Map
+
+
+sig
+ module type S =
+ sig
+ type key
+ type +'a t
+ val empty : 'a t
+ val is_empty : 'a t -> bool
+ val mem : key -> 'a t -> bool
+ val add : key -> 'a -> 'a t -> 'a t
+ val singleton : key -> 'a -> 'a t
+ val remove : key -> 'a t -> 'a t
+ val merge :
+ (key -> 'a option -> 'b option -> 'c option) -> 'a t -> 'b t -> 'c t
+ val union : (key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
+ val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
+ val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
+ val iter : (key -> 'a -> unit) -> 'a t -> unit
+ val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
+ val for_all : (key -> 'a -> bool) -> 'a t -> bool
+ val exists : (key -> 'a -> bool) -> 'a t -> bool
+ val filter : (key -> 'a -> bool) -> 'a t -> 'a t
+ val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
+ val cardinal : 'a t -> int
+ val bindings : 'a t -> (key * 'a) list
+ val min_binding : 'a t -> key * 'a
+ val max_binding : 'a t -> key * 'a
+ val choose : 'a t -> key * 'a
+ val split : key -> 'a t -> 'a t * 'a option * 'a t
+ val find : key -> 'a t -> 'a
+ val map : ('a -> 'b) -> 'a t -> 'b t
+ val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
+ val to_seq : 'a SequenceLabels.t -> (key * 'a) SequenceLabels.sequence
+ val of_seq : (key * 'a) SequenceLabels.sequence -> 'a SequenceLabels.t
+ val keys : 'a SequenceLabels.t -> key SequenceLabels.sequence
+ val values : 'a SequenceLabels.t -> 'a SequenceLabels.sequence
+ val to_list : 'a SequenceLabels.t -> (key * 'a) list
+ val of_list : (key * 'a) list -> 'a SequenceLabels.t
+ end
+ module Adapt :
+ functor (M : Map.S) ->
+ sig
+ type key = M.key
+ type 'a t = 'a M.t
+ val empty : 'a t
+ val is_empty : 'a t -> bool
+ val mem : key -> 'a t -> bool
+ val add : key -> 'a -> 'a t -> 'a t
+ val singleton : key -> 'a -> 'a t
+ val remove : key -> 'a t -> 'a t
+ val merge :
+ (key -> 'a option -> 'b option -> 'c option) ->
+ 'a t -> 'b t -> 'c t
+ val union : (key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
+ val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
+ val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
+ val iter : (key -> 'a -> unit) -> 'a t -> unit
+ val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
+ val for_all : (key -> 'a -> bool) -> 'a t -> bool
+ val exists : (key -> 'a -> bool) -> 'a t -> bool
+ val filter : (key -> 'a -> bool) -> 'a t -> 'a t
+ val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
+ val cardinal : 'a t -> int
+ val bindings : 'a t -> (key * 'a) list
+ val min_binding : 'a t -> key * 'a
+ val max_binding : 'a t -> key * 'a
+ val choose : 'a t -> key * 'a
+ val split : key -> 'a t -> 'a t * 'a option * 'a t
+ val find : key -> 'a t -> 'a
+ val map : ('a -> 'b) -> 'a t -> 'b t
+ val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
+ val to_seq : 'a t -> (key * 'a) sequence
+ val of_seq : (key * 'a) sequence -> 'a t
+ val keys : 'a t -> key sequence
+ val values : 'a t -> 'a sequence
+ val to_list : 'a t -> (key * 'a) list
+ val of_list : (key * 'a) list -> 'a t
+ end
+ module Make :
+ functor (V : Map.OrderedType) ->
+ sig
+ type key = V.t
+ type +'a t
+ val empty : 'a t
+ val is_empty : 'a t -> bool
+ val mem : key -> 'a t -> bool
+ val add : key -> 'a -> 'a t -> 'a t
+ val singleton : key -> 'a -> 'a t
+ val remove : key -> 'a t -> 'a t
+ val merge :
+ (key -> 'a option -> 'b option -> 'c option) ->
+ 'a t -> 'b t -> 'c t
+ val union : (key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
+ val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
+ val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
+ val iter : (key -> 'a -> unit) -> 'a t -> unit
+ val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
+ val for_all : (key -> 'a -> bool) -> 'a t -> bool
+ val exists : (key -> 'a -> bool) -> 'a t -> bool
+ val filter : (key -> 'a -> bool) -> 'a t -> 'a t
+ val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
+ val cardinal : 'a t -> int
+ val bindings : 'a t -> (key * 'a) list
+ val min_binding : 'a t -> key * 'a
+ val max_binding : 'a t -> key * 'a
+ val choose : 'a t -> key * 'a
+ val split : key -> 'a t -> 'a t * 'a option * 'a t
+ val find : key -> 'a t -> 'a
+ val map : ('a -> 'b) -> 'a t -> 'b t
+ val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
+ val to_seq : 'a t -> (key * 'a) sequence
+ val of_seq : (key * 'a) sequence -> 'a t
+ val keys : 'a t -> key sequence
+ val values : 'a t -> 'a sequence
+ val to_list : 'a t -> (key * 'a) list
+ val of_list : (key * 'a) list -> 'a t
+ end
+end
\ No newline at end of file
diff --git a/api/type_SequenceLabels.Set.Adapt.html b/api/type_SequenceLabels.Set.Adapt.html
new file mode 100644
index 0000000..f1035d2
--- /dev/null
+++ b/api/type_SequenceLabels.Set.Adapt.html
@@ -0,0 +1,49 @@
+
+
+
+
+
+
+
+
+
+
+
+SequenceLabels.Set.Adapt
+
+
+functor (X : Set.S) ->
+ sig
+ type elt = X.elt
+ type t = X.t
+ val empty : t
+ val is_empty : t -> bool
+ val mem : elt -> t -> bool
+ val add : elt -> t -> t
+ val singleton : elt -> t
+ val remove : elt -> t -> t
+ val union : t -> t -> t
+ val inter : t -> t -> t
+ val diff : t -> t -> t
+ val compare : t -> t -> int
+ val equal : t -> t -> bool
+ val subset : t -> t -> bool
+ val iter : (elt -> unit) -> t -> unit
+ val map : (elt -> elt) -> t -> t
+ val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
+ val for_all : (elt -> bool) -> t -> bool
+ val exists : (elt -> bool) -> t -> bool
+ val filter : (elt -> bool) -> t -> t
+ val partition : (elt -> bool) -> t -> t * t
+ val cardinal : t -> int
+ val elements : t -> elt list
+ val min_elt : t -> elt
+ val max_elt : t -> elt
+ val choose : t -> elt
+ val split : elt -> t -> t * bool * t
+ val find : elt -> t -> elt
+ val of_seq : elt sequence -> t
+ val to_seq : t -> elt sequence
+ val to_list : t -> elt list
+ val of_list : elt list -> t
+ end
\ No newline at end of file
diff --git a/api/type_SequenceLabels.Set.Make.html b/api/type_SequenceLabels.Set.Make.html
new file mode 100644
index 0000000..d96cefc
--- /dev/null
+++ b/api/type_SequenceLabels.Set.Make.html
@@ -0,0 +1,49 @@
+
+
+
+
+
+
+
+
+
+
+
+SequenceLabels.Set.Make
+
+
+functor (X : Set.OrderedType) ->
+ sig
+ type elt = X.t
+ type t
+ val empty : t
+ val is_empty : t -> bool
+ val mem : elt -> t -> bool
+ val add : elt -> t -> t
+ val singleton : elt -> t
+ val remove : elt -> t -> t
+ val union : t -> t -> t
+ val inter : t -> t -> t
+ val diff : t -> t -> t
+ val compare : t -> t -> int
+ val equal : t -> t -> bool
+ val subset : t -> t -> bool
+ val iter : (elt -> unit) -> t -> unit
+ val map : (elt -> elt) -> t -> t
+ val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
+ val for_all : (elt -> bool) -> t -> bool
+ val exists : (elt -> bool) -> t -> bool
+ val filter : (elt -> bool) -> t -> t
+ val partition : (elt -> bool) -> t -> t * t
+ val cardinal : t -> int
+ val elements : t -> elt list
+ val min_elt : t -> elt
+ val max_elt : t -> elt
+ val choose : t -> elt
+ val split : elt -> t -> t * bool * t
+ val find : elt -> t -> elt
+ val of_seq : elt sequence -> t
+ val to_seq : t -> elt sequence
+ val to_list : t -> elt list
+ val of_list : elt list -> t
+ end
\ No newline at end of file
diff --git a/api/type_SequenceLabels.Set.S.html b/api/type_SequenceLabels.Set.S.html
new file mode 100644
index 0000000..6cee1dd
--- /dev/null
+++ b/api/type_SequenceLabels.Set.S.html
@@ -0,0 +1,48 @@
+
+
+
+
+
+
+
+
+
+
+
+SequenceLabels.Set.S
+
+
+sig
+ type elt
+ type t
+ val empty : t
+ val is_empty : t -> bool
+ val mem : elt -> t -> bool
+ val add : elt -> t -> t
+ val singleton : elt -> t
+ val remove : elt -> t -> t
+ val union : t -> t -> t
+ val inter : t -> t -> t
+ val diff : t -> t -> t
+ val compare : t -> t -> int
+ val equal : t -> t -> bool
+ val subset : t -> t -> bool
+ val iter : (elt -> unit) -> t -> unit
+ val map : (elt -> elt) -> t -> t
+ val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
+ val for_all : (elt -> bool) -> t -> bool
+ val exists : (elt -> bool) -> t -> bool
+ val filter : (elt -> bool) -> t -> t
+ val partition : (elt -> bool) -> t -> t * t
+ val cardinal : t -> int
+ val elements : t -> elt list
+ val min_elt : t -> elt
+ val max_elt : t -> elt
+ val choose : t -> elt
+ val split : elt -> t -> t * bool * t
+ val find : elt -> t -> elt
+ val of_seq : elt SequenceLabels.sequence -> SequenceLabels.t
+ val to_seq : SequenceLabels.t -> elt SequenceLabels.sequence
+ val to_list : SequenceLabels.t -> elt list
+ val of_list : elt list -> SequenceLabels.t
+end
\ No newline at end of file
diff --git a/api/type_SequenceLabels.Set.html b/api/type_SequenceLabels.Set.html
new file mode 100644
index 0000000..eea38f2
--- /dev/null
+++ b/api/type_SequenceLabels.Set.html
@@ -0,0 +1,123 @@
+
+
+
+
+
+
+
+
+
+
+
+SequenceLabels.Set
+
+
+sig
+ module type S =
+ sig
+ type elt
+ type t
+ val empty : t
+ val is_empty : t -> bool
+ val mem : elt -> t -> bool
+ val add : elt -> t -> t
+ val singleton : elt -> t
+ val remove : elt -> t -> t
+ val union : t -> t -> t
+ val inter : t -> t -> t
+ val diff : t -> t -> t
+ val compare : t -> t -> int
+ val equal : t -> t -> bool
+ val subset : t -> t -> bool
+ val iter : (elt -> unit) -> t -> unit
+ val map : (elt -> elt) -> t -> t
+ val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
+ val for_all : (elt -> bool) -> t -> bool
+ val exists : (elt -> bool) -> t -> bool
+ val filter : (elt -> bool) -> t -> t
+ val partition : (elt -> bool) -> t -> t * t
+ val cardinal : t -> int
+ val elements : t -> elt list
+ val min_elt : t -> elt
+ val max_elt : t -> elt
+ val choose : t -> elt
+ val split : elt -> t -> t * bool * t
+ val find : elt -> t -> elt
+ val of_seq : elt SequenceLabels.sequence -> SequenceLabels.t
+ val to_seq : SequenceLabels.t -> elt SequenceLabels.sequence
+ val to_list : SequenceLabels.t -> elt list
+ val of_list : elt list -> SequenceLabels.t
+ end
+ module Adapt :
+ functor (X : Set.S) ->
+ sig
+ type elt = X.elt
+ type t = X.t
+ val empty : t
+ val is_empty : t -> bool
+ val mem : elt -> t -> bool
+ val add : elt -> t -> t
+ val singleton : elt -> t
+ val remove : elt -> t -> t
+ val union : t -> t -> t
+ val inter : t -> t -> t
+ val diff : t -> t -> t
+ val compare : t -> t -> int
+ val equal : t -> t -> bool
+ val subset : t -> t -> bool
+ val iter : (elt -> unit) -> t -> unit
+ val map : (elt -> elt) -> t -> t
+ val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
+ val for_all : (elt -> bool) -> t -> bool
+ val exists : (elt -> bool) -> t -> bool
+ val filter : (elt -> bool) -> t -> t
+ val partition : (elt -> bool) -> t -> t * t
+ val cardinal : t -> int
+ val elements : t -> elt list
+ val min_elt : t -> elt
+ val max_elt : t -> elt
+ val choose : t -> elt
+ val split : elt -> t -> t * bool * t
+ val find : elt -> t -> elt
+ val of_seq : elt sequence -> t
+ val to_seq : t -> elt sequence
+ val to_list : t -> elt list
+ val of_list : elt list -> t
+ end
+ module Make :
+ functor (X : Set.OrderedType) ->
+ sig
+ type elt = X.t
+ type t
+ val empty : t
+ val is_empty : t -> bool
+ val mem : elt -> t -> bool
+ val add : elt -> t -> t
+ val singleton : elt -> t
+ val remove : elt -> t -> t
+ val union : t -> t -> t
+ val inter : t -> t -> t
+ val diff : t -> t -> t
+ val compare : t -> t -> int
+ val equal : t -> t -> bool
+ val subset : t -> t -> bool
+ val iter : (elt -> unit) -> t -> unit
+ val map : (elt -> elt) -> t -> t
+ val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
+ val for_all : (elt -> bool) -> t -> bool
+ val exists : (elt -> bool) -> t -> bool
+ val filter : (elt -> bool) -> t -> t
+ val partition : (elt -> bool) -> t -> t * t
+ val cardinal : t -> int
+ val elements : t -> elt list
+ val min_elt : t -> elt
+ val max_elt : t -> elt
+ val choose : t -> elt
+ val split : elt -> t -> t * bool * t
+ val find : elt -> t -> elt
+ val of_seq : elt sequence -> t
+ val to_seq : t -> elt sequence
+ val to_list : t -> elt list
+ val of_list : elt list -> t
+ end
+end
\ No newline at end of file
diff --git a/api/type_SequenceLabels.html b/api/type_SequenceLabels.html
new file mode 100644
index 0000000..4dd957a
--- /dev/null
+++ b/api/type_SequenceLabels.html
@@ -0,0 +1,476 @@
+
+
+
+
+
+
+
+
+
+
+
+SequenceLabels
+
+
+sig
+ type 'a t = ('a -> unit) -> unit
+ type 'a sequence = 'a SequenceLabels.t
+ type ('a, 'b) t2 = ('a -> 'b -> unit) -> unit
+ val from_iter : (('a -> unit) -> unit) -> 'a SequenceLabels.t
+ val from_fun : (unit -> 'a option) -> 'a SequenceLabels.t
+ val empty : 'a SequenceLabels.t
+ val singleton : 'a -> 'a SequenceLabels.t
+ val doubleton : 'a -> 'a -> 'a SequenceLabels.t
+ val init : f:(int -> 'a) -> 'a SequenceLabels.t
+ val cons : 'a -> 'a SequenceLabels.t -> 'a SequenceLabels.t
+ val snoc : 'a SequenceLabels.t -> 'a -> 'a SequenceLabels.t
+ val return : 'a -> 'a SequenceLabels.t
+ val pure : 'a -> 'a SequenceLabels.t
+ val repeat : 'a -> 'a SequenceLabels.t
+ val iterate : ('a -> 'a) -> 'a -> 'a SequenceLabels.t
+ val forever : (unit -> 'b) -> 'b SequenceLabels.t
+ val cycle : 'a SequenceLabels.t -> 'a SequenceLabels.t
+ val iter : f:('a -> unit) -> 'a SequenceLabels.t -> unit
+ val iteri : f:(int -> 'a -> unit) -> 'a SequenceLabels.t -> unit
+ val fold : f:('a -> 'b -> 'a) -> init:'a -> 'b SequenceLabels.t -> 'a
+ val foldi :
+ f:('a -> int -> 'b -> 'a) -> init:'a -> 'b SequenceLabels.t -> 'a
+ val fold_map :
+ f:('acc -> 'a -> 'acc * 'b) ->
+ init:'acc -> 'a SequenceLabels.t -> 'b SequenceLabels.t
+ val fold_filter_map :
+ f:('acc -> 'a -> 'acc * 'b option) ->
+ init:'acc -> 'a SequenceLabels.t -> 'b SequenceLabels.t
+ val map : f:('a -> 'b) -> 'a SequenceLabels.t -> 'b SequenceLabels.t
+ val mapi :
+ f:(int -> 'a -> 'b) -> 'a SequenceLabels.t -> 'b SequenceLabels.t
+ val map_by_2 :
+ f:('a -> 'a -> 'a) -> 'a SequenceLabels.t -> 'a SequenceLabels.t
+ val for_all : f:('a -> bool) -> 'a SequenceLabels.t -> bool
+ val exists : f:('a -> bool) -> 'a SequenceLabels.t -> bool
+ val mem : ?eq:('a -> 'a -> bool) -> x:'a -> 'a SequenceLabels.t -> bool
+ val find : f:('a -> 'b option) -> 'a SequenceLabels.t -> 'b option
+ val findi : f:(int -> 'a -> 'b option) -> 'a SequenceLabels.t -> 'b option
+ val find_pred : f:('a -> bool) -> 'a SequenceLabels.t -> 'a option
+ val find_pred_exn : f:('a -> bool) -> 'a SequenceLabels.t -> 'a
+ val length : 'a SequenceLabels.t -> int
+ val is_empty : 'a SequenceLabels.t -> bool
+ val filter : f:('a -> bool) -> 'a SequenceLabels.t -> 'a SequenceLabels.t
+ val append :
+ 'a SequenceLabels.t -> 'a SequenceLabels.t -> 'a SequenceLabels.t
+ val concat : 'a SequenceLabels.t SequenceLabels.t -> 'a SequenceLabels.t
+ val flatten : 'a SequenceLabels.t SequenceLabels.t -> 'a SequenceLabels.t
+ val flat_map :
+ f:('a -> 'b SequenceLabels.t) ->
+ 'a SequenceLabels.t -> 'b SequenceLabels.t
+ val flat_map_l :
+ f:('a -> 'b list) -> 'a SequenceLabels.t -> 'b SequenceLabels.t
+ val filter_map :
+ f:('a -> 'b option) -> 'a SequenceLabels.t -> 'b SequenceLabels.t
+ val intersperse : x:'a -> 'a SequenceLabels.t -> 'a SequenceLabels.t
+ val persistent : 'a SequenceLabels.t -> 'a SequenceLabels.t
+ val persistent_lazy : 'a SequenceLabels.t -> 'a SequenceLabels.t
+ val sort :
+ ?cmp:('a -> 'a -> int) -> 'a SequenceLabels.t -> 'a SequenceLabels.t
+ val sort_uniq :
+ ?cmp:('a -> 'a -> int) -> 'a SequenceLabels.t -> 'a SequenceLabels.t
+ val sorted : ?cmp:('a -> 'a -> int) -> 'a SequenceLabels.t -> bool
+ val group_succ_by :
+ ?eq:('a -> 'a -> bool) -> 'a SequenceLabels.t -> 'a list SequenceLabels.t
+ val group_by :
+ ?hash:('a -> int) ->
+ ?eq:('a -> 'a -> bool) -> 'a SequenceLabels.t -> 'a list SequenceLabels.t
+ val count :
+ ?hash:('a -> int) ->
+ ?eq:('a -> 'a -> bool) ->
+ 'a SequenceLabels.t -> ('a * int) SequenceLabels.t
+ val uniq :
+ ?eq:('a -> 'a -> bool) -> 'a SequenceLabels.t -> 'a SequenceLabels.t
+ val product :
+ 'a SequenceLabels.t -> 'b SequenceLabels.t -> ('a * 'b) SequenceLabels.t
+ val diagonal_l : 'a list -> ('a * 'a) SequenceLabels.t
+ val diagonal : 'a SequenceLabels.t -> ('a * 'a) SequenceLabels.t
+ val product2 :
+ 'a SequenceLabels.t -> 'b SequenceLabels.t -> ('a, 'b) SequenceLabels.t2
+ val join :
+ join_row:('a -> 'b -> 'c option) ->
+ 'a SequenceLabels.t -> 'b SequenceLabels.t -> 'c SequenceLabels.t
+ val unfoldr : ('b -> ('a * 'b) option) -> 'b -> 'a SequenceLabels.t
+ val scan :
+ ('b -> 'a -> 'b) -> 'b -> 'a SequenceLabels.t -> 'b SequenceLabels.t
+ val max : ?lt:('a -> 'a -> bool) -> 'a SequenceLabels.t -> 'a option
+ val min : ?lt:('a -> 'a -> bool) -> 'a SequenceLabels.t -> 'a option
+ val head : 'a SequenceLabels.t -> 'a option
+ val head_exn : 'a SequenceLabels.t -> 'a
+ val take : int -> 'a SequenceLabels.t -> 'a SequenceLabels.t
+ val take_while :
+ f:('a -> bool) -> 'a SequenceLabels.t -> 'a SequenceLabels.t
+ val fold_while :
+ f:('a -> 'b -> 'a * [ `Continue | `Stop ]) ->
+ init:'a -> 'b SequenceLabels.t -> 'a
+ val drop : int -> 'a SequenceLabels.t -> 'a SequenceLabels.t
+ val drop_while :
+ f:('a -> bool) -> 'a SequenceLabels.t -> 'a SequenceLabels.t
+ val rev : 'a SequenceLabels.t -> 'a SequenceLabels.t
+ val empty2 : ('a, 'b) SequenceLabels.t2
+ val is_empty2 : ('a, 'b) SequenceLabels.t2 -> bool
+ val length2 : ('a, 'b) SequenceLabels.t2 -> int
+ val zip : ('a, 'b) SequenceLabels.t2 -> ('a * 'b) SequenceLabels.t
+ val unzip : ('a * 'b) SequenceLabels.t -> ('a, 'b) SequenceLabels.t2
+ val zip_i : 'a SequenceLabels.t -> (int, 'a) SequenceLabels.t2
+ val fold2 :
+ f:('c -> 'a -> 'b -> 'c) -> init:'c -> ('a, 'b) SequenceLabels.t2 -> 'c
+ val iter2 : f:('a -> 'b -> unit) -> ('a, 'b) SequenceLabels.t2 -> unit
+ val map2 :
+ f:('a -> 'b -> 'c) -> ('a, 'b) SequenceLabels.t2 -> 'c SequenceLabels.t
+ val map2_2 :
+ ('a -> 'b -> 'c) ->
+ ('a -> 'b -> 'd) ->
+ ('a, 'b) SequenceLabels.t2 -> ('c, 'd) SequenceLabels.t2
+ val to_list : 'a SequenceLabels.t -> 'a list
+ val to_rev_list : 'a SequenceLabels.t -> 'a list
+ val of_list : 'a list -> 'a SequenceLabels.t
+ val on_list :
+ ('a SequenceLabels.t -> 'b SequenceLabels.t) -> 'a list -> 'b list
+ val to_opt : 'a SequenceLabels.t -> 'a option
+ val to_array : 'a SequenceLabels.t -> 'a array
+ val of_array : 'a array -> 'a SequenceLabels.t
+ val of_array_i : 'a array -> (int * 'a) SequenceLabels.t
+ val of_array2 : 'a array -> (int, 'a) SequenceLabels.t2
+ val array_slice : 'a array -> int -> int -> 'a SequenceLabels.t
+ val of_opt : 'a option -> 'a SequenceLabels.t
+ val of_stream : 'a Stream.t -> 'a SequenceLabels.t
+ val to_stream : 'a SequenceLabels.t -> 'a Stream.t
+ val to_stack : 'a Stack.t -> 'a SequenceLabels.t -> unit
+ val of_stack : 'a Stack.t -> 'a SequenceLabels.t
+ val to_queue : 'a Queue.t -> 'a SequenceLabels.t -> unit
+ val of_queue : 'a Queue.t -> 'a SequenceLabels.t
+ val hashtbl_add : ('a, 'b) Hashtbl.t -> ('a * 'b) SequenceLabels.t -> unit
+ val hashtbl_replace :
+ ('a, 'b) Hashtbl.t -> ('a * 'b) SequenceLabels.t -> unit
+ val to_hashtbl : ('a * 'b) SequenceLabels.t -> ('a, 'b) Hashtbl.t
+ val to_hashtbl2 : ('a, 'b) SequenceLabels.t2 -> ('a, 'b) Hashtbl.t
+ val of_hashtbl : ('a, 'b) Hashtbl.t -> ('a * 'b) SequenceLabels.t
+ val of_hashtbl2 : ('a, 'b) Hashtbl.t -> ('a, 'b) SequenceLabels.t2
+ val hashtbl_keys : ('a, 'b) Hashtbl.t -> 'a SequenceLabels.t
+ val hashtbl_values : ('a, 'b) Hashtbl.t -> 'b SequenceLabels.t
+ val of_str : string -> char SequenceLabels.t
+ val to_str : char SequenceLabels.t -> string
+ val concat_str : string SequenceLabels.t -> string
+ exception OneShotSequence
+ val of_in_channel : Pervasives.in_channel -> char SequenceLabels.t
+ val to_buffer : char SequenceLabels.t -> Buffer.t -> unit
+ val int_range : start:int -> stop:int -> int SequenceLabels.t
+ val int_range_dec : start:int -> stop:int -> int SequenceLabels.t
+ val int_range_by :
+ step:int -> start:int -> stop:int -> int SequenceLabels.t
+ val bools : bool SequenceLabels.t
+ val of_set :
+ (module Set.S with type elt = 'a and type t = 'b) ->
+ 'b -> 'a SequenceLabels.t
+ val to_set :
+ (module Set.S with type elt = 'a and type t = 'b) ->
+ 'a SequenceLabels.t -> 'b
+ type 'a gen = unit -> 'a option
+ type 'a klist = unit -> [ `Cons of 'a * 'a SequenceLabels.klist | `Nil ]
+ val of_gen : 'a SequenceLabels.gen -> 'a SequenceLabels.t
+ val to_gen : 'a SequenceLabels.t -> 'a SequenceLabels.gen
+ val of_klist : 'a SequenceLabels.klist -> 'a SequenceLabels.t
+ val to_klist : 'a SequenceLabels.t -> 'a SequenceLabels.klist
+ module Set :
+ sig
+ module type S =
+ sig
+ type elt
+ type t
+ val empty : t
+ val is_empty : t -> bool
+ val mem : elt -> t -> bool
+ val add : elt -> t -> t
+ val singleton : elt -> t
+ val remove : elt -> t -> t
+ val union : t -> t -> t
+ val inter : t -> t -> t
+ val diff : t -> t -> t
+ val compare : t -> t -> int
+ val equal : t -> t -> bool
+ val subset : t -> t -> bool
+ val iter : (elt -> unit) -> t -> unit
+ val map : (elt -> elt) -> t -> t
+ val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
+ val for_all : (elt -> bool) -> t -> bool
+ val exists : (elt -> bool) -> t -> bool
+ val filter : (elt -> bool) -> t -> t
+ val partition : (elt -> bool) -> t -> t * t
+ val cardinal : t -> int
+ val elements : t -> elt list
+ val min_elt : t -> elt
+ val max_elt : t -> elt
+ val choose : t -> elt
+ val split : elt -> t -> t * bool * t
+ val find : elt -> t -> elt
+ val of_seq : elt SequenceLabels.sequence -> SequenceLabels.t
+ val to_seq : SequenceLabels.t -> elt SequenceLabels.sequence
+ val to_list : SequenceLabels.t -> elt list
+ val of_list : elt list -> SequenceLabels.t
+ end
+ module Adapt :
+ functor (X : Set.S) ->
+ sig
+ type elt = X.elt
+ type t = X.t
+ val empty : t
+ val is_empty : t -> bool
+ val mem : elt -> t -> bool
+ val add : elt -> t -> t
+ val singleton : elt -> t
+ val remove : elt -> t -> t
+ val union : t -> t -> t
+ val inter : t -> t -> t
+ val diff : t -> t -> t
+ val compare : t -> t -> int
+ val equal : t -> t -> bool
+ val subset : t -> t -> bool
+ val iter : (elt -> unit) -> t -> unit
+ val map : (elt -> elt) -> t -> t
+ val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
+ val for_all : (elt -> bool) -> t -> bool
+ val exists : (elt -> bool) -> t -> bool
+ val filter : (elt -> bool) -> t -> t
+ val partition : (elt -> bool) -> t -> t * t
+ val cardinal : t -> int
+ val elements : t -> elt list
+ val min_elt : t -> elt
+ val max_elt : t -> elt
+ val choose : t -> elt
+ val split : elt -> t -> t * bool * t
+ val find : elt -> t -> elt
+ val of_seq : elt sequence -> t
+ val to_seq : t -> elt sequence
+ val to_list : t -> elt list
+ val of_list : elt list -> t
+ end
+ module Make :
+ functor (X : Set.OrderedType) ->
+ sig
+ type elt = X.t
+ type t
+ val empty : t
+ val is_empty : t -> bool
+ val mem : elt -> t -> bool
+ val add : elt -> t -> t
+ val singleton : elt -> t
+ val remove : elt -> t -> t
+ val union : t -> t -> t
+ val inter : t -> t -> t
+ val diff : t -> t -> t
+ val compare : t -> t -> int
+ val equal : t -> t -> bool
+ val subset : t -> t -> bool
+ val iter : (elt -> unit) -> t -> unit
+ val map : (elt -> elt) -> t -> t
+ val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
+ val for_all : (elt -> bool) -> t -> bool
+ val exists : (elt -> bool) -> t -> bool
+ val filter : (elt -> bool) -> t -> t
+ val partition : (elt -> bool) -> t -> t * t
+ val cardinal : t -> int
+ val elements : t -> elt list
+ val min_elt : t -> elt
+ val max_elt : t -> elt
+ val choose : t -> elt
+ val split : elt -> t -> t * bool * t
+ val find : elt -> t -> elt
+ val of_seq : elt sequence -> t
+ val to_seq : t -> elt sequence
+ val to_list : t -> elt list
+ val of_list : elt list -> t
+ end
+ end
+ module Map :
+ sig
+ module type S =
+ sig
+ type key
+ type +'a t
+ val empty : 'a t
+ val is_empty : 'a t -> bool
+ val mem : key -> 'a t -> bool
+ val add : key -> 'a -> 'a t -> 'a t
+ val singleton : key -> 'a -> 'a t
+ val remove : key -> 'a t -> 'a t
+ val merge :
+ (key -> 'a option -> 'b option -> 'c option) ->
+ 'a t -> 'b t -> 'c t
+ val union : (key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
+ val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
+ val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
+ val iter : (key -> 'a -> unit) -> 'a t -> unit
+ val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
+ val for_all : (key -> 'a -> bool) -> 'a t -> bool
+ val exists : (key -> 'a -> bool) -> 'a t -> bool
+ val filter : (key -> 'a -> bool) -> 'a t -> 'a t
+ val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
+ val cardinal : 'a t -> int
+ val bindings : 'a t -> (key * 'a) list
+ val min_binding : 'a t -> key * 'a
+ val max_binding : 'a t -> key * 'a
+ val choose : 'a t -> key * 'a
+ val split : key -> 'a t -> 'a t * 'a option * 'a t
+ val find : key -> 'a t -> 'a
+ val map : ('a -> 'b) -> 'a t -> 'b t
+ val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
+ val to_seq :
+ 'a SequenceLabels.t -> (key * 'a) SequenceLabels.sequence
+ val of_seq :
+ (key * 'a) SequenceLabels.sequence -> 'a SequenceLabels.t
+ val keys : 'a SequenceLabels.t -> key SequenceLabels.sequence
+ val values : 'a SequenceLabels.t -> 'a SequenceLabels.sequence
+ val to_list : 'a SequenceLabels.t -> (key * 'a) list
+ val of_list : (key * 'a) list -> 'a SequenceLabels.t
+ end
+ module Adapt :
+ functor (M : Map.S) ->
+ sig
+ type key = M.key
+ type 'a t = 'a M.t
+ val empty : 'a t
+ val is_empty : 'a t -> bool
+ val mem : key -> 'a t -> bool
+ val add : key -> 'a -> 'a t -> 'a t
+ val singleton : key -> 'a -> 'a t
+ val remove : key -> 'a t -> 'a t
+ val merge :
+ (key -> 'a option -> 'b option -> 'c option) ->
+ 'a t -> 'b t -> 'c t
+ val union :
+ (key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
+ val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
+ val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
+ val iter : (key -> 'a -> unit) -> 'a t -> unit
+ val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
+ val for_all : (key -> 'a -> bool) -> 'a t -> bool
+ val exists : (key -> 'a -> bool) -> 'a t -> bool
+ val filter : (key -> 'a -> bool) -> 'a t -> 'a t
+ val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
+ val cardinal : 'a t -> int
+ val bindings : 'a t -> (key * 'a) list
+ val min_binding : 'a t -> key * 'a
+ val max_binding : 'a t -> key * 'a
+ val choose : 'a t -> key * 'a
+ val split : key -> 'a t -> 'a t * 'a option * 'a t
+ val find : key -> 'a t -> 'a
+ val map : ('a -> 'b) -> 'a t -> 'b t
+ val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
+ val to_seq : 'a t -> (key * 'a) sequence
+ val of_seq : (key * 'a) sequence -> 'a t
+ val keys : 'a t -> key sequence
+ val values : 'a t -> 'a sequence
+ val to_list : 'a t -> (key * 'a) list
+ val of_list : (key * 'a) list -> 'a t
+ end
+ module Make :
+ functor (V : Map.OrderedType) ->
+ sig
+ type key = V.t
+ type +'a t
+ val empty : 'a t
+ val is_empty : 'a t -> bool
+ val mem : key -> 'a t -> bool
+ val add : key -> 'a -> 'a t -> 'a t
+ val singleton : key -> 'a -> 'a t
+ val remove : key -> 'a t -> 'a t
+ val merge :
+ (key -> 'a option -> 'b option -> 'c option) ->
+ 'a t -> 'b t -> 'c t
+ val union :
+ (key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
+ val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
+ val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
+ val iter : (key -> 'a -> unit) -> 'a t -> unit
+ val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
+ val for_all : (key -> 'a -> bool) -> 'a t -> bool
+ val exists : (key -> 'a -> bool) -> 'a t -> bool
+ val filter : (key -> 'a -> bool) -> 'a t -> 'a t
+ val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
+ val cardinal : 'a t -> int
+ val bindings : 'a t -> (key * 'a) list
+ val min_binding : 'a t -> key * 'a
+ val max_binding : 'a t -> key * 'a
+ val choose : 'a t -> key * 'a
+ val split : key -> 'a t -> 'a t * 'a option * 'a t
+ val find : key -> 'a t -> 'a
+ val map : ('a -> 'b) -> 'a t -> 'b t
+ val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
+ val to_seq : 'a t -> (key * 'a) sequence
+ val of_seq : (key * 'a) sequence -> 'a t
+ val keys : 'a t -> key sequence
+ val values : 'a t -> 'a sequence
+ val to_list : 'a t -> (key * 'a) list
+ val of_list : (key * 'a) list -> 'a t
+ end
+ end
+ val random_int : int -> int SequenceLabels.t
+ val random_bool : bool SequenceLabels.t
+ val random_float : float -> float SequenceLabels.t
+ val random_array : 'a array -> 'a SequenceLabels.t
+ val random_list : 'a list -> 'a SequenceLabels.t
+ val shuffle : 'a SequenceLabels.t -> 'a SequenceLabels.t
+ val shuffle_buffer : n:int -> 'a SequenceLabels.t -> 'a SequenceLabels.t
+ val sample : n:int -> 'a SequenceLabels.t -> 'a array
+ module Infix :
+ sig
+ val ( -- ) : int -> int -> int SequenceLabels.t
+ val ( --^ ) : int -> int -> int SequenceLabels.t
+ val ( >>= ) :
+ 'a SequenceLabels.t ->
+ ('a -> 'b SequenceLabels.t) -> 'b SequenceLabels.t
+ val ( >|= ) : 'a SequenceLabels.t -> ('a -> 'b) -> 'b SequenceLabels.t
+ val ( <*> ) :
+ ('a -> 'b) SequenceLabels.t ->
+ 'a SequenceLabels.t -> 'b SequenceLabels.t
+ val ( <+> ) :
+ 'a SequenceLabels.t -> 'a SequenceLabels.t -> 'a SequenceLabels.t
+ end
+ val ( -- ) : int -> int -> int t
+ val ( --^ ) : int -> int -> int t
+ val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
+ val ( >|= ) : 'a t -> ('a -> 'b) -> 'b t
+ val ( <*> ) : ('a -> 'b) t -> 'a t -> 'b t
+ val ( <+> ) : 'a t -> 'a t -> 'a t
+ val pp_seq :
+ ?sep:string ->
+ (Format.formatter -> 'a -> unit) ->
+ Format.formatter -> 'a SequenceLabels.t -> unit
+ val pp_buf :
+ ?sep:string ->
+ (Buffer.t -> 'a -> unit) -> Buffer.t -> 'a SequenceLabels.t -> unit
+ val to_string :
+ ?sep:string -> ('a -> string) -> 'a SequenceLabels.t -> string
+ module IO :
+ sig
+ val lines_of :
+ ?mode:int ->
+ ?flags:Pervasives.open_flag list -> string -> string SequenceLabels.t
+ val chunks_of :
+ ?mode:int ->
+ ?flags:Pervasives.open_flag list ->
+ ?size:int -> string -> string SequenceLabels.t
+ val write_to :
+ ?mode:int ->
+ ?flags:Pervasives.open_flag list ->
+ string -> string SequenceLabels.t -> unit
+ val write_bytes_to :
+ ?mode:int ->
+ ?flags:Pervasives.open_flag list ->
+ string -> Bytes.t SequenceLabels.t -> unit
+ val write_lines :
+ ?mode:int ->
+ ?flags:Pervasives.open_flag list ->
+ string -> string SequenceLabels.t -> unit
+ val write_bytes_lines :
+ ?mode:int ->
+ ?flags:Pervasives.open_flag list ->
+ string -> Bytes.t SequenceLabels.t -> unit
+ end
+end
\ No newline at end of file