diff --git a/api/Sequence.Infix.html b/api/Sequence.Infix.html index 3b0c65b..a8f4363 100644 --- a/api/Sequence.Infix.html +++ b/api/Sequence.Infix.html @@ -4,18 +4,54 @@ - + + + -Sequence.Infix + +Sequence.Infix -
Previous +
Previous  Up - 
+ Next +

Module Sequence.Infix

+ 
module Infix: sig .. end
-
val (--) : int -> int -> int Sequence.t
val (|>) : 'a -> ('a -> 'b) -> 'b
val (@@) : 'a Sequence.t -> 'a Sequence.t -> 'a Sequence.t
\ No newline at end of file + +
val (--) : int -> int -> int Sequence.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 Sequence.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 Sequence.t -> ('a -> 'b Sequence.t) -> 'b Sequence.t
+Monadic bind (infix version of Sequence.flat_map
+Since 0.5
+
+ +
val (>|=) : 'a Sequence.t -> ('a -> 'b) -> 'b Sequence.t
+Infix version of Sequence.map
+Since 0.5
+
+ +
val (<*>) : ('a -> 'b) Sequence.t -> 'a Sequence.t -> 'b Sequence.t
+Applicative operator (product+application)
+Since 0.5
+
+ +
val (<+>) : 'a Sequence.t -> 'a Sequence.t -> 'a Sequence.t
+Concatenation of sequences
+Since 0.5
+
+ \ No newline at end of file diff --git a/api/Sequence.Map.Adapt.html b/api/Sequence.Map.Adapt.html index 07d6fd9..20a2b29 100644 --- a/api/Sequence.Map.Adapt.html +++ b/api/Sequence.Map.Adapt.html @@ -7,17 +7,20 @@ + -Sequence.Map.Adapt + +Sequence.Map.Adapt
 Up  Next

Functor Sequence.Map.Adapt

-
module Adapt: 
functor (M : Map.S) -> S  with type key = M.key and type 'a map = 'a M.t
+ +
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
@@ -35,7 +38,12 @@ Adapt a pre-existing Map module to make it sequence-aware
-
type +'a map 
include Map.S
-
val to_seq : 'a map -> (key * 'a) Sequence.t
val of_seq : (key * 'a) Sequence.t -> 'a map
val keys : 'a map -> key Sequence.t
val values : 'a map -> 'a Sequence.t
\ No newline at end of file + +
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
\ No newline at end of file diff --git a/api/Sequence.Map.Make.html b/api/Sequence.Map.Make.html index cc1bcf8..c81f573 100644 --- a/api/Sequence.Map.Make.html +++ b/api/Sequence.Map.Make.html @@ -7,17 +7,20 @@ + -Sequence.Map.Make + +Sequence.Map.Make
Previous  Up  

Functor Sequence.Map.Make

-
module Make: 
functor (V : Map.OrderedType) -> S  with type key = V.t
+ +
module Make: 
functor (V : Map.OrderedType) -> S  with type key = V.t
Create an enriched Map module, with sequence-aware functions
@@ -35,7 +38,12 @@ Create an enriched Map module, with sequence-aware functions
-
type +'a map 
include Map.S
-
val to_seq : 'a map -> (key * 'a) Sequence.t
val of_seq : (key * 'a) Sequence.t -> 'a map
val keys : 'a map -> key Sequence.t
val values : 'a map -> 'a Sequence.t
\ No newline at end of file + +
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
\ No newline at end of file diff --git a/api/Sequence.Map.S.html b/api/Sequence.Map.S.html index 6f4811d..67d90d9 100644 --- a/api/Sequence.Map.S.html +++ b/api/Sequence.Map.S.html @@ -6,17 +6,25 @@ + -Sequence.Map.S + +Sequence.Map.S
 Up  

Module type Sequence.Map.S

+ 
module type S = sig .. end
-
type +'a map 
include Map.S
-
val to_seq : 'a map -> (key * 'a) Sequence.t
val of_seq : (key * 'a) Sequence.t -> 'a map
val keys : 'a map -> key Sequence.t
val values : 'a map -> 'a Sequence.t
\ No newline at end of file + +
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
\ No newline at end of file diff --git a/api/Sequence.Map.html b/api/Sequence.Map.html index 3ff1f7b..f67b554 100644 --- a/api/Sequence.Map.html +++ b/api/Sequence.Map.html @@ -5,24 +5,30 @@ - + + -Sequence.Map + +Sequence.Map
Previous  Up - Next + Next

Module Sequence.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 map = 'a M.t
+ +
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
diff --git a/api/Sequence.Set.Adapt.html b/api/Sequence.Set.Adapt.html index 8284b03..32d2eb8 100644 --- a/api/Sequence.Set.Adapt.html +++ b/api/Sequence.Set.Adapt.html @@ -7,17 +7,20 @@ + -Sequence.Set.Adapt + +Sequence.Set.Adapt
 Up  Next

Functor Sequence.Set.Adapt

-
module Adapt: 
functor (X : Set.S) -> S  with type elt = X.elt and type set = X.t
+ +
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
@@ -35,7 +38,10 @@ Create an enriched Set module from the given one
-
type set 
include Set.S
-
val of_seq : elt Sequence.t -> set
val to_seq : set -> elt Sequence.t
\ No newline at end of file + +
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
\ No newline at end of file diff --git a/api/Sequence.Set.Make.html b/api/Sequence.Set.Make.html index 4564c3d..9267f73 100644 --- a/api/Sequence.Set.Make.html +++ b/api/Sequence.Set.Make.html @@ -7,17 +7,20 @@ + -Sequence.Set.Make + +Sequence.Set.Make
Previous  Up  

Functor Sequence.Set.Make

-
module Make: 
functor (X : Set.OrderedType) -> S  with type elt = X.t
+ +
module Make: 
functor (X : Set.OrderedType) -> S  with type elt = X.t
Functor to build an extended Set module from an ordered type
@@ -35,7 +38,10 @@ Functor to build an extended Set module from an ordered type
-
type set 
include Set.S
-
val of_seq : elt Sequence.t -> set
val to_seq : set -> elt Sequence.t
\ No newline at end of file + +
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
\ No newline at end of file diff --git a/api/Sequence.Set.S.html b/api/Sequence.Set.S.html index 026fbc1..b089f3a 100644 --- a/api/Sequence.Set.S.html +++ b/api/Sequence.Set.S.html @@ -6,17 +6,23 @@ + -Sequence.Set.S + +Sequence.Set.S
 Up  

Module type Sequence.Set.S

+ 
module type S = sig .. end
-
type set 
include Set.S
-
val of_seq : elt Sequence.t -> set
val to_seq : set -> elt Sequence.t
\ No newline at end of file + +
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
\ No newline at end of file diff --git a/api/Sequence.Set.html b/api/Sequence.Set.html index 5275185..984ea09 100644 --- a/api/Sequence.Set.html +++ b/api/Sequence.Set.html @@ -7,20 +7,26 @@ + -Sequence.Set + +Sequence.Set
 Up  Next

Module Sequence.Set

+ 
module Set: sig .. end
-
module type S = sig .. end
module Adapt: 
functor (X : Set.S) -> S  with type elt = X.elt and type set = X.t
+ +
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
diff --git a/api/Sequence.html b/api/Sequence.html index 92b0273..70f7dde 100644 --- a/api/Sequence.html +++ b/api/Sequence.html @@ -4,280 +4,674 @@ + + - + + + + - + + Sequence
 Up - 
+ Next +

Module Sequence

-
module Sequence: sig .. end
-

Transient iterators, that abstract on a finite sequence of elements.


+ +
module Sequence: sig .. end
+

Simple and Efficient Iterators



The iterators are designed to allow easy transfer (mappings) between data - structures, without defining n^2 conversions between the n types. The + structures, without defining n^2 conversions between the n types. The implementation relies on the assumption that a sequence can be iterated on as many times as needed; this choice allows for high performance of many combinators. However, for transient iterators, the Sequence.persistent function is provided, storing elements of a transient iterator - in memory; the iterator can then be used several times. + in memory; the iterator can then be used several times (See further).

- Note that some combinators also return sequences (e.g. Sequence.group). The + Note that some combinators also return sequences (e.g. group). The transformation is computed on the fly every time one iterates over the resulting sequence. If a transformation performs heavy computation, - Sequence.persistent can also be used as intermediate storage.
+ Sequence.persistent can also be used as intermediate storage. +

+ + Most functions are lazy, i.e. they do not actually use their arguments + until their result is iterated on. For instance, if one calls Sequence.map + on a sequence, one gets a new sequence, but nothing else happens until + this new sequence is used (by folding or iterating on it). +

+ + If a sequence is built from an iteration function that is repeatable + (i.e. calling it several times always iterates on the same set of + elements, for instance List.iter or Map.iter), then + the resulting Sequence.t object is also repeatable. For one-time iter functions + such as iteration on a file descriptor or a Stream, + the Sequence.persistent function can be used to iterate and store elements in + a memory structure; the result is a sequence that iterates on the elements + of this memory structure, cheaply and repeatably.
+ 

type 'a t = ('a -> unit) -> unit
-
-Sequence abstract iterator type, representing a finite sequence of - values of type 'a.
+
+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
+ +
val from_iter : (('a -> unit) -> unit) -> 'a t
Build a sequence from a iter function
-
val from_fun : (unit -> 'a option) -> 'a t
+ +
val from_fun : (unit -> 'a option) -> 'a t
Call the function repeatedly until it returns None. This - sequence is transient, use Sequence.persistent if needed!
+ sequence is transient, use Sequence.persistent if needed!
-
val empty : 'a t
-Empty sequence
+ +
val empty : 'a t
+Empty sequence. It contains no element.
-
val singleton : 'a -> 'a t
-Singleton sequence
+ +
val singleton : 'a -> 'a t
+Singleton sequence, with exactly one element.
-
val repeat : 'a -> 'a t
-Infinite sequence of the same element
+ +
val doubleton : 'a -> 'a -> 'a t
+Sequence with exactly two elements
-
val iterate : ('a -> 'a) -> 'a -> 'a t
-iterate f x is the infinite sequence (x, f(x), f(f(x)), ...)
+ +
val cons : 'a -> 'a t -> 'a t
+cons x l yields x, then yields from l. + Same as append (singleton x) l
-
val forever : (unit -> 'b) -> 'b t
-Sequence that calls the given function to produce elements
+ +
val snoc : 'a t -> 'a -> 'a t
+Same as Sequence.cons but yields the element after iterating on l
-
val cycle : 'a t -> 'a t
-Cycle forever through the given sequence.
+ +
val return : 'a -> 'a t
+Synonym to Sequence.singleton
+
+ +
val pure : 'a -> 'a t
+Synonym to Sequence.singleton
+
+ +
val repeat : 'a -> 'a t
+Infinite sequence of the same element. You may want to look + at Sequence.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 Sequence.take and Sequence.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 Sequence.take not to loop + forever.

Consume a sequence


-
val iter : ('a -> unit) -> 'a t -> unit
-Consume the sequence, passing all its arguments to the function
+ +
val iter : ('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 : (int -> 'a -> unit) -> 'a t -> unit
+ +
val iteri : (int -> 'a -> unit) -> 'a t -> unit
Iterate on elements and their index in the sequence
-
val fold : ('b -> 'a -> 'b) -> 'b -> 'a t -> 'b
+ +
val fold : ('a -> 'b -> 'a) -> 'a -> 'b t -> 'a
Fold over elements of the sequence, consuming it
-
val foldi : ('b -> int -> 'a -> 'b) -> 'b -> 'a t -> 'b
+ +
val foldi : ('a -> int -> 'b -> 'a) -> 'a -> 'b t -> 'a
Fold over elements of the sequence and their index, consuming it
-
val map : ('a -> 'b) -> 'a t -> 'b t
+ +
val map : ('a -> 'b) -> 'a t -> 'b t
Map objects of the sequence into other elements, lazily
-
val mapi : (int -> 'a -> 'b) -> 'a t -> 'b t
+ +
val mapi : (int -> 'a -> 'b) -> 'a t -> 'b t
Map objects, along with their index in the sequence
-
val for_all : ('a -> bool) -> 'a t -> bool
+ +
val map_by_2 : ('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 : ('a -> bool) -> 'a t -> bool
Do all elements satisfy the predicate?
-
val exists : ('a -> bool) -> 'a t -> bool
+ +
val exists : ('a -> bool) -> 'a t -> bool
Exists there some element satisfying the predicate?
-
val length : 'a t -> int
-How long is the sequence?
+ +
val mem : ?eq:('a -> 'a -> bool) -> 'a -> 'a t -> bool
+Is the value a member of the sequence?
+Since 0.5
-
val is_empty : 'a t -> bool
-Is the sequence empty?
+
eq : the equality predicate to use (default (=))
+ +
val find : ('a -> 'b option) -> 'a t -> 'b option
+Find the first element on which the function doesn't return None
+Since 0.5
+
+ +
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 : ('a -> bool) -> 'a t -> 'a t
+ +
val filter : ('a -> bool) -> 'a t -> 'a t
Filter on elements of the sequence
-
val append : 'a t -> 'a t -> 'a t
-Append two sequences
+ +
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 concat : 'a t t -> 'a t
+Concatenate a sequence of sequences into one sequence.
-
val flatten : 'a t t -> 'a t
+ +
val flatten : 'a t t -> 'a t
Alias for Sequence.concat
-
val flatMap : ('a -> 'b t) -> 'a t -> 'b t
-Monadic bind. It applies the function to every element of the - initial sequence, and calls concat.
+ +
val flat_map : ('a -> 'b t) -> 'a t -> 'b t
+Monadic bind. Intuitively, it applies the function to every + element of the initial sequence, and calls Sequence.concat. + Formerly flatMap
+Since 0.5
-
val intersperse : 'a -> 'a t -> 'a t
-Insert the second element between every element of the sequence
+ +
val flat_map_l : ('a -> 'b list) -> 'a t -> 'b t
+Convenience function combining Sequence.flat_map and Sequence.of_list
+Since NEXT_RELEASE
-
val persistent : 'a t -> 'a t
-Iterate on the sequence, storing elements in a data structure. - The resulting sequence can be iterated on as many times as needed.
+ +
val filter_map : ('a -> 'b option) -> 'a t -> 'b t
+Map and only keep non-None elements + Formerly fmap
+Since 0.5
-
val sort : ?cmp:('a -> 'a -> int) -> 'a t -> 'a t
-Sort the sequence. Eager, O(n) ram and O(n ln(n)) time.
+ +
val intersperse : 'a -> 'a t -> 'a t
+Insert the single element between every element of the sequence
-
val sort_uniq : ?cmp:('a -> 'a -> int) -> 'a t -> 'a t
+
+

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 Sequence.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 (Sequence.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 group : ?eq:('a -> 'a -> bool) -> 'a t -> 'a list t
-Group equal consecutive elements.
+ +
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 uniq : ?eq:('a -> 'a -> bool) -> 'a t -> 'a t
+ +
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 uniq : ?eq:('a -> 'a -> bool) -> 'a t -> 'a t
Remove consecutive duplicate elements. Basically this is - like fun seq -> map List.hd (group seq).
+ like fun seq -> map List.hd (group seq).
-
val product : 'a t -> 'b t -> ('a * 'b) t
-Cartesian product of the sequences. The first one is transformed - by calling persistent on it, so that it can be traversed - several times (outer loop of the product)
+ +
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 Sequence.persistent on it + beforehand.
-
val join : join_row:('a -> 'b -> 'c option) ->
       'a t -> 'b t -> 'c t
+ +
val product2 : 'a t -> 'b t -> ('a, 'b) t2
+Binary version of Sequence.product. Same requirements.
+Since 0.5
+
+ +
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.
+ 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
+ +
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'.
+ yields Some (x,b') then x is returned + and unfoldr recurses with b'.
-
val scan : ('b -> 'a -> 'b) -> 'b -> 'a t -> 'b t
+ +
val scan : ('b -> 'a -> 'b) -> 'b -> 'a t -> 'b t
Sequence of intermediate results
-
val max : ?lt:('a -> 'a -> bool) -> 'a t -> 'a -> 'a
-Max element of the sequence, using the given comparison - function. A default element has to be provided.
+ +
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 -> 'a
-Min element of the sequence, using the given comparison function
+ +
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 take : int -> 'a t -> 'a t
-Take at most n elements from the sequence
+ +
val head : 'a t -> 'a option
+First element, if any, otherwise None
+Since 0.5.1
-
val drop : int -> 'a t -> 'a t
-Drop the n first elements of the sequence
+ +
val head_exn : 'a t -> 'a
+First element, if any, fails
+Since 0.5.1
+Raises Invalid_argument if the sequence is empty
-
val rev : 'a t -> 'a t
-Reverse the sequence. O(n) memory and time.
+ +
val take : int -> 'a t -> 'a t
+Take at most n elements from the sequence. Works on infinite + sequences.
+
+ +
val take_while : ('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 : ('a -> 'b -> 'a * [ `Continue | `Stop ]) -> 'a -> 'b t -> 'a
+Folds over elements of the sequence, stopping early if the accumulator + returns ('a, `Stop)
+Since 0.5.5
+
+ +
val drop : int -> 'a t -> 'a t
+Drop the n first elements of the sequence. Lazy.
+
+ +
val drop_while : ('a -> bool) -> 'a t -> 'a t
+Predicate version of Sequence.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
+ +
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 : ('c -> 'a -> 'b -> 'c) -> 'c -> ('a, 'b) t2 -> 'c
val iter2 : ('a -> 'b -> unit) -> ('a, 'b) t2 -> unit
val map2 : ('a -> 'b -> 'c) -> ('a, 'b) t2 -> 'c t
val map2_2 : ('a -> 'b -> 'c) ->
       ('a -> 'b -> 'd) -> ('a, 'b) t2 -> ('c, 'd) t2
+ +
val fold2 : ('c -> 'a -> 'b -> 'c) -> 'c -> ('a, 'b) t2 -> 'c
+
val iter2 : ('a -> 'b -> unit) -> ('a, 'b) t2 -> unit
+
val map2 : ('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
val to_rev_list : 'a t -> 'a list
-Get the list of the reversed sequence (more efficient)
+ +
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 Sequence.to_rev_list.
-
val of_list : 'a list -> 'a t
val to_array : 'a t -> 'a array
+ +
val to_rev_list : 'a t -> 'a list
+Get the list of the reversed sequence (more efficient than Sequence.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.
+Since 0.5.2
+
+ +
val to_opt : 'a t -> 'a option
+Alias to Sequence.head
+Since 0.5.1
+
+ +
val to_array : 'a t -> 'a array
Convert to an array. Currently not very efficient because - and intermediate list is used.
+ an intermediate list is used.
-
val of_array : 'a array -> 'a t
val of_array_i : 'a array -> (int * 'a) t
+ +
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
+ +
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
+ from i to j
-
val of_stream : 'a Stream.t -> 'a t
+ +
val of_opt : 'a option -> 'a t
+Iterate on 0 or 1 values.
+Since 0.5.1
+
+ +
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
+ +
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
+ +
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
+ +
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
+ +
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
+ +
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
+ +
val hashtbl_add : ('a, 'b) Hashtbl.t -> ('a * 'b) t -> unit
Add elements of the sequence to the hashtable, with - Hashtbl.add
+ Hashtbl.add
-
val hashtbl_replace : ('a, 'b) Hashtbl.t -> ('a * 'b) t -> unit
+ +
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)
+ Hashtbl.replace (erases conflicting bindings)
-
val to_hashtbl : ('a * 'b) t -> ('a, 'b) Hashtbl.t
+ +
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
+ +
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
+ +
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
+ +
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 of_in_channel : Pervasives.in_channel -> char t
val to_buffer : char t -> Buffer.t -> unit
+ +
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 Sequence.intersperse to add a separator.
+Since 0.5
+
+ +
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 Sequence.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
+ +
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 of_set : (module Set.S with type elt = 'a and type t = 'b) -> 'b -> 'a t
+ +
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 -> int -> int -> int t
+int_range_by ~step i 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.
+Raises Invalid_argument if step=0
+
+ +
val bools : bool t
+Iterates on true and false
+Since 0.7
+
+ +
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
+ +
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
val random_bool : bool t
val random_float : float -> float t
val random_array : 'a array -> 'a t
+ +
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

-

Type-classes


-
module TypeClass: sig .. end

-

Infix functions


-
module Infix: sig .. end

-

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 random_list : 'a list -> 'a t
+Infinite sequence of random elements of the list. Basically the + same as Sequence.random_array.
- \ No newline at end of file + +
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 : 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 : 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 Sequence.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 929010b..3a9bf8f 100644 --- a/api/html.stamp +++ b/api/html.stamp @@ -1 +1 @@ -8860b0ecfcc48b9b2fb5adef35908225 \ No newline at end of file +f0710dfe44cf0fb5dacae3bfdb0e21a2 \ No newline at end of file diff --git a/api/index.html b/api/index.html index db1821e..260626a 100644 --- a/api/index.html +++ b/api/index.html @@ -5,15 +5,18 @@ + - + +

  • Index of types
    • +
  • Index of exceptions
  • Index of values
  • Index of modules
  • Index of module types
    • @@ -21,7 +24,11 @@

    +
    Sequence
    -Transient iterators, that abstract on a finite sequence of elements. +Simple and Efficient Iterators +
    +
    SequenceLabels
    +Simple and Efficient Iterators
    diff --git a/api/index_attributes.html b/api/index_attributes.html index 5f68e9c..7a57b12 100644 --- a/api/index_attributes.html +++ b/api/index_attributes.html @@ -4,10 +4,12 @@ + -Index of class attributes + +Index of class attributes
     Up diff --git a/api/index_class_types.html b/api/index_class_types.html index dc35f10..3563748 100644 --- a/api/index_class_types.html +++ b/api/index_class_types.html @@ -4,10 +4,12 @@ + -Index of class types + +Index of class types
     Up diff --git a/api/index_classes.html b/api/index_classes.html index ba10ab9..dbe98c3 100644 --- a/api/index_classes.html +++ b/api/index_classes.html @@ -4,10 +4,12 @@ + -Index of classes + +Index of classes
     Up diff --git a/api/index_exceptions.html b/api/index_exceptions.html index 2ea47cc..f9d6d72 100644 --- a/api/index_exceptions.html +++ b/api/index_exceptions.html @@ -4,16 +4,31 @@ + -Index of exceptions + +Index of exceptions
     Up  

    Index of exceptions

    + + + + +

    O
    OneShotSequence [SequenceLabels]
    +Raised when the user tries to iterate several times on + a transient iterator +
    +
    OneShotSequence [Sequence]
    +Raised when the user tries to iterate several times on + a transient iterator +
    +
    \ No newline at end of file diff --git a/api/index_methods.html b/api/index_methods.html index d1b975e..d5ae037 100644 --- a/api/index_methods.html +++ b/api/index_methods.html @@ -4,10 +4,12 @@ + -Index of class methods + +Index of class methods
     Up diff --git a/api/index_module_types.html b/api/index_module_types.html index 5697df3..b03b43f 100644 --- a/api/index_module_types.html +++ b/api/index_module_types.html @@ -4,10 +4,12 @@ + -Index of module types + +Index of module types
     Up @@ -15,6 +17,10 @@

    Index of module types

    + + + + diff --git a/api/index_modules.html b/api/index_modules.html index 9c74f8f..05b00e0 100644 --- a/api/index_modules.html +++ b/api/index_modules.html @@ -4,10 +4,12 @@ + -Index of modules + +Index of modules
     Up @@ -15,6 +17,16 @@

    Index of modules


    S
    S [SequenceLabels.Map]
    S [SequenceLabels.Set]
    S [Sequence.Map]
    S [Sequence.Set]
    + + + + + + + + + + + + + + + + - + + + - - +

    A
    Adapt [SequenceLabels.Map]
    +Adapt a pre-existing Map module to make it sequence-aware +
    +
    Adapt [SequenceLabels.Set]
    +Create an enriched Set module from the given one +
    +
    Adapt [Sequence.Map]
    Adapt a pre-existing Map module to make it sequence-aware @@ -26,9 +38,25 @@ Create an enriched Set module from the given one

    I
    IO [SequenceLabels]
    IO [Sequence]
    Infix [SequenceLabels]
    Infix [Sequence]

    M
    Make [SequenceLabels.Map]
    +Create an enriched Map module, with sequence-aware functions +
    +
    Make [SequenceLabels.Set]
    +Functor to build an extended Set module from an ordered type +
    +
    Make [Sequence.Map]
    Create an enriched Map module, with sequence-aware functions @@ -39,18 +67,24 @@ Create an enriched Map module, with sequence-aware functions Functor to build an extended Set module from an ordered type
    Map [SequenceLabels]
    Map [Sequence]

    S
    Sequence
    -Transient iterators, that abstract on a finite sequence of elements. +Simple and Efficient Iterators
    Set [Sequence]
    SequenceLabels
    +Simple and Efficient Iterators +
    +
    Set [SequenceLabels]

    T
    TypeClass [Sequence]
    Set [Sequence]
    diff --git a/api/index_types.html b/api/index_types.html index ff4f35c..744fe08 100644 --- a/api/index_types.html +++ b/api/index_types.html @@ -4,40 +4,47 @@ + -Index of types + +Index of types
     Up  

    Index of types

    - - + + - - + - - + + - + - - - + + + + + + + diff --git a/api/index_values.html b/api/index_values.html index 22e51aa..30188be 100644 --- a/api/index_values.html +++ b/api/index_values.html @@ -4,10 +4,12 @@ + -Index of values + +Index of values
     Up @@ -15,28 +17,143 @@

    Index of values


    A
    addable [Sequence.TypeClass]

    G
    gen [SequenceLabels]

    I
    iterable [Sequence.TypeClass]
    gen [Sequence]

    M
    map [Sequence.Map.S]

    K
    klist [SequenceLabels]
    monoid [Sequence.TypeClass]
    klist [Sequence]

    S
    sequenceable [Sequence.TypeClass]
    -Classes -
    -
    set [Sequence.Set.S]
    sequence [SequenceLabels]
    sequence [Sequence]

    T
    t [SequenceLabels]
    +A sequence of values of type 'a. +
    +
    t [Sequence]
    -Sequence abstract iterator type, representing a finite sequence of - values of type 'a. +A sequence of values of type 'a. +
    +
    t2 [SequenceLabels]
    +Sequence of pairs of values of type 'a and 'b.
    t2 [Sequence]
    + + - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -45,60 +162,182 @@ Cycle forever through the given sequence. + + + + + + + + + + - + + + + + + + + + - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -106,64 +345,174 @@ Sequence that calls the given function to produce elements Call the function repeatedly until it returns None. + + - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - + + + + + - - + + + + @@ -172,116 +521,324 @@ Iterate on elements and their index in the sequence + + + + - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - + + + + + + + + + + + + + + + + + + + + + + - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -289,23 +846,96 @@ Pretty print a sequence of 'a, using the given pretty Cartesian product of the sequences. + + + + + + + + + + + + + + + + - + + + - + + + + + + + + + @@ -314,16 +944,71 @@ Reverse the sequence. + + + + + + - - + + + + + + + + + + + + + + + + @@ -331,91 +1016,274 @@ Singleton sequence Sort the sequence. + + - + + + + + + + + + - - + + + + + + + + + + - + + + + + + + + + + + + + + + + + + + + + - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

    (--) [SequenceLabels.Infix]
    +a -- b is the range of integers from a to b, both included, + in increasing order. +
    +
    (--) [Sequence.Infix]
    (@@) [Sequence.Infix]
    (|>) [Sequence.Infix]
    +a -- b is the range of integers from a to b, both included, + in increasing order. +
    +
    (--^) [SequenceLabels.Infix]
    +a --^ b is the range of integers from b to a, both included, + in decreasing order (starts from a). +
    +
    (--^) [Sequence.Infix]
    +a --^ b is the range of integers from b to a, both included, + in decreasing order (starts from a). +
    +
    (<*>) [SequenceLabels.Infix]
    +Applicative operator (product+application) +
    +
    (<*>) [Sequence.Infix]
    +Applicative operator (product+application) +
    +
    (<+>) [SequenceLabels.Infix]
    +Concatenation of sequences +
    +
    (<+>) [Sequence.Infix]
    +Concatenation of sequences +
    +
    (>>=) [SequenceLabels.Infix]
    +Monadic bind (infix version of SequenceLabels.flat_map +
    +
    (>>=) [Sequence.Infix]
    +Monadic bind (infix version of Sequence.flat_map +
    +
    (>|=) [SequenceLabels.Infix]
    +Infix version of SequenceLabels.map +
    +
    (>|=) [Sequence.Infix]
    +Infix version of Sequence.map +
    +

    A
    append [SequenceLabels]
    +Append two sequences. +
    +
    append [Sequence]
    -Append two sequences +Append two sequences. +
    +
    array_slice [SequenceLabels]
    +array_slice a i j Sequence of elements whose indexes range + from i to j
    array_slice [Sequence]
    array_slice a i j Sequence of elements whose indexes range - from i to j + from i to j +
    +

    B
    bools [Sequence]
    +Iterates on true and false

    C
    chunks_of [SequenceLabels.IO]
    +Read chunks of the given size from the file. +
    +
    chunks_of [Sequence.IO]
    +Read chunks of the given size from the file. +
    +
    concat [SequenceLabels]
    +Concatenate a sequence of sequences into one sequence. +
    +
    concat [Sequence]
    -Concatenate a sequence of sequences into one sequence +Concatenate a sequence of sequences into one sequence. +
    +
    concat_str [SequenceLabels]
    +Concatenate strings together, eagerly. +
    +
    concat_str [Sequence]
    +Concatenate strings together, eagerly. +
    +
    cons [SequenceLabels]
    +cons x l yields x, then yields from l. +
    +
    cons [Sequence]
    +cons x l yields x, then yields from l. +
    +
    cycle [SequenceLabels]
    +Cycle forever through the given sequence.
    cycle [Sequence]

    D
    doubleton [SequenceLabels]
    +Sequence with exactly two elements +
    +
    doubleton [Sequence]
    +Sequence with exactly two elements +
    +
    drop [SequenceLabels]
    +Drop the n first elements of the sequence. +
    +
    drop [Sequence]
    -Drop the n first elements of the sequence +Drop the n first elements of the sequence. +
    +
    drop_while [SequenceLabels]
    +Predicate version of SequenceLabels.drop +
    +
    drop_while [Sequence]
    +Predicate version of Sequence.drop

    E
    empty [Sequence]
    empty [SequenceLabels]
    -Empty sequence +Empty sequence.
    empty [Sequence]
    +Empty sequence. +
    +
    empty2 [SequenceLabels]
    empty2 [Sequence]
    exists [SequenceLabels]
    +Exists there some element satisfying the predicate? +
    +
    exists [Sequence]
    Exists there some element satisfying the predicate?

    F
    filter [SequenceLabels]
    +Filter on elements of the sequence +
    +
    filter [Sequence]
    Filter on elements of the sequence
    flatMap [Sequence]
    filter_map [SequenceLabels]
    +Alias to fmap with a more explicit name +
    +
    filter_map [Sequence]
    +Map and only keep non-None elements + Formerly fmap +
    +
    find [SequenceLabels]
    +Find the first element on which the function doesn't return None +
    +
    find [Sequence]
    +Find the first element on which the function doesn't return None +
    +
    flat_map [SequenceLabels]
    +Alias to flatMap with a more explicit name +
    +
    flat_map [Sequence]
    Monadic bind.
    flat_map_l [SequenceLabels]
    +Convenience function combining SequenceLabels.flat_map and SequenceLabels.of_list +
    +
    flat_map_l [Sequence]
    +Convenience function combining Sequence.flat_map and Sequence.of_list +
    +
    flatten [SequenceLabels]
    +Alias for SequenceLabels.concat +
    +
    flatten [Sequence]
    Alias for Sequence.concat
    fold [SequenceLabels]
    +Fold over elements of the sequence, consuming it +
    +
    fold [Sequence]
    Fold over elements of the sequence, consuming it
    fold2 [SequenceLabels]
    fold2 [Sequence]
    fold_while [SequenceLabels]
    +Folds over elements of the sequence, stopping early if the accumulator + returns ('a, `Stop) +
    +
    fold_while [Sequence]
    +Folds over elements of the sequence, stopping early if the accumulator + returns ('a, `Stop) +
    +
    foldi [SequenceLabels]
    +Fold over elements of the sequence and their index, consuming it +
    +
    foldi [Sequence]
    Fold over elements of the sequence and their index, consuming it
    for_all [SequenceLabels]
    +Do all elements satisfy the predicate? +
    +
    for_all [Sequence]
    Do all elements satisfy the predicate?
    forever [SequenceLabels]
    +Sequence that calls the given function to produce elements. +
    +
    forever [Sequence]
    -Sequence that calls the given function to produce elements +Sequence that calls the given function to produce elements. +
    +
    from_fun [SequenceLabels]
    +Call the function repeatedly until it returns None.
    from_fun [Sequence]
    from_iter [SequenceLabels]
    +Build a sequence from a iter function +
    +
    from_iter [Sequence]
    Build a sequence from a iter function

    G
    group [Sequence]
    group_by [SequenceLabels]
    +Group equal elements, disregarding their order of appearance. +
    +
    group_by [Sequence]
    +Group equal elements, disregarding their order of appearance. +
    +
    group_succ_by [SequenceLabels]
    +Group equal consecutive elements. +
    +
    group_succ_by [Sequence]
    Group equal consecutive elements.

    H
    hashtbl_add [SequenceLabels]
    +Add elements of the sequence to the hashtable, with + Hashtbl.add +
    +
    hashtbl_add [Sequence]
    Add elements of the sequence to the hashtable, with - Hashtbl.add + Hashtbl.add
    hashtbl_keys [SequenceLabels]
    hashtbl_keys [Sequence]
    hashtbl_replace [SequenceLabels]
    +Add elements of the sequence to the hashtable, with + Hashtbl.replace (erases conflicting bindings) +
    +
    hashtbl_replace [Sequence]
    Add elements of the sequence to the hashtable, with - Hashtbl.replace (erases conflicting bindings) + Hashtbl.replace (erases conflicting bindings)
    hashtbl_values [SequenceLabels]
    hashtbl_values [Sequence]
    head [SequenceLabels]
    +First element, if any, otherwise None +
    +
    head [Sequence]
    +First element, if any, otherwise None +
    +
    head_exn [SequenceLabels]
    +First element, if any, fails +
    +
    head_exn [Sequence]
    +First element, if any, fails +
    +

    I
    int_range [SequenceLabels]
    +Iterator on integers in start...stop by steps 1. +
    +
    int_range [Sequence]
    -Iterator on integers in start...stop by steps 1 +Iterator on integers in start...stop by steps 1. +
    +
    int_range_by [SequenceLabels]
    +int_range_by ~step ~start:i ~stop:j is the range starting at i, including j, + where the difference between successive elements is step. +
    +
    int_range_by [Sequence]
    +int_range_by ~step i j is the range starting at i, including j, + where the difference between successive elements is step. +
    +
    int_range_dec [SequenceLabels]
    +Iterator on decreasing integers in stop...start by steps -1. +
    +
    int_range_dec [Sequence]
    +Iterator on decreasing integers in stop...start by steps -1. +
    +
    intersperse [SequenceLabels]
    +Insert the single element between every element of the sequence
    intersperse [Sequence]
    -Insert the second element between every element of the sequence +Insert the single element between every element of the sequence +
    +
    is_empty [SequenceLabels]
    +Is the sequence empty? Forces the sequence.
    is_empty [Sequence]
    -Is the sequence empty? +Is the sequence empty? Forces the sequence.
    is_empty2 [SequenceLabels]
    is_empty2 [Sequence]
    iter [Sequence]
    iter [SequenceLabels]
    -Consume the sequence, passing all its arguments to the function +Consume the sequence, passing all its arguments to the function.
    iter [Sequence]
    +Consume the sequence, passing all its arguments to the function. +
    +
    iter2 [SequenceLabels]
    iter2 [Sequence]
    iterable [Sequence.TypeClass]
    iterate [SequenceLabels]
    +iterate f x is the infinite sequence x, f(x), f(f(x)), ... +
    +
    iterate [Sequence]
    -iterate f x is the infinite sequence (x, f(x), f(f(x)), ...) +iterate f x is the infinite sequence x, f(x), f(f(x)), ... +
    +
    iteri [SequenceLabels]
    +Iterate on elements and their index in the sequence
    iteri [Sequence]

    J
    join [SequenceLabels]
    +join ~join_row a b combines every element of a with every + element of b using join_row. +
    +
    join [Sequence]
    join ~join_row a b combines every element of a with every - element of b using join_row. + element of b using join_row.

    K
    keys [SequenceLabels.Map.S]
    keys [Sequence.Map.S]

    L
    length [Sequence]
    length [SequenceLabels]
    -How long is the sequence? +How long is the sequence? Forces the sequence.
    length [Sequence]
    +How long is the sequence? Forces the sequence. +
    +
    length2 [SequenceLabels]
    length2 [Sequence]
    lines_of [SequenceLabels.IO]
    +lines_of filename reads all lines of the given file. +
    +
    lines_of [Sequence.IO]
    +lines_of filename reads all lines of the given file. +
    +

    M
    map [SequenceLabels]
    +Map objects of the sequence into other elements, lazily +
    +
    map [Sequence]
    Map objects of the sequence into other elements, lazily
    map2 [SequenceLabels]
    map2 [Sequence]
    map2_2 [SequenceLabels]
    +map2_2 f g seq2 maps each x, y of seq2 into f x y, g x y +
    +
    map2_2 [Sequence]
    map2_2 f g seq2 maps each x, y of seq2 into f x y, g x y
    map_by_2 [SequenceLabels]
    +Map objects two by two. +
    +
    map_by_2 [Sequence]
    +Map objects two by two. +
    +
    mapi [SequenceLabels]
    +Map objects, along with their index in the sequence +
    +
    mapi [Sequence]
    Map objects, along with their index in the sequence
    max [SequenceLabels]
    +Max element of the sequence, using the given comparison function. +
    +
    max [Sequence]
    -Max element of the sequence, using the given comparison - function. +Max element of the sequence, using the given comparison function. +
    +
    mem [SequenceLabels]
    +Is the value a member of the sequence? +
    +
    mem [Sequence]
    +Is the value a member of the sequence? +
    +
    min [SequenceLabels]
    +Min element of the sequence, using the given comparison function.
    min [Sequence]
    -Min element of the sequence, using the given comparison function +Min element of the sequence, using the given comparison function.
    monoid [Sequence.TypeClass]

    O
    of_array [SequenceLabels]
    of_array [Sequence]
    of_array2 [SequenceLabels]
    of_array2 [Sequence]
    of_array_i [SequenceLabels]
    +Elements of the array, with their index +
    +
    of_array_i [Sequence]
    Elements of the array, with their index
    of_gen [SequenceLabels]
    +Traverse eagerly the generator and build a sequence from it +
    +
    of_gen [Sequence]
    +Traverse eagerly the generator and build a sequence from it +
    +
    of_hashtbl [SequenceLabels]
    +Sequence of key/value pairs from the hashtable +
    +
    of_hashtbl [Sequence]
    Sequence of key/value pairs from the hashtable
    of_hashtbl2 [SequenceLabels]
    +Sequence of key/value pairs from the hashtable +
    +
    of_hashtbl2 [Sequence]
    Sequence of key/value pairs from the hashtable
    of_in_channel [SequenceLabels]
    +Iterates on characters of the input (can block when one + iterates over the sequence). +
    +
    of_in_channel [Sequence]
    +Iterates on characters of the input (can block when one + iterates over the sequence). +
    +
    of_klist [SequenceLabels]
    +Iterate on the lazy list +
    +
    of_klist [Sequence]
    +Iterate on the lazy list +
    +
    of_list [SequenceLabels.Map.S]
    of_iterable [Sequence.TypeClass]
    of_list [SequenceLabels.Set.S]
    of_list [SequenceLabels]
    of_list [Sequence.Map.S]
    of_list [Sequence.Set.S]
    of_list [Sequence]
    of_opt [SequenceLabels]
    +Iterate on 0 or 1 values. +
    +
    of_opt [Sequence]
    +Iterate on 0 or 1 values. +
    +
    of_queue [SequenceLabels]
    +Sequence of elements contained in the queue, FIFO order +
    +
    of_queue [Sequence]
    Sequence of elements contained in the queue, FIFO order
    of_seq [SequenceLabels.Map.S]
    of_seq [SequenceLabels.Set.S]
    of_seq [Sequence.Map.S]
    of_seq [Sequence.Set.S]
    of_set [SequenceLabels]
    +Convert the given set to a sequence. +
    +
    of_set [Sequence]
    Convert the given set to a sequence.
    of_stack [SequenceLabels]
    +Sequence of elements of the stack (same order as Stack.iter) +
    +
    of_stack [Sequence]
    Sequence of elements of the stack (same order as Stack.iter)
    of_str [SequenceLabels]
    of_str [Sequence]
    of_stream [SequenceLabels]
    +Sequence of elements of a stream (usable only once) +
    +
    of_stream [Sequence]
    Sequence of elements of a stream (usable only once)
    on_list [SequenceLabels]
    +on_list f l is equivalent to to_list @@ f @@ of_list l. +
    +
    on_list [Sequence]
    +on_list f l is equivalent to to_list @@ f @@ of_list l. +
    +

    P
    persistent [SequenceLabels]
    +Iterate on the sequence, storing elements in an efficient internal structure.. +
    +
    persistent [Sequence]
    -Iterate on the sequence, storing elements in a data structure. +Iterate on the sequence, storing elements in an efficient internal structure.. +
    +
    persistent_lazy [SequenceLabels]
    +Lazy version of SequenceLabels.persistent. +
    +
    persistent_lazy [Sequence]
    +Lazy version of Sequence.persistent. +
    +
    pp_buf [SequenceLabels]
    +Print into a buffer +
    +
    pp_buf [Sequence]
    +Print into a buffer +
    +
    pp_seq [SequenceLabels]
    +Pretty print a sequence of 'a, using the given pretty printer + to print each elements.
    pp_seq [Sequence]
    Pretty print a sequence of 'a, using the given pretty printer - to print each elements. + to print each elements. +
    +
    product [SequenceLabels]
    +Cartesian product of the sequences.
    product [Sequence]
    product2 [SequenceLabels]
    +Binary version of SequenceLabels.product. +
    +
    product2 [Sequence]
    +Binary version of Sequence.product. +
    +
    pure [SequenceLabels]
    +Synonym to SequenceLabels.singleton +
    +
    pure [Sequence]
    +Synonym to Sequence.singleton +
    +

    R
    random_array [SequenceLabels]
    +Sequence of choices of an element in the array +
    +
    random_array [Sequence]
    Sequence of choices of an element in the array
    random_bool [SequenceLabels]
    +Infinite sequence of random bool values +
    +
    random_bool [Sequence]
    +Infinite sequence of random bool values +
    +
    random_float [SequenceLabels]
    random_float [Sequence]
    random_int [SequenceLabels]
    +Infinite sequence of random integers between 0 and + the given higher bound (see Random.int) +
    +
    random_int [Sequence]
    +Infinite sequence of random integers between 0 and + the given higher bound (see Random.int) +
    +
    random_list [SequenceLabels]
    +Infinite sequence of random elements of the list. +
    +
    random_list [Sequence]
    +Infinite sequence of random elements of the list. +
    +
    repeat [SequenceLabels]
    +Infinite sequence of the same element. +
    +
    repeat [Sequence]
    -Infinite sequence of the same element +Infinite sequence of the same element. +
    +
    return [SequenceLabels]
    +Synonym to SequenceLabels.singleton +
    +
    return [Sequence]
    +Synonym to Sequence.singleton +
    +
    rev [SequenceLabels]
    +Reverse the sequence.
    rev [Sequence]

    S
    sample [SequenceLabels]
    +sample n seq returns k samples of seq, with uniform probability. +
    +
    sample [Sequence]
    +sample n seq returns k samples of seq, with uniform probability. +
    +
    scan [SequenceLabels]
    +Sequence of intermediate results +
    +
    scan [Sequence]
    Sequence of intermediate results
    sequenceable [Sequence.TypeClass]
    shuffle [SequenceLabels]
    +shuffle seq returns a perfect shuffle of seq. +
    +
    shuffle [Sequence]
    +shuffle seq returns a perfect shuffle of seq. +
    +
    shuffle_buffer [SequenceLabels]
    +shuffle_buffer n seq returns a sequence of element of seq in random + order. +
    +
    shuffle_buffer [Sequence]
    +shuffle_buffer n seq returns a sequence of element of seq in random + order. +
    +
    singleton [SequenceLabels]
    +Singleton sequence, with exactly one element. +
    +
    singleton [Sequence]
    -Singleton sequence +Singleton sequence, with exactly one element. +
    +
    snoc [SequenceLabels]
    +Same as SequenceLabels.cons but yields the element after iterating on l +
    +
    snoc [Sequence]
    +Same as Sequence.cons but yields the element after iterating on l +
    +
    sort [SequenceLabels]
    +Sort the sequence.
    sort [Sequence]
    sort_uniq [SequenceLabels]
    +Sort the sequence and remove duplicates. +
    +
    sort_uniq [Sequence]
    Sort the sequence and remove duplicates.

    T
    take [Sequence]
    take [SequenceLabels]
    -Take at most n elements from the sequence +Take at most n elements from the sequence. +
    +
    take [Sequence]
    +Take at most n elements from the sequence. +
    +
    take_while [SequenceLabels]
    +Take elements while they satisfy the predicate, then stops iterating. +
    +
    take_while [Sequence]
    +Take elements while they satisfy the predicate, then stops iterating. +
    +
    to_array [SequenceLabels]
    +Convert to an array.
    to_addable [Sequence.TypeClass]
    to_array [Sequence]
    Convert to an array.
    to_buffer [SequenceLabels]
    +Copy content of the sequence into the buffer +
    +
    to_buffer [Sequence]
    Copy content of the sequence into the buffer
    to_gen [SequenceLabels]
    +Make the sequence persistent (O(n)) and then iterate on it. +
    +
    to_gen [Sequence]
    +Make the sequence persistent (O(n)) and then iterate on it. +
    +
    to_hashtbl [SequenceLabels]
    +Build a hashtable from a sequence of key/value pairs +
    +
    to_hashtbl [Sequence]
    Build a hashtable from a sequence of key/value pairs
    to_hashtbl2 [SequenceLabels]
    +Build a hashtable from a sequence of key/value pairs +
    +
    to_hashtbl2 [Sequence]
    Build a hashtable from a sequence of key/value pairs
    to_list [Sequence]
    to_klist [SequenceLabels]
    +Make the sequence persistent and then iterate on it. +
    +
    to_klist [Sequence]
    +Make the sequence persistent and then iterate on it. +
    +
    to_list [SequenceLabels.Map.S]
    to_list [SequenceLabels.Set.S]
    to_list [SequenceLabels]
    +Convert the sequence into a list. +
    +
    to_list [Sequence.Map.S]
    to_list [Sequence.Set.S]
    to_list [Sequence]
    +Convert the sequence into a list. +
    +
    to_opt [SequenceLabels]
    +Alias to SequenceLabels.head +
    +
    to_opt [Sequence]
    +Alias to Sequence.head +
    +
    to_queue [SequenceLabels]
    +Push elements of the sequence into the queue +
    +
    to_queue [Sequence]
    Push elements of the sequence into the queue
    to_rev_list [Sequence]
    to_rev_list [SequenceLabels]
    -Get the list of the reversed sequence (more efficient) +Get the list of the reversed sequence (more efficient than SequenceLabels.to_list)
    to_rev_list [Sequence]
    +Get the list of the reversed sequence (more efficient than Sequence.to_list) +
    +
    to_seq [SequenceLabels.Map.S]
    to_seq [SequenceLabels.Set.S]
    to_seq [Sequence.Map.S]
    to_seq [Sequence.Set.S]
    to_set [SequenceLabels]
    +Convert the sequence to a set, given the proper set module +
    +
    to_set [Sequence]
    Convert the sequence to a set, given the proper set module
    to_stack [SequenceLabels]
    +Push elements of the sequence on the stack +
    +
    to_stack [Sequence]
    Push elements of the sequence on the stack
    to_str [SequenceLabels]
    to_str [Sequence]
    to_stream [SequenceLabels]
    +Convert to a stream. +
    +
    to_stream [Sequence]
    Convert to a stream.
    to_string [SequenceLabels]
    +Print into a string +
    +
    to_string [Sequence]
    +Print into a string +
    +

    U
    unfoldr [SequenceLabels]
    +unfoldr f b will apply f to b. +
    +
    unfoldr [Sequence]
    unfoldr f b will apply f to b.
    uniq [SequenceLabels]
    +Remove consecutive duplicate elements. +
    +
    uniq [Sequence]
    Remove consecutive duplicate elements.
    unzip [SequenceLabels]
    unzip [Sequence]

    V
    values [SequenceLabels.Map.S]
    values [Sequence.Map.S]

    W
    write_bytes_lines [SequenceLabels.IO]
    write_bytes_lines [Sequence.IO]
    +
    +
    write_bytes_to [SequenceLabels.IO]
    +
    +
    write_bytes_to [Sequence.IO]
    +
    +
    write_lines [SequenceLabels.IO]
    +Same as SequenceLabels.IO.write_to, but intercales '\n' between each string +
    +
    write_lines [Sequence.IO]
    +Same as Sequence.IO.write_to, but intercales '\n' between each string +
    +
    write_to [SequenceLabels.IO]
    +write_to filename seq writes all strings from seq into the given + file. +
    +
    write_to [Sequence.IO]
    +write_to filename seq writes all strings from seq into the given + file. +
    +

    Z
    zip [SequenceLabels]
    zip [Sequence]
    zip_i [SequenceLabels]
    +Zip elements of the sequence with their index in the sequence +
    +
    zip_i [Sequence]
    Zip elements of the sequence with their index in the sequence diff --git a/api/style.css b/api/style.css index 993fd5c..a5b4578 100644 --- a/api/style.css +++ b/api/style.css @@ -1,7 +1,5 @@ .keyword { font-weight : bold ; color : Red } .keywordsign { color : #C04600 } -.superscript { font-size : 4 } -.subscript { font-size : 4 } .comment { color : Green } .constructor { color : Blue } .type { color : #5C6585 } diff --git a/api/type_Sequence.Infix.html b/api/type_Sequence.Infix.html index 0006b96..25d4c7a 100644 --- a/api/type_Sequence.Infix.html +++ b/api/type_Sequence.Infix.html @@ -3,14 +3,19 @@ + -Sequence.Infix + +Sequence.Infix -sig
    -  val ( -- ) : int -> int -> int Sequence.t
    -  val ( |> ) : 'a -> ('a -> 'b) -> 'b
    -  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 cc3c1df..1506e16 100644 --- a/api/type_Sequence.Map.Adapt.html +++ b/api/type_Sequence.Map.Adapt.html @@ -3,44 +3,48 @@ + -Sequence.Map.Adapt + +Sequence.Map.Adapt -functor (M : Map.S) ->
    -  sig
    -    type 'a map = 'a M.t
    -    type key = M.key
    -    val empty : 'a map
    -    val is_empty : 'a map -> bool
    -    val mem : key -> 'a map -> bool
    -    val add : key -> 'a -> 'a map -> 'a map
    -    val singleton : key -> 'a -> 'a map
    -    val remove : key -> 'a map -> 'a map
    -    val merge :
    -      (key -> 'a option -> 'b option -> 'c option) ->
    -      'a map -> 'b map -> 'c map
    -    val compare : ('a -> 'a -> int) -> 'a map -> 'a map -> int
    -    val equal : ('a -> 'a -> bool) -> 'a map -> 'a map -> bool
    -    val iter : (key -> 'a -> unit) -> 'a map -> unit
    -    val fold : (key -> 'a -> 'b -> 'b) -> 'a map -> 'b -> 'b
    -    val for_all : (key -> 'a -> bool) -> 'a map -> bool
    -    val exists : (key -> 'a -> bool) -> 'a map -> bool
    -    val filter : (key -> 'a -> bool) -> 'a map -> 'a map
    -    val partition : (key -> 'a -> bool) -> 'a map -> 'a map * 'a map
    -    val cardinal : 'a map -> int
    -    val bindings : 'a map -> (key * 'a) list
    -    val min_binding : 'a map -> key * 'a
    -    val max_binding : 'a map -> key * 'a
    -    val choose : 'a map -> key * 'a
    -    val split : key -> 'a map -> 'a map * 'a option * 'a map
    -    val find : key -> 'a map -> 'a
    -    val map : ('a -> 'b) -> 'a map -> 'b map
    -    val mapi : (key -> 'a -> 'b) -> 'a map -> 'b map
    -    val to_seq : 'a map -> (key * 'a) t
    -    val of_seq : (key * 'a) t -> 'a map
    -    val keys : 'a map -> key t
    -    val values : 'a map -> '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 34b67f0..267d7c3 100644 --- a/api/type_Sequence.Map.Make.html +++ b/api/type_Sequence.Map.Make.html @@ -3,44 +3,48 @@ + -Sequence.Map.Make + +Sequence.Map.Make -functor (V : Map.OrderedType) ->
    -  sig
    -    type +'a map
    -    type key = V.t
    -    val empty : 'a map
    -    val is_empty : 'a map -> bool
    -    val mem : key -> 'a map -> bool
    -    val add : key -> 'a -> 'a map -> 'a map
    -    val singleton : key -> 'a -> 'a map
    -    val remove : key -> 'a map -> 'a map
    -    val merge :
    -      (key -> 'a option -> 'b option -> 'c option) ->
    -      'a map -> 'b map -> 'c map
    -    val compare : ('a -> 'a -> int) -> 'a map -> 'a map -> int
    -    val equal : ('a -> 'a -> bool) -> 'a map -> 'a map -> bool
    -    val iter : (key -> 'a -> unit) -> 'a map -> unit
    -    val fold : (key -> 'a -> 'b -> 'b) -> 'a map -> 'b -> 'b
    -    val for_all : (key -> 'a -> bool) -> 'a map -> bool
    -    val exists : (key -> 'a -> bool) -> 'a map -> bool
    -    val filter : (key -> 'a -> bool) -> 'a map -> 'a map
    -    val partition : (key -> 'a -> bool) -> 'a map -> 'a map * 'a map
    -    val cardinal : 'a map -> int
    -    val bindings : 'a map -> (key * 'a) list
    -    val min_binding : 'a map -> key * 'a
    -    val max_binding : 'a map -> key * 'a
    -    val choose : 'a map -> key * 'a
    -    val split : key -> 'a map -> 'a map * 'a option * 'a map
    -    val find : key -> 'a map -> 'a
    -    val map : ('a -> 'b) -> 'a map -> 'b map
    -    val mapi : (key -> 'a -> 'b) -> 'a map -> 'b map
    -    val to_seq : 'a map -> (key * 'a) t
    -    val of_seq : (key * 'a) t -> 'a map
    -    val keys : 'a map -> key t
    -    val values : 'a map -> '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 e52c7f4..ffd18a4 100644 --- a/api/type_Sequence.Map.S.html +++ b/api/type_Sequence.Map.S.html @@ -3,43 +3,47 @@ + -Sequence.Map.S + +Sequence.Map.S -sig
    -  type +'a map
    -  type key
    -  val empty : 'a map
    -  val is_empty : 'a map -> bool
    -  val mem : key -> 'a map -> bool
    -  val add : key -> 'a -> 'a map -> 'a map
    -  val singleton : key -> 'a -> 'a map
    -  val remove : key -> 'a map -> 'a map
    -  val merge :
    -    (key -> 'a option -> 'b option -> 'c option) ->
    -    'a map -> 'b map -> 'c map
    -  val compare : ('a -> 'a -> int) -> 'a map -> 'a map -> int
    -  val equal : ('a -> 'a -> bool) -> 'a map -> 'a map -> bool
    -  val iter : (key -> 'a -> unit) -> 'a map -> unit
    -  val fold : (key -> 'a -> 'b -> 'b) -> 'a map -> 'b -> 'b
    -  val for_all : (key -> 'a -> bool) -> 'a map -> bool
    -  val exists : (key -> 'a -> bool) -> 'a map -> bool
    -  val filter : (key -> 'a -> bool) -> 'a map -> 'a map
    -  val partition : (key -> 'a -> bool) -> 'a map -> 'a map * 'a map
    -  val cardinal : 'a map -> int
    -  val bindings : 'a map -> (key * 'a) list
    -  val min_binding : 'a map -> key * 'a
    -  val max_binding : 'a map -> key * 'a
    -  val choose : 'a map -> key * 'a
    -  val split : key -> 'a map -> 'a map * 'a option * 'a map
    -  val find : key -> 'a map -> 'a
    -  val map : ('a -> 'b) -> 'a map -> 'b map
    -  val mapi : (key -> 'a -> 'b) -> 'a map -> 'b map
    -  val to_seq : 'a Sequence.Map.S.map -> (key * 'a) Sequence.t
    -  val of_seq : (key * 'a) Sequence.t -> 'a Sequence.Map.S.map
    -  val keys : 'a Sequence.Map.S.map -> key Sequence.t
    -  val values : 'a Sequence.Map.S.map -> '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 e3ab51e..5079a3e 100644 --- a/api/type_Sequence.Map.html +++ b/api/type_Sequence.Map.html @@ -3,118 +3,128 @@ + -Sequence.Map + +Sequence.Map -sig
    -  module type S =
    -    sig
    -      type +'a map
    -      type key
    -      val empty : 'a map
    -      val is_empty : 'a map -> bool
    -      val mem : key -> 'a map -> bool
    -      val add : key -> 'a -> 'a map -> 'a map
    -      val singleton : key -> 'a -> 'a map
    -      val remove : key -> 'a map -> 'a map
    -      val merge :
    -        (key -> 'a option -> 'b option -> 'c option) ->
    -        'a map -> 'b map -> 'c map
    -      val compare : ('a -> 'a -> int) -> 'a map -> 'a map -> int
    -      val equal : ('a -> 'a -> bool) -> 'a map -> 'a map -> bool
    -      val iter : (key -> 'a -> unit) -> 'a map -> unit
    -      val fold : (key -> 'a -> 'b -> 'b) -> 'a map -> 'b -> 'b
    -      val for_all : (key -> 'a -> bool) -> 'a map -> bool
    -      val exists : (key -> 'a -> bool) -> 'a map -> bool
    -      val filter : (key -> 'a -> bool) -> 'a map -> 'a map
    -      val partition : (key -> 'a -> bool) -> 'a map -> 'a map * 'a map
    -      val cardinal : 'a map -> int
    -      val bindings : 'a map -> (key * 'a) list
    -      val min_binding : 'a map -> key * 'a
    -      val max_binding : 'a map -> key * 'a
    -      val choose : 'a map -> key * 'a
    -      val split : key -> 'a map -> 'a map * 'a option * 'a map
    -      val find : key -> 'a map -> 'a
    -      val map : ('a -> 'b) -> 'a map -> 'b map
    -      val mapi : (key -> 'a -> 'b) -> 'a map -> 'b map
    -      val to_seq : 'a Sequence.Map.S.map -> (key * 'a) Sequence.t
    -      val of_seq : (key * 'a) Sequence.t -> 'a Sequence.Map.S.map
    -      val keys : 'a Sequence.Map.S.map -> key Sequence.t
    -      val values : 'a Sequence.Map.S.map -> 'a Sequence.t
    -    end
    -  module Adapt :
    -    functor (M : Map.S) ->
    -      sig
    -        type 'a map = 'a M.t
    -        type key = M.key
    -        val empty : 'a map
    -        val is_empty : 'a map -> bool
    -        val mem : key -> 'a map -> bool
    -        val add : key -> 'a -> 'a map -> 'a map
    -        val singleton : key -> 'a -> 'a map
    -        val remove : key -> 'a map -> 'a map
    -        val merge :
    -          (key -> 'a option -> 'b option -> 'c option) ->
    -          'a map -> 'b map -> 'c map
    -        val compare : ('a -> 'a -> int) -> 'a map -> 'a map -> int
    -        val equal : ('a -> 'a -> bool) -> 'a map -> 'a map -> bool
    -        val iter : (key -> 'a -> unit) -> 'a map -> unit
    -        val fold : (key -> 'a -> 'b -> 'b) -> 'a map -> 'b -> 'b
    -        val for_all : (key -> 'a -> bool) -> 'a map -> bool
    -        val exists : (key -> 'a -> bool) -> 'a map -> bool
    -        val filter : (key -> 'a -> bool) -> 'a map -> 'a map
    -        val partition : (key -> 'a -> bool) -> 'a map -> 'a map * 'a map
    -        val cardinal : 'a map -> int
    -        val bindings : 'a map -> (key * 'a) list
    -        val min_binding : 'a map -> key * 'a
    -        val max_binding : 'a map -> key * 'a
    -        val choose : 'a map -> key * 'a
    -        val split : key -> 'a map -> 'a map * 'a option * 'a map
    -        val find : key -> 'a map -> 'a
    -        val map : ('a -> 'b) -> 'a map -> 'b map
    -        val mapi : (key -> 'a -> 'b) -> 'a map -> 'b map
    -        val to_seq : 'a map -> (key * 'a) t
    -        val of_seq : (key * 'a) t -> 'a map
    -        val keys : 'a map -> key t
    -        val values : 'a map -> 'a t
    -      end
    -  module Make :
    -    functor (V : Map.OrderedType) ->
    -      sig
    -        type +'a map
    -        type key = V.t
    -        val empty : 'a map
    -        val is_empty : 'a map -> bool
    -        val mem : key -> 'a map -> bool
    -        val add : key -> 'a -> 'a map -> 'a map
    -        val singleton : key -> 'a -> 'a map
    -        val remove : key -> 'a map -> 'a map
    -        val merge :
    -          (key -> 'a option -> 'b option -> 'c option) ->
    -          'a map -> 'b map -> 'c map
    -        val compare : ('a -> 'a -> int) -> 'a map -> 'a map -> int
    -        val equal : ('a -> 'a -> bool) -> 'a map -> 'a map -> bool
    -        val iter : (key -> 'a -> unit) -> 'a map -> unit
    -        val fold : (key -> 'a -> 'b -> 'b) -> 'a map -> 'b -> 'b
    -        val for_all : (key -> 'a -> bool) -> 'a map -> bool
    -        val exists : (key -> 'a -> bool) -> 'a map -> bool
    -        val filter : (key -> 'a -> bool) -> 'a map -> 'a map
    -        val partition : (key -> 'a -> bool) -> 'a map -> 'a map * 'a map
    -        val cardinal : 'a map -> int
    -        val bindings : 'a map -> (key * 'a) list
    -        val min_binding : 'a map -> key * 'a
    -        val max_binding : 'a map -> key * 'a
    -        val choose : 'a map -> key * 'a
    -        val split : key -> 'a map -> 'a map * 'a option * 'a map
    -        val find : key -> 'a map -> 'a
    -        val map : ('a -> 'b) -> 'a map -> 'b map
    -        val mapi : (key -> 'a -> 'b) -> 'a map -> 'b map
    -        val to_seq : 'a map -> (key * 'a) t
    -        val of_seq : (key * 'a) t -> 'a map
    -        val keys : 'a map -> key t
    -        val values : 'a map -> '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 ac941bb..4a8c1b9 100644 --- a/api/type_Sequence.Set.Adapt.html +++ b/api/type_Sequence.Set.Adapt.html @@ -3,40 +3,45 @@ + -Sequence.Set.Adapt + +Sequence.Set.Adapt -functor (X : Set.S) ->
    -  sig
    -    type set = X.t
    -    type elt = X.elt
    -    val empty : set
    -    val is_empty : set -> bool
    -    val mem : elt -> set -> bool
    -    val add : elt -> set -> set
    -    val singleton : elt -> set
    -    val remove : elt -> set -> set
    -    val union : set -> set -> set
    -    val inter : set -> set -> set
    -    val diff : set -> set -> set
    -    val compare : set -> set -> int
    -    val equal : set -> set -> bool
    -    val subset : set -> set -> bool
    -    val iter : (elt -> unit) -> set -> unit
    -    val fold : (elt -> 'a -> 'a) -> set -> 'a -> 'a
    -    val for_all : (elt -> bool) -> set -> bool
    -    val exists : (elt -> bool) -> set -> bool
    -    val filter : (elt -> bool) -> set -> set
    -    val partition : (elt -> bool) -> set -> set * set
    -    val cardinal : set -> int
    -    val elements : set -> elt list
    -    val min_elt : set -> elt
    -    val max_elt : set -> elt
    -    val choose : set -> elt
    -    val split : elt -> set -> set * bool * set
    -    val of_seq : elt t -> set
    -    val to_seq : set -> elt 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 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 5882212..532541b 100644 --- a/api/type_Sequence.Set.Make.html +++ b/api/type_Sequence.Set.Make.html @@ -3,40 +3,45 @@ + -Sequence.Set.Make + +Sequence.Set.Make -functor (X : Set.OrderedType) ->
    -  sig
    -    type set
    -    type elt = X.t
    -    val empty : set
    -    val is_empty : set -> bool
    -    val mem : elt -> set -> bool
    -    val add : elt -> set -> set
    -    val singleton : elt -> set
    -    val remove : elt -> set -> set
    -    val union : set -> set -> set
    -    val inter : set -> set -> set
    -    val diff : set -> set -> set
    -    val compare : set -> set -> int
    -    val equal : set -> set -> bool
    -    val subset : set -> set -> bool
    -    val iter : (elt -> unit) -> set -> unit
    -    val fold : (elt -> 'a -> 'a) -> set -> 'a -> 'a
    -    val for_all : (elt -> bool) -> set -> bool
    -    val exists : (elt -> bool) -> set -> bool
    -    val filter : (elt -> bool) -> set -> set
    -    val partition : (elt -> bool) -> set -> set * set
    -    val cardinal : set -> int
    -    val elements : set -> elt list
    -    val min_elt : set -> elt
    -    val max_elt : set -> elt
    -    val choose : set -> elt
    -    val split : elt -> set -> set * bool * set
    -    val of_seq : elt t -> set
    -    val to_seq : set -> elt 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 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 7ac2b38..660cd6a 100644 --- a/api/type_Sequence.Set.S.html +++ b/api/type_Sequence.Set.S.html @@ -3,39 +3,44 @@ + -Sequence.Set.S + +Sequence.Set.S -sig
    -  type set
    -  type elt
    -  val empty : set
    -  val is_empty : set -> bool
    -  val mem : elt -> set -> bool
    -  val add : elt -> set -> set
    -  val singleton : elt -> set
    -  val remove : elt -> set -> set
    -  val union : set -> set -> set
    -  val inter : set -> set -> set
    -  val diff : set -> set -> set
    -  val compare : set -> set -> int
    -  val equal : set -> set -> bool
    -  val subset : set -> set -> bool
    -  val iter : (elt -> unit) -> set -> unit
    -  val fold : (elt -> 'a -> 'a) -> set -> 'a -> 'a
    -  val for_all : (elt -> bool) -> set -> bool
    -  val exists : (elt -> bool) -> set -> bool
    -  val filter : (elt -> bool) -> set -> set
    -  val partition : (elt -> bool) -> set -> set * set
    -  val cardinal : set -> int
    -  val elements : set -> elt list
    -  val min_elt : set -> elt
    -  val max_elt : set -> elt
    -  val choose : set -> elt
    -  val split : elt -> set -> set * bool * set
    -  val of_seq : elt Sequence.t -> Sequence.Set.S.set
    -  val to_seq : Sequence.Set.S.set -> elt 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 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 b6d35fc..60550bc 100644 --- a/api/type_Sequence.Set.html +++ b/api/type_Sequence.Set.html @@ -3,106 +3,117 @@ + -Sequence.Set + +Sequence.Set -sig
    -  module type S =
    -    sig
    -      type set
    -      type elt
    -      val empty : set
    -      val is_empty : set -> bool
    -      val mem : elt -> set -> bool
    -      val add : elt -> set -> set
    -      val singleton : elt -> set
    -      val remove : elt -> set -> set
    -      val union : set -> set -> set
    -      val inter : set -> set -> set
    -      val diff : set -> set -> set
    -      val compare : set -> set -> int
    -      val equal : set -> set -> bool
    -      val subset : set -> set -> bool
    -      val iter : (elt -> unit) -> set -> unit
    -      val fold : (elt -> 'a -> 'a) -> set -> 'a -> 'a
    -      val for_all : (elt -> bool) -> set -> bool
    -      val exists : (elt -> bool) -> set -> bool
    -      val filter : (elt -> bool) -> set -> set
    -      val partition : (elt -> bool) -> set -> set * set
    -      val cardinal : set -> int
    -      val elements : set -> elt list
    -      val min_elt : set -> elt
    -      val max_elt : set -> elt
    -      val choose : set -> elt
    -      val split : elt -> set -> set * bool * set
    -      val of_seq : elt Sequence.t -> Sequence.Set.S.set
    -      val to_seq : Sequence.Set.S.set -> elt Sequence.t
    -    end
    -  module Adapt :
    -    functor (X : Set.S) ->
    -      sig
    -        type set = X.t
    -        type elt = X.elt
    -        val empty : set
    -        val is_empty : set -> bool
    -        val mem : elt -> set -> bool
    -        val add : elt -> set -> set
    -        val singleton : elt -> set
    -        val remove : elt -> set -> set
    -        val union : set -> set -> set
    -        val inter : set -> set -> set
    -        val diff : set -> set -> set
    -        val compare : set -> set -> int
    -        val equal : set -> set -> bool
    -        val subset : set -> set -> bool
    -        val iter : (elt -> unit) -> set -> unit
    -        val fold : (elt -> 'a -> 'a) -> set -> 'a -> 'a
    -        val for_all : (elt -> bool) -> set -> bool
    -        val exists : (elt -> bool) -> set -> bool
    -        val filter : (elt -> bool) -> set -> set
    -        val partition : (elt -> bool) -> set -> set * set
    -        val cardinal : set -> int
    -        val elements : set -> elt list
    -        val min_elt : set -> elt
    -        val max_elt : set -> elt
    -        val choose : set -> elt
    -        val split : elt -> set -> set * bool * set
    -        val of_seq : elt t -> set
    -        val to_seq : set -> elt t
    -      end
    -  module Make :
    -    functor (X : Set.OrderedType) ->
    -      sig
    -        type set
    -        type elt = X.t
    -        val empty : set
    -        val is_empty : set -> bool
    -        val mem : elt -> set -> bool
    -        val add : elt -> set -> set
    -        val singleton : elt -> set
    -        val remove : elt -> set -> set
    -        val union : set -> set -> set
    -        val inter : set -> set -> set
    -        val diff : set -> set -> set
    -        val compare : set -> set -> int
    -        val equal : set -> set -> bool
    -        val subset : set -> set -> bool
    -        val iter : (elt -> unit) -> set -> unit
    -        val fold : (elt -> 'a -> 'a) -> set -> 'a -> 'a
    -        val for_all : (elt -> bool) -> set -> bool
    -        val exists : (elt -> bool) -> set -> bool
    -        val filter : (elt -> bool) -> set -> set
    -        val partition : (elt -> bool) -> set -> set * set
    -        val cardinal : set -> int
    -        val elements : set -> elt list
    -        val min_elt : set -> elt
    -        val max_elt : set -> elt
    -        val choose : set -> elt
    -        val split : elt -> set -> set * bool * set
    -        val of_seq : elt t -> set
    -        val to_seq : set -> elt 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 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 \ No newline at end of file diff --git a/api/type_Sequence.html b/api/type_Sequence.html index 8fc6cf3..73f7f4a 100644 --- a/api/type_Sequence.html +++ b/api/type_Sequence.html @@ -3,336 +3,420 @@ + -Sequence + +Sequence -sig
    -  type 'a t = ('a -> unit) -> unit
    -  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 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 : ('b -> 'a -> 'b) -> 'b -> 'a Sequence.t -> 'b
    -  val foldi : ('b -> int -> 'a -> 'b) -> 'b -> 'a Sequence.t -> 'b
    -  val map : ('a -> 'b) -> 'a Sequence.t -> 'b Sequence.t
    -  val mapi : (int -> 'a -> 'b) -> 'a Sequence.t -> 'b Sequence.t
    -  val for_all : ('a -> bool) -> 'a Sequence.t -> bool
    -  val exists : ('a -> bool) -> 'a Sequence.t -> bool
    -  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 flatMap : ('a -> 'b Sequence.t) -> 'a Sequence.t -> 'b Sequence.t
    -  val intersperse : 'a -> 'a Sequence.t -> 'a Sequence.t
    -  val persistent : '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 : ?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 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 -> 'a
    -  val min : ?lt:('a -> 'a -> bool) -> 'a Sequence.t -> 'a -> 'a
    -  val take : int -> 'a Sequence.t -> 'a Sequence.t
    -  val drop : int -> '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 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_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 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 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
    -  module Set :
    -    sig
    -      module type S =
    -        sig
    -          type set
    -          type elt
    -          val empty : set
    -          val is_empty : set -> bool
    -          val mem : elt -> set -> bool
    -          val add : elt -> set -> set
    -          val singleton : elt -> set
    -          val remove : elt -> set -> set
    -          val union : set -> set -> set
    -          val inter : set -> set -> set
    -          val diff : set -> set -> set
    -          val compare : set -> set -> int
    -          val equal : set -> set -> bool
    -          val subset : set -> set -> bool
    -          val iter : (elt -> unit) -> set -> unit
    -          val fold : (elt -> 'a -> 'a) -> set -> 'a -> 'a
    -          val for_all : (elt -> bool) -> set -> bool
    -          val exists : (elt -> bool) -> set -> bool
    -          val filter : (elt -> bool) -> set -> set
    -          val partition : (elt -> bool) -> set -> set * set
    -          val cardinal : set -> int
    -          val elements : set -> elt list
    -          val min_elt : set -> elt
    -          val max_elt : set -> elt
    -          val choose : set -> elt
    -          val split : elt -> set -> set * bool * set
    -          val of_seq : elt Sequence.t -> Sequence.Set.S.set
    -          val to_seq : Sequence.Set.S.set -> elt Sequence.t
    -        end
    -      module Adapt :
    -        functor (X : Set.S) ->
    -          sig
    -            type set = X.t
    -            type elt = X.elt
    -            val empty : set
    -            val is_empty : set -> bool
    -            val mem : elt -> set -> bool
    -            val add : elt -> set -> set
    -            val singleton : elt -> set
    -            val remove : elt -> set -> set
    -            val union : set -> set -> set
    -            val inter : set -> set -> set
    -            val diff : set -> set -> set
    -            val compare : set -> set -> int
    -            val equal : set -> set -> bool
    -            val subset : set -> set -> bool
    -            val iter : (elt -> unit) -> set -> unit
    -            val fold : (elt -> 'a -> 'a) -> set -> 'a -> 'a
    -            val for_all : (elt -> bool) -> set -> bool
    -            val exists : (elt -> bool) -> set -> bool
    -            val filter : (elt -> bool) -> set -> set
    -            val partition : (elt -> bool) -> set -> set * set
    -            val cardinal : set -> int
    -            val elements : set -> elt list
    -            val min_elt : set -> elt
    -            val max_elt : set -> elt
    -            val choose : set -> elt
    -            val split : elt -> set -> set * bool * set
    -            val of_seq : elt t -> set
    -            val to_seq : set -> elt t
    -          end
    -      module Make :
    -        functor (X : Set.OrderedType) ->
    -          sig
    -            type set
    -            type elt = X.t
    -            val empty : set
    -            val is_empty : set -> bool
    -            val mem : elt -> set -> bool
    -            val add : elt -> set -> set
    -            val singleton : elt -> set
    -            val remove : elt -> set -> set
    -            val union : set -> set -> set
    -            val inter : set -> set -> set
    -            val diff : set -> set -> set
    -            val compare : set -> set -> int
    -            val equal : set -> set -> bool
    -            val subset : set -> set -> bool
    -            val iter : (elt -> unit) -> set -> unit
    -            val fold : (elt -> 'a -> 'a) -> set -> 'a -> 'a
    -            val for_all : (elt -> bool) -> set -> bool
    -            val exists : (elt -> bool) -> set -> bool
    -            val filter : (elt -> bool) -> set -> set
    -            val partition : (elt -> bool) -> set -> set * set
    -            val cardinal : set -> int
    -            val elements : set -> elt list
    -            val min_elt : set -> elt
    -            val max_elt : set -> elt
    -            val choose : set -> elt
    -            val split : elt -> set -> set * bool * set
    -            val of_seq : elt t -> set
    -            val to_seq : set -> elt t
    -          end
    -    end
    -  module Map :
    -    sig
    -      module type S =
    -        sig
    -          type +'a map
    -          type key
    -          val empty : 'a map
    -          val is_empty : 'a map -> bool
    -          val mem : key -> 'a map -> bool
    -          val add : key -> 'a -> 'a map -> 'a map
    -          val singleton : key -> 'a -> 'a map
    -          val remove : key -> 'a map -> 'a map
    -          val merge :
    -            (key -> 'a option -> 'b option -> 'c option) ->
    -            'a map -> 'b map -> 'c map
    -          val compare : ('a -> 'a -> int) -> 'a map -> 'a map -> int
    -          val equal : ('a -> 'a -> bool) -> 'a map -> 'a map -> bool
    -          val iter : (key -> 'a -> unit) -> 'a map -> unit
    -          val fold : (key -> 'a -> 'b -> 'b) -> 'a map -> 'b -> 'b
    -          val for_all : (key -> 'a -> bool) -> 'a map -> bool
    -          val exists : (key -> 'a -> bool) -> 'a map -> bool
    -          val filter : (key -> 'a -> bool) -> 'a map -> 'a map
    -          val partition : (key -> 'a -> bool) -> 'a map -> 'a map * 'a map
    -          val cardinal : 'a map -> int
    -          val bindings : 'a map -> (key * 'a) list
    -          val min_binding : 'a map -> key * 'a
    -          val max_binding : 'a map -> key * 'a
    -          val choose : 'a map -> key * 'a
    -          val split : key -> 'a map -> 'a map * 'a option * 'a map
    -          val find : key -> 'a map -> 'a
    -          val map : ('a -> 'b) -> 'a map -> 'b map
    -          val mapi : (key -> 'a -> 'b) -> 'a map -> 'b map
    -          val to_seq : 'a Sequence.Map.S.map -> (key * 'a) Sequence.t
    -          val of_seq : (key * 'a) Sequence.t -> 'a Sequence.Map.S.map
    -          val keys : 'a Sequence.Map.S.map -> key Sequence.t
    -          val values : 'a Sequence.Map.S.map -> 'a Sequence.t
    -        end
    -      module Adapt :
    -        functor (M : Map.S) ->
    -          sig
    -            type 'a map = 'a M.t
    -            type key = M.key
    -            val empty : 'a map
    -            val is_empty : 'a map -> bool
    -            val mem : key -> 'a map -> bool
    -            val add : key -> 'a -> 'a map -> 'a map
    -            val singleton : key -> 'a -> 'a map
    -            val remove : key -> 'a map -> 'a map
    -            val merge :
    -              (key -> 'a option -> 'b option -> 'c option) ->
    -              'a map -> 'b map -> 'c map
    -            val compare : ('a -> 'a -> int) -> 'a map -> 'a map -> int
    -            val equal : ('a -> 'a -> bool) -> 'a map -> 'a map -> bool
    -            val iter : (key -> 'a -> unit) -> 'a map -> unit
    -            val fold : (key -> 'a -> 'b -> 'b) -> 'a map -> 'b -> 'b
    -            val for_all : (key -> 'a -> bool) -> 'a map -> bool
    -            val exists : (key -> 'a -> bool) -> 'a map -> bool
    -            val filter : (key -> 'a -> bool) -> 'a map -> 'a map
    -            val partition : (key -> 'a -> bool) -> 'a map -> 'a map * 'a map
    -            val cardinal : 'a map -> int
    -            val bindings : 'a map -> (key * 'a) list
    -            val min_binding : 'a map -> key * 'a
    -            val max_binding : 'a map -> key * 'a
    -            val choose : 'a map -> key * 'a
    -            val split : key -> 'a map -> 'a map * 'a option * 'a map
    -            val find : key -> 'a map -> 'a
    -            val map : ('a -> 'b) -> 'a map -> 'b map
    -            val mapi : (key -> 'a -> 'b) -> 'a map -> 'b map
    -            val to_seq : 'a map -> (key * 'a) t
    -            val of_seq : (key * 'a) t -> 'a map
    -            val keys : 'a map -> key t
    -            val values : 'a map -> 'a t
    -          end
    -      module Make :
    -        functor (V : Map.OrderedType) ->
    -          sig
    -            type +'a map
    -            type key = V.t
    -            val empty : 'a map
    -            val is_empty : 'a map -> bool
    -            val mem : key -> 'a map -> bool
    -            val add : key -> 'a -> 'a map -> 'a map
    -            val singleton : key -> 'a -> 'a map
    -            val remove : key -> 'a map -> 'a map
    -            val merge :
    -              (key -> 'a option -> 'b option -> 'c option) ->
    -              'a map -> 'b map -> 'c map
    -            val compare : ('a -> 'a -> int) -> 'a map -> 'a map -> int
    -            val equal : ('a -> 'a -> bool) -> 'a map -> 'a map -> bool
    -            val iter : (key -> 'a -> unit) -> 'a map -> unit
    -            val fold : (key -> 'a -> 'b -> 'b) -> 'a map -> 'b -> 'b
    -            val for_all : (key -> 'a -> bool) -> 'a map -> bool
    -            val exists : (key -> 'a -> bool) -> 'a map -> bool
    -            val filter : (key -> 'a -> bool) -> 'a map -> 'a map
    -            val partition : (key -> 'a -> bool) -> 'a map -> 'a map * 'a map
    -            val cardinal : 'a map -> int
    -            val bindings : 'a map -> (key * 'a) list
    -            val min_binding : 'a map -> key * 'a
    -            val max_binding : 'a map -> key * 'a
    -            val choose : 'a map -> key * 'a
    -            val split : key -> 'a map -> 'a map * 'a option * 'a map
    -            val find : key -> 'a map -> 'a
    -            val map : ('a -> 'b) -> 'a map -> 'b map
    -            val mapi : (key -> 'a -> 'b) -> 'a map -> 'b map
    -            val to_seq : 'a map -> (key * 'a) t
    -            val of_seq : (key * 'a) t -> 'a map
    -            val keys : 'a map -> key t
    -            val values : 'a map -> '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
    -  module TypeClass :
    -    sig
    -      type ('a, 'b) sequenceable = {
    -        to_seq : 'b -> 'a Sequence.t;
    -        of_seq : 'a Sequence.t -> 'b;
    -      }
    -      type ('a, 'b) addable = { empty : 'b; add : 'b -> 'a -> 'b; }
    -      type 'a monoid = ('a, 'a) Sequence.TypeClass.addable
    -      type ('a, 'b) iterable = { iter : ('a -> unit) -> 'b -> unit; }
    -      val sequenceable : ('a, 'a Sequence.t) Sequence.TypeClass.sequenceable
    -      val iterable : ('a, 'a Sequence.t) Sequence.TypeClass.iterable
    -      val monoid : 'a Sequence.t Sequence.TypeClass.monoid
    -      val of_iterable :
    -        ('a, 'b) Sequence.TypeClass.iterable -> 'b -> 'a Sequence.t
    -      val to_addable :
    -        ('a, 'b) Sequence.TypeClass.addable -> 'a Sequence.t -> 'b
    -    end
    -  module Infix :
    -    sig
    -      val ( -- ) : int -> int -> int Sequence.t
    -      val ( |> ) : 'a -> ('a -> 'b) -> 'b
    -      val ( @@ ) : 'a Sequence.t -> 'a Sequence.t -> 'a Sequence.t
    -    end
    -  val pp_seq :
    -    ?sep:string ->
    -    (Format.formatter -> 'a -> unit) ->
    -    Format.formatter -> 'a Sequence.t -> unit
    +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 end \ No newline at end of file