From 353d34b9cbd928e3a5d7d2560a665c716cebe4bf Mon Sep 17 00:00:00 2001 From: Simon Cruanes Date: Wed, 22 Feb 2017 13:24:46 +0100 Subject: [PATCH] update api docs --- api/Sequence.IO.html | 62 ++ api/Sequence.Infix.html | 1 + api/Sequence.Map.Adapt.html | 1 + api/Sequence.Map.Make.html | 1 + api/Sequence.Map.S.html | 1 + api/Sequence.Map.html | 1 + api/Sequence.Set.Adapt.html | 1 + api/Sequence.Set.Make.html | 1 + api/Sequence.Set.S.html | 1 + api/Sequence.Set.html | 1 + api/Sequence.html | 145 +++- api/SequenceLabels.IO.html | 58 ++ api/SequenceLabels.Infix.html | 54 ++ api/SequenceLabels.Map.Adapt.html | 50 ++ api/SequenceLabels.Map.Make.html | 50 ++ api/SequenceLabels.Map.S.html | 31 + api/SequenceLabels.Map.html | 36 + api/SequenceLabels.Set.Adapt.html | 48 ++ api/SequenceLabels.Set.Make.html | 48 ++ api/SequenceLabels.Set.S.html | 29 + api/SequenceLabels.Set.html | 34 + api/SequenceLabels.html | 696 ++++++++++++++++++++ api/html.stamp | 2 +- api/index.html | 1 + api/index_attributes.html | 1 + api/index_class_types.html | 1 + api/index_classes.html | 1 + api/index_exceptions.html | 1 + api/index_extensions.html | 22 + api/index_methods.html | 1 + api/index_module_types.html | 1 + api/index_modules.html | 1 + api/index_types.html | 7 + api/index_values.html | 173 +++++ api/type_Sequence.IO.html | 35 + api/type_Sequence.Infix.html | 15 +- api/type_Sequence.Map.Adapt.html | 73 ++- api/type_Sequence.Map.Make.html | 73 ++- api/type_Sequence.Map.S.html | 71 +- api/type_Sequence.Map.html | 233 +++---- api/type_Sequence.Set.Adapt.html | 68 +- api/type_Sequence.Set.Make.html | 68 +- api/type_Sequence.Set.S.html | 66 +- api/type_Sequence.Set.html | 214 +++--- api/type_Sequence.html | 871 +++++++++++++------------ api/type_SequenceLabels.IO.html | 39 ++ api/type_SequenceLabels.Infix.html | 25 + api/type_SequenceLabels.Map.Adapt.html | 51 ++ api/type_SequenceLabels.Map.Make.html | 51 ++ api/type_SequenceLabels.Map.S.html | 50 ++ api/type_SequenceLabels.Map.html | 131 ++++ api/type_SequenceLabels.Set.Adapt.html | 49 ++ api/type_SequenceLabels.Set.Make.html | 49 ++ api/type_SequenceLabels.Set.S.html | 48 ++ api/type_SequenceLabels.Set.html | 123 ++++ api/type_SequenceLabels.html | 476 ++++++++++++++ 56 files changed, 3598 insertions(+), 843 deletions(-) create mode 100644 api/Sequence.IO.html create mode 100644 api/SequenceLabels.IO.html create mode 100644 api/SequenceLabels.Infix.html create mode 100644 api/SequenceLabels.Map.Adapt.html create mode 100644 api/SequenceLabels.Map.Make.html create mode 100644 api/SequenceLabels.Map.S.html create mode 100644 api/SequenceLabels.Map.html create mode 100644 api/SequenceLabels.Set.Adapt.html create mode 100644 api/SequenceLabels.Set.Make.html create mode 100644 api/SequenceLabels.Set.S.html create mode 100644 api/SequenceLabels.Set.html create mode 100644 api/SequenceLabels.html create mode 100644 api/index_extensions.html create mode 100644 api/type_Sequence.IO.html create mode 100644 api/type_SequenceLabels.IO.html create mode 100644 api/type_SequenceLabels.Infix.html create mode 100644 api/type_SequenceLabels.Map.Adapt.html create mode 100644 api/type_SequenceLabels.Map.Make.html create mode 100644 api/type_SequenceLabels.Map.S.html create mode 100644 api/type_SequenceLabels.Map.html create mode 100644 api/type_SequenceLabels.Set.Adapt.html create mode 100644 api/type_SequenceLabels.Set.Make.html create mode 100644 api/type_SequenceLabels.Set.S.html create mode 100644 api/type_SequenceLabels.Set.html create mode 100644 api/type_SequenceLabels.html diff --git a/api/Sequence.IO.html b/api/Sequence.IO.html new file mode 100644 index 0000000..6620ef7 --- /dev/null +++ b/api/Sequence.IO.html @@ -0,0 +1,62 @@ + + + + + + + + + + + + + + + +Sequence.IO + + +
Previous + Up + 
+

Module Sequence.IO

+ +
module IO: sig .. end
+ +
val lines_of : ?mode:int -> ?flags:Pervasives.open_flag list -> string -> string Sequence.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 Sequence.t
+Read chunks of the given size 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 results
+
+ +
val write_to : ?mode:int ->
       ?flags:Pervasives.open_flag list -> string -> string Sequence.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 Sequence.t -> unit
+Since 0.5.4
+
+ +
val write_lines : ?mode:int ->
       ?flags:Pervasives.open_flag list -> string -> string Sequence.t -> unit
+Same as Sequence.IO.write_to, but intercales '\n' between each string
+
+ +
val write_bytes_lines : ?mode:int ->
       ?flags:Pervasives.open_flag list -> string -> Bytes.t Sequence.t -> unit
+Since 0.5.4
+
+ \ No newline at end of file diff --git a/api/Sequence.Infix.html b/api/Sequence.Infix.html index a8f4363..dd3fc2f 100644 --- a/api/Sequence.Infix.html +++ b/api/Sequence.Infix.html @@ -3,6 +3,7 @@ + diff --git a/api/Sequence.Map.Adapt.html b/api/Sequence.Map.Adapt.html index 20a2b29..10e0c2a 100644 --- a/api/Sequence.Map.Adapt.html +++ b/api/Sequence.Map.Adapt.html @@ -3,6 +3,7 @@ + diff --git a/api/Sequence.Map.Make.html b/api/Sequence.Map.Make.html index c81f573..8ad3db4 100644 --- a/api/Sequence.Map.Make.html +++ b/api/Sequence.Map.Make.html @@ -3,6 +3,7 @@ + diff --git a/api/Sequence.Map.S.html b/api/Sequence.Map.S.html index 67d90d9..48c16d7 100644 --- a/api/Sequence.Map.S.html +++ b/api/Sequence.Map.S.html @@ -3,6 +3,7 @@ + diff --git a/api/Sequence.Map.html b/api/Sequence.Map.html index f67b554..39061d8 100644 --- a/api/Sequence.Map.html +++ b/api/Sequence.Map.html @@ -3,6 +3,7 @@ + diff --git a/api/Sequence.Set.Adapt.html b/api/Sequence.Set.Adapt.html index 32d2eb8..d66b2c4 100644 --- a/api/Sequence.Set.Adapt.html +++ b/api/Sequence.Set.Adapt.html @@ -3,6 +3,7 @@ + diff --git a/api/Sequence.Set.Make.html b/api/Sequence.Set.Make.html index 9267f73..9ccb425 100644 --- a/api/Sequence.Set.Make.html +++ b/api/Sequence.Set.Make.html @@ -3,6 +3,7 @@ + diff --git a/api/Sequence.Set.S.html b/api/Sequence.Set.S.html index b089f3a..3bed0f4 100644 --- a/api/Sequence.Set.S.html +++ b/api/Sequence.Set.S.html @@ -3,6 +3,7 @@ + diff --git a/api/Sequence.Set.html b/api/Sequence.Set.html index 984ea09..9cf1484 100644 --- a/api/Sequence.Set.html +++ b/api/Sequence.Set.html @@ -3,6 +3,7 @@ + diff --git a/api/Sequence.html b/api/Sequence.html index 70f7dde..8a81dad 100644 --- a/api/Sequence.html +++ b/api/Sequence.html @@ -3,6 +3,7 @@ + @@ -84,6 +85,12 @@ A sequence of values of type 'a. If you give it a func Sequence of pairs of values of type 'a and 'b.
+ +
type 'a equal = 'a -> 'a -> bool
+ + +
type 'a hash = 'a -> int
+

Build a sequence


@@ -108,6 +115,11 @@ Singleton sequence, with exactly one element.
Sequence with exactly two elements
+
val init : (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
@@ -166,6 +178,19 @@ Fold over elements of the sequence, consuming it
Fold over elements of the sequence and their index, consuming it
+
val fold_map : ('acc -> 'a -> 'acc * 'b) -> 'acc -> 'a t -> 'b t
+fold_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.
+Since 0.9
+
+ +
val fold_filter_map : ('acc -> 'a -> 'acc * 'b option) -> 'acc -> 'a t -> 'b t
+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.
+Since 0.9
+
+ 
val map : ('a -> 'b) -> 'a t -> 'b t
Map objects of the sequence into other elements, lazily
@@ -199,6 +224,33 @@ Find the first element on which the function doesn't return N Since 0.5
+
val find_map : ('a -> 'b option) -> 'a t -> 'b option
+Alias to Sequence.find
+Since 0.10
+
+ +
val findi : (int -> 'a -> 'b option) -> 'a t -> 'b option
+Indexed version of Sequence.find
+Since 0.9
+
+ +
val find_mapi : (int -> 'a -> 'b option) -> 'a t -> 'b option
+Alias to Sequence.findi
+Since 0.10
+
+ +
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
+Unsafe version of Sequence.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.
@@ -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
+Checks whether the sequence is sorted. Eager, same as Sequence.sort.
+Since 0.9
+
+ 
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
+Unsafe version of Sequence.max
+Since 0.10
+Raises Not_found if the sequence is empty
+
+ 
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
+Unsafe version of Sequence.min
+Since 0.10
+Raises Not_found if the sequence is empty
+
+ 
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 + + +
Previous + Up + 
+

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
+Same as SequenceLabels.IO.write_to, but intercales '\n' between each string
+
+ +
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 + + +
Previous + Up + Next +
+

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 + + +
 Up + Next +
+

Functor SequenceLabels.Map.Adapt

+ +
module Adapt: 
functor (M : Map.S) -> S  with type key = M.key and type 'a t = 'a M.t
+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 + + +
Previous + Up + 
+

Functor SequenceLabels.Map.Make

+ +
module Make: 
functor (V : Map.OrderedType) -> S  with type key = V.t
+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 + + +
 Up + 
+

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 + + +
Previous + Up + Next +
+

Module SequenceLabels.Map

+ +
module Map: sig .. end
+ +
module type S = sig .. end
+
module Adapt: 
functor (M : Map.S) -> S  with type key = M.key and type 'a t = 'a M.t
+Adapt a pre-existing Map module to make it sequence-aware +
+ +
module Make: 
functor (V : Map.OrderedType) -> S  with type key = V.t
+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 + + +
 Up + Next +
+

Functor SequenceLabels.Set.Adapt

+ +
module Adapt: 
functor (X : Set.S) -> S  with type elt = X.elt and type t = X.t
+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 + + +
Previous + Up + 
+

Functor SequenceLabels.Set.Make

+ +
module Make: 
functor (X : Set.OrderedType) -> S  with type elt = X.t
+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 + + +
 Up + 
+

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 + + +
 Up + Next +
+

Module SequenceLabels.Set

+ +
module Set: sig .. end
+ +
module type S = sig .. end
+
module Adapt: 
functor (X : Set.S) -> S  with type elt = X.elt and type t = X.t
+Create an enriched Set module from the given one +
+ +
module Make: 
functor (X : Set.OrderedType) -> S  with type elt = X.t
+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 + + +
Previous + Up + 
+

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
+Same as SequenceLabels.cons but yields the element after iterating on l
+
+ +
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
+Indexed version of SequenceLabels.find
+Since 0.9
+
+ +
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
+Convenience function combining SequenceLabels.flat_map and SequenceLabels.of_list
+Since 0.9
+
+ +
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
+Checks whether the sequence is sorted. Eager, same as SequenceLabels.sort.
+Since 0.9
+
+ +
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 + + +
 Up + 
+

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

+ + + + + + diff --git a/api/index_values.html b/api/index_values.html index 30188be..8b1d567 100644 --- a/api/index_values.html +++ b/api/index_values.html @@ -2,6 +2,7 @@ + @@ -105,6 +106,11 @@ Append two sequences. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -618,6 +761,11 @@ Max element of the sequence, using the given comparison function. Max element of the sequence, using the given comparison function. + + + + @@ -1026,6 +1179,21 @@ Sort the sequence and remove duplicates. Sort the sequence and remove duplicates. + + + + + + + +

E
equal [Sequence]

G
gen [SequenceLabels]
gen [Sequence]

H
hash [Sequence]

K
klist [SequenceLabels]

B
bools [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.

D
diagonal [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_map f acc l is like Sequence.map, but it carries some state as in + Sequence.fold. +
+
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

I
init [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. +
+

K
keys [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 +
+

O
of_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. +
+

T
take [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