diff --git a/api/Sequence.IO.html b/api/Sequence.IO.html deleted file mode 100644 index 6620ef7..0000000 --- a/api/Sequence.IO.html +++ /dev/null @@ -1,62 +0,0 @@ - - - - - - - - - - - - - - - -Sequence.IO - - -
Previous - Up - 
-

Module Sequence.IO

- -
module IO: sig .. end
- -
val lines_of : ?mode:int -> ?flags:Pervasives.open_flag list -> string -> string Sequence.t
-lines_of filename reads all lines of the given file. It raises the - same exception as would opening the file and read from it, except - from End_of_file (which is caught). The file is always properly - closed. - Every time the sequence is iterated on, the file is opened again, so - different iterations might return different results
-
-
mode : default 0o644
-
flags : default: [Open_rdonly]
- -
val chunks_of : ?mode:int ->
       ?flags:Pervasives.open_flag list -> ?size:int -> string -> string Sequence.t
-Read chunks of the given size from the file. The last chunk might be - smaller. Behaves like Sequence.IO.lines_of regarding errors and options. - Every time the sequence is iterated on, the file is opened again, so - different iterations might return different results
-
- -
val write_to : ?mode:int ->
       ?flags:Pervasives.open_flag list -> string -> string Sequence.t -> unit
-write_to filename seq writes all strings from seq into the given - file. It takes care of opening and closing the file.
-
-
mode : default 0o644
-
flags : used by open_out_gen. Default: [Open_creat;Open_wronly].
- -
val write_bytes_to : ?mode:int ->
       ?flags:Pervasives.open_flag list -> string -> Bytes.t Sequence.t -> unit
-Since 0.5.4
-
- -
val write_lines : ?mode:int ->
       ?flags:Pervasives.open_flag list -> string -> string Sequence.t -> unit
-Same as Sequence.IO.write_to, but intercales '\n' between each string
-
- -
val write_bytes_lines : ?mode:int ->
       ?flags:Pervasives.open_flag list -> string -> Bytes.t Sequence.t -> unit
-Since 0.5.4
-
- \ No newline at end of file diff --git a/api/Sequence.Infix.html b/api/Sequence.Infix.html deleted file mode 100644 index dd3fc2f..0000000 --- a/api/Sequence.Infix.html +++ /dev/null @@ -1,58 +0,0 @@ - - - - - - - - - - - - - - - - -Sequence.Infix - - -
Previous - Up - Next -
-

Module Sequence.Infix

- -
module Infix: sig .. end
- -
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 deleted file mode 100644 index 10e0c2a..0000000 --- a/api/Sequence.Map.Adapt.html +++ /dev/null @@ -1,50 +0,0 @@ - - - - - - - - - - - - - - - -Sequence.Map.Adapt - - -
 Up - Next -
-

Functor Sequence.Map.Adapt

- -
module Adapt: 
functor (M : Map.S) -> S  with type key = M.key and type 'a t = 'a M.t
-Adapt a pre-existing Map module to make it sequence-aware
-
- - - - - -
Parameters: - - - - -
-M:Map.S -
-
-
- -
include Map.S
- -
val to_seq : 'a 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 deleted file mode 100644 index 8ad3db4..0000000 --- a/api/Sequence.Map.Make.html +++ /dev/null @@ -1,50 +0,0 @@ - - - - - - - - - - - - - - - -Sequence.Map.Make - - -
Previous - Up - 
-

Functor Sequence.Map.Make

- -
module Make: 
functor (V : Map.OrderedType) -> S  with type key = V.t
-Create an enriched Map module, with sequence-aware functions
-
- - - - - -
Parameters: - - - - -
-V:Map.OrderedType -
-
-
- -
include Map.S
- -
val to_seq : 'a 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 deleted file mode 100644 index 48c16d7..0000000 --- a/api/Sequence.Map.S.html +++ /dev/null @@ -1,31 +0,0 @@ - - - - - - - - - - - - - - -Sequence.Map.S - - -
 Up - 
-

Module type Sequence.Map.S

- -
module type S = sig .. end
- -
include Map.S
- -
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 deleted file mode 100644 index 39061d8..0000000 --- a/api/Sequence.Map.html +++ /dev/null @@ -1,36 +0,0 @@ - - - - - - - - - - - - - - - - -Sequence.Map - - -
Previous - Up - 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 t = 'a M.t
-Adapt a pre-existing Map module to make it sequence-aware -
- -
module Make: 
functor (V : Map.OrderedType) -> S  with type key = V.t
-Create an enriched Map module, with sequence-aware functions -
- \ No newline at end of file diff --git a/api/Sequence.Set.Adapt.html b/api/Sequence.Set.Adapt.html deleted file mode 100644 index d66b2c4..0000000 --- a/api/Sequence.Set.Adapt.html +++ /dev/null @@ -1,48 +0,0 @@ - - - - - - - - - - - - - - - -Sequence.Set.Adapt - - -
 Up - Next -
-

Functor Sequence.Set.Adapt

- -
module Adapt: 
functor (X : Set.S) -> S  with type elt = X.elt and type t = X.t
-Create an enriched Set module from the given one
-
- - - - - -
Parameters: - - - - -
-X:Set.S -
-
-
- -
include Set.S
- -
val of_seq : elt 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 deleted file mode 100644 index 9ccb425..0000000 --- a/api/Sequence.Set.Make.html +++ /dev/null @@ -1,48 +0,0 @@ - - - - - - - - - - - - - - - -Sequence.Set.Make - - -
Previous - Up - 
-

Functor Sequence.Set.Make

- -
module Make: 
functor (X : Set.OrderedType) -> S  with type elt = X.t
-Functor to build an extended Set module from an ordered type
-
- - - - - -
Parameters: - - - - -
-X:Set.OrderedType -
-
-
- -
include Set.S
- -
val of_seq : elt 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 deleted file mode 100644 index 3bed0f4..0000000 --- a/api/Sequence.Set.S.html +++ /dev/null @@ -1,29 +0,0 @@ - - - - - - - - - - - - - - -Sequence.Set.S - - -
 Up - 
-

Module type Sequence.Set.S

- -
module type S = sig .. end
- -
include Set.S
- -
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 deleted file mode 100644 index 9cf1484..0000000 --- a/api/Sequence.Set.html +++ /dev/null @@ -1,34 +0,0 @@ - - - - - - - - - - - - - - - -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 t = X.t
-Create an enriched Set module from the given one -
- -
module Make: 
functor (X : Set.OrderedType) -> S  with type elt = X.t
-Functor to build an extended Set module from an ordered type -
- \ No newline at end of file diff --git a/api/Sequence.TypeClass.html b/api/Sequence.TypeClass.html deleted file mode 100644 index d2512ae..0000000 --- a/api/Sequence.TypeClass.html +++ /dev/null @@ -1,81 +0,0 @@ - - - - - - - - - - - - - - - -Sequence.TypeClass - - -
Previous - Up - Next -
-

Module Sequence.TypeClass

-
module TypeClass: sig .. end
-
type ('a, 'b) sequenceable = {
- - - - - - - - - -
-   -to_seq :'b -> 'a Sequence.t;
-   -of_seq :'a Sequence.t -> 'b;
-} - -
-

Classes


-
- -
type ('a, 'b) addable = {
- - - - - - - - - -
-   -empty :'b;
-   -add :'b -> 'a -> 'b;
-} - - -
type 'a monoid = ('a, 'a) addable
- -
type ('a, 'b) iterable = {
- - - - -
-   -iter :('a -> unit) -> 'b -> unit;
-} - - -
-

Instances


-
val sequenceable : ('a, 'a Sequence.t) sequenceable
val iterable : ('a, 'a Sequence.t) iterable
val monoid : 'a Sequence.t monoid

-

Conversions


-
val of_iterable : ('a, 'b) iterable -> 'b -> 'a Sequence.t
val to_addable : ('a, 'b) addable -> 'a Sequence.t -> 'b
\ No newline at end of file diff --git a/api/Sequence.html b/api/Sequence.html deleted file mode 100644 index e5e566f..0000000 --- a/api/Sequence.html +++ /dev/null @@ -1,865 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -Sequence - - -
 Up - Next -
-

Module Sequence

- -
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 - 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 (See further). -

- - 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. -

- - 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
-
-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.
-
- - -
type 'a equal = 'a -> 'a -> bool
- - -
type 'a hash = 'a -> int
- -
-

Build a sequence


- -
val from_iter : (('a -> unit) -> unit) -> 'a t
-Build a sequence from a iter function
-
- -
val from_fun : (unit -> 'a option) -> 'a t
-Call the function repeatedly until it returns None. This - sequence is transient, use Sequence.persistent if needed!
-
- -
val empty : 'a t
-Empty sequence. It contains no element.
-
- -
val singleton : 'a -> 'a t
-Singleton sequence, with exactly one element.
-
- -
val doubleton : 'a -> 'a -> 'a t
-Sequence with exactly two elements
-
- -
val init : (int -> 'a) -> 'a t
-init f is the infinite sequence f 0; f 1; f 2; ….
-Since 0.9
-
- -
val cons : 'a -> 'a t -> 'a t
-cons x l yields x, then yields from l. - Same as append (singleton x) l
-
- -
val snoc : 'a t -> 'a -> 'a t
-Same as Sequence.cons but yields the element after iterating on l
-
- -
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. - Basically iter f seq is just seq f.
-
- -
val iteri : (int -> 'a -> unit) -> 'a t -> unit
-Iterate on elements and their index in the sequence
-
- -
val fold : ('a -> 'b -> 'a) -> 'a -> 'b t -> 'a
-Fold over elements of the sequence, consuming it
-
- -
val foldi : ('a -> int -> 'b -> 'a) -> 'a -> 'b t -> 'a
-Fold over elements of the sequence and their index, consuming it
-
- -
val fold_map : ('acc -> 'a -> 'acc * 'b) -> 'acc -> 'a t -> 'b t
-fold_map f acc l is like Sequence.map, but it carries some state as in - Sequence.fold. The state is not returned, it is just used to thread some - information to the map function.
-Since 0.9
-
- -
val fold_filter_map : ('acc -> 'a -> 'acc * 'b option) -> 'acc -> 'a t -> 'b t
-fold_filter_map f acc l is a Sequence.fold_map-like function, but the - function can choose to skip an element by retuning None.
-Since 0.9
-
- -
val map : ('a -> 'b) -> 'a t -> 'b t
-Map objects of the sequence into other elements, lazily
-
- -
val mapi : (int -> 'a -> 'b) -> 'a t -> 'b t
-Map objects, along with their index in the sequence
-
- -
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
-Exists there some element satisfying the predicate?
-
- -
val mem : ?eq:('a -> 'a -> bool) -> 'a -> 'a t -> bool
-Is the value a member of the sequence?
-Since 0.5
-
-
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 find_map : ('a -> 'b option) -> 'a t -> 'b option
-Alias to Sequence.find
-Since 0.10
-
- -
val findi : (int -> 'a -> 'b option) -> 'a t -> 'b option
-Indexed version of Sequence.find
-Since 0.9
-
- -
val find_mapi : (int -> 'a -> 'b option) -> 'a t -> 'b option
-Alias to Sequence.findi
-Since 0.10
-
- -
val find_pred : ('a -> bool) -> 'a t -> 'a option
-find_pred p l finds the first element of l that satisfies p, - or returns None if no element satisfies p
-Since 0.9
-
- -
val find_pred_exn : ('a -> bool) -> 'a t -> 'a
-Unsafe version of Sequence.find_pred
-Since 0.9
-Raises Not_found if no such element is found
-
- -
val length : 'a t -> int
-How long is the sequence? Forces the sequence.
-
- -
val is_empty : 'a t -> bool
-Is the sequence empty? Forces the sequence.
-
-
-

Transform a sequence


- -
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. Iterating on the result is like iterating - on the first, then on the second.
-
- -
val append_l : 'a t list -> 'a t
-Append sequences. Iterating on the result is like iterating - on the each sequence of the list in order.
-Since 0.11
-
- -
val concat : 'a t t -> 'a t
-Concatenate a sequence of sequences into one sequence.
-
- -
val flatten : 'a t t -> 'a t
-Alias for Sequence.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 flat_map_l : ('a -> 'b list) -> 'a t -> 'b t
-Convenience function combining Sequence.flat_map and Sequence.of_list
-Since 0.9
-
- -
val seq_list : 'a t list -> 'a list t
-seq_list l returns all the ways to pick one element in each sub-sequence - in l. Assumes the sub-sequences can be iterated on several times.
-Since 0.11
-
- -
val seq_list_map : ('a -> 'b t) -> 'a list -> 'b list t
-seq_list_map f l maps f over every element of l, - then calls Sequence.seq_list
-Since 0.11
-
- -
val filter_map : ('a -> 'b option) -> 'a t -> 'b t
-Map and only keep non-None elements - Formerly fmap
-Since 0.5
-
- -
val filter_mapi : (int -> 'a -> 'b option) -> 'a t -> 'b t
-Map with indices, and only keep non-None elements
-Since 0.11
-
- -
val intersperse : 'a -> 'a t -> 'a t
-Insert the single element between every element of the sequence
-
-
-

Caching


- -
val persistent : 'a t -> 'a t
-Iterate on the sequence, storing elements in an efficient internal structure.. - The resulting sequence can be iterated on as many times as needed. - Note: calling persistent on an already persistent sequence - will still make a new copy of the sequence!
-
- -
val persistent_lazy : 'a t -> 'a t
-Lazy version of 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 sorted : ?cmp:('a -> 'a -> int) -> 'a t -> bool
-Checks whether the sequence is sorted. Eager, same as Sequence.sort.
-Since 0.9
-
- -
val group_succ_by : ?eq:('a -> 'a -> bool) -> 'a t -> 'a list t
-Group equal consecutive elements. Linear time. - Formerly synonym to group.
-Since 0.6
-
- -
val group_by : ?hash:('a -> int) ->
       ?eq:('a -> 'a -> bool) -> 'a t -> 'a list t
-Group equal elements, disregarding their order of appearance. - The result sequence is traversable as many times as required. - precondition: for any x and y, if eq x y then hash x=hash y must hold.
-Since 0.6
-
- -
val count : ?hash:('a -> int) ->
       ?eq:('a -> 'a -> bool) -> 'a t -> ('a * int) t
-Map each distinct element to its number of occurrences in the whole seq. - Similar to group_by seq |> map (fun l->List.hd l, List.length l) - precondition: for any x and y, if eq x y then hash x=hash y must hold.
-Since 0.10
-
- -
val uniq : ?eq:('a -> 'a -> bool) -> 'a t -> 'a t
-Remove consecutive duplicate elements. Basically this is - like fun seq -> map List.hd (group seq).
-
- -
val product : 'a t -> 'b t -> ('a * 'b) t
-Cartesian product of the sequences. When calling product a b, - the caller MUST ensure that b can be traversed as many times - as required (several times), possibly by calling Sequence.persistent on it - beforehand.
-
- -
val diagonal_l : 'a list -> ('a * 'a) t
-All pairs of distinct positions of the list. diagonal l will - return the sequence of all List.nth i l, List.nth j l if i < j.
-Since 0.9
-
- -
val diagonal : 'a t -> ('a * 'a) t
-All pairs of distinct positions of the sequence. - Iterates only once on the sequence, which must be finite.
-Since 0.9
-
- -
val product2 : 'a t -> 'b t -> ('a, 'b) t2
-Binary version of 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.
-
- -
val join_by : ?eq:'key equal ->
       ?hash:'key hash ->
       ('a -> 'key) ->
       ('b -> 'key) ->
       merge:('key -> 'a -> 'b -> 'c option) ->
       'a t -> 'b t -> 'c t
-join key1 key2 ~merge is a binary operation - that takes two sequences a and b, projects their - elements resp. with key1 and key2, and combine - values (x,y) from (a,b) with the same key - using merge. If merge returns None, the combination - of values is discarded. - precondition: for any x and y, if eq x y then hash x=hash y must hold.
-Since 0.10
-
- -
val join_all_by : ?eq:'key equal ->
       ?hash:'key hash ->
       ('a -> 'key) ->
       ('b -> 'key) ->
       merge:('key -> 'a list -> 'b list -> 'c option) ->
       'a t -> 'b t -> 'c t
-join_all_by key1 key2 ~merge is a binary operation - that takes two sequences a and b, projects their - elements resp. with key1 and key2, and, for each key k - occurring in at least one of them: -
-Since 0.10
-
- -
val group_join_by : ?eq:'a equal ->
       ?hash:'a hash ->
       ('b -> 'a) -> 'a t -> 'b t -> ('a * 'b list) t
-group_join_by key2 associates to every element x of - the first sequence, all the elements y of the second - sequence such that eq x (key y). Elements of the first - sequences without corresponding values in the second one - are mapped to [] - precondition: for any x and y, if eq x y then hash x=hash y must hold.
-Since 0.10
-
- -
val inter : ?eq:'a equal ->
       ?hash:'a hash -> 'a t -> 'a t -> 'a t
-Intersection of two collections. Each element will occur at most once - in the result. Eager. - precondition: for any x and y, if eq x y then hash x=hash y must hold.
-Since 0.10
-
- -
val union : ?eq:'a equal ->
       ?hash:'a hash -> 'a t -> 'a t -> 'a t
-Union of two collections. Each element will occur at most once - in the result. Eager. - precondition: for any x and y, if eq x y then hash x=hash y must hold.
-Since 0.10
-
- -
val diff : ?eq:'a equal ->
       ?hash:'a hash -> 'a t -> 'a t -> 'a t
-Set difference. Eager.
-Since 0.10
-
- -
val subset : ?eq:'a equal ->
       ?hash:'a hash -> 'a t -> 'a t -> bool
-subset a b returns true if all elements of a belong to b. Eager. - precondition: for any x and y, if eq x y then hash x=hash y must hold.
-Since 0.10
-
- -
val unfoldr : ('b -> ('a * 'b) option) -> 'b -> 'a t
-unfoldr f b will apply f to b. If it - yields Some (x,b') then x is returned - and unfoldr recurses with b'.
-
- -
val scan : ('b -> 'a -> 'b) -> 'b -> 'a t -> 'b t
-Sequence of intermediate results
-
- -
val max : ?lt:('a -> 'a -> bool) -> 'a t -> 'a option
-Max element of the sequence, using the given comparison function.
-Returns None if the sequence is empty, Some m where m is the maximal - element otherwise
-
- -
val max_exn : ?lt:('a -> 'a -> bool) -> 'a t -> 'a
-Unsafe version of Sequence.max
-Since 0.10
-Raises Not_found if the sequence is empty
-
- -
val min : ?lt:('a -> 'a -> bool) -> 'a t -> 'a option
-Min element of the sequence, using the given comparison function. - see Sequence.max for more details.
-
- -
val min_exn : ?lt:('a -> 'a -> bool) -> 'a t -> 'a
-Unsafe version of Sequence.min
-Since 0.10
-Raises Not_found if the sequence is empty
-
- -
val sum : int t -> int
-Sum of elements
-Since 0.11
-
- -
val sumf : float t -> float
-Sum of elements, using Kahan summation
-Since 0.11
-
- -
val head : 'a t -> 'a option
-First element, if any, otherwise None
-Since 0.5.1
-
- -
val head_exn : 'a t -> 'a
-First element, if any, fails
-Since 0.5.1
-Raises Invalid_argument if the sequence is empty
-
- -
val take : int -> 'a t -> 'a t
-Take at most n elements from the sequence. Works on infinite - sequences.
-
- -
val take_while : ('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
-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
-map2_2 f g seq2 maps each x, y of seq2 into f x y, g x y
-
-
-

Basic data structures converters


- -
val to_list : 'a t -> 'a list
-Convert the sequence into a list. Preserves order of elements. - This function is tail-recursive, but consumes 2*n memory. - If order doesn't matter to you, consider Sequence.to_rev_list.
-
- -
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 pair_with_idx : 'a t -> (int * 'a) t
-Similar to Sequence.zip_i but returns a normal sequence of tuples
-Since 0.11
-
- -
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 - an intermediate list is used.
-
- -
val of_array : 'a array -> 'a t
-
val of_array_i : 'a array -> (int * 'a) t
-Elements of the array, with their index
-
- -
val of_array2 : 'a array -> (int, 'a) t2
-
val array_slice : 'a array -> int -> int -> 'a t
-array_slice a i j Sequence of elements whose indexes range - from i to j
-
- -
val of_opt : 'a option -> 'a t
-Iterate on 0 or 1 values.
-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
-Convert to a stream. linear in memory and time (a copy is made in memory)
-
- -
val to_stack : 'a Stack.t -> 'a t -> unit
-Push elements of the sequence on the stack
-
- -
val of_stack : 'a Stack.t -> 'a t
-Sequence of elements of the stack (same order as Stack.iter)
-
- -
val to_queue : 'a Queue.t -> 'a t -> unit
-Push elements of the sequence into the queue
-
- -
val of_queue : 'a Queue.t -> 'a t
-Sequence of elements contained in the queue, FIFO order
-
- -
val hashtbl_add : ('a, 'b) Hashtbl.t -> ('a * 'b) t -> unit
-Add elements of the sequence to the hashtable, with - Hashtbl.add
-
- -
val hashtbl_replace : ('a, 'b) Hashtbl.t -> ('a * 'b) t -> unit
-Add elements of the sequence to the hashtable, with - Hashtbl.replace (erases conflicting bindings)
-
- -
val to_hashtbl : ('a * 'b) t -> ('a, 'b) Hashtbl.t
-Build a hashtable from a sequence of key/value pairs
-
- -
val to_hashtbl2 : ('a, 'b) t2 -> ('a, 'b) Hashtbl.t
-Build a hashtable from a sequence of key/value pairs
-
- -
val of_hashtbl : ('a, 'b) Hashtbl.t -> ('a * 'b) t
-Sequence of key/value pairs from the hashtable
-
- -
val of_hashtbl2 : ('a, 'b) Hashtbl.t -> ('a, 'b) t2
-Sequence of key/value pairs from the hashtable
-
- -
val hashtbl_keys : ('a, 'b) Hashtbl.t -> 'a t
-
val hashtbl_values : ('a, 'b) Hashtbl.t -> 'b t
-
val of_str : string -> char t
-
val to_str : char t -> string
-
val concat_str : string t -> string
-Concatenate strings together, eagerly. - Also see 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. Also see - (--) for an infix version.
-
- -
val int_range_dec : start:int -> stop:int -> int t
-Iterator on decreasing integers in stop...start by steps -1. - See (--^) for an infix version
-
- -
val int_range_by : step:int -> 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
-Convert the sequence to a set, given the proper set module
-
- -
type 'a gen = unit -> 'a option
- - -
type 'a klist = unit -> [ `Cons of 'a * 'a klist | `Nil ]
- - -
val of_gen : 'a gen -> 'a t
-Traverse eagerly the generator and build a sequence from it
-
- -
val to_gen : 'a t -> 'a gen
-Make the sequence persistent (O(n)) and then iterate on it. Eager.
-
- -
val of_klist : 'a klist -> 'a t
-Iterate on the lazy list
-
- -
val to_klist : 'a t -> 'a klist
-Make the sequence persistent and then iterate on it. Eager.
-
-
-

Functorial conversions between sets and sequences


- -
module Set: sig .. end

-

Conversion between maps and sequences.


- -
module Map: sig .. end

-

Infinite sequences of random values


- -
val random_int : int -> int t
-Infinite sequence of random integers between 0 and - the given higher bound (see Random.int)
-
- -
val random_bool : bool t
-Infinite sequence of random bool values
-
- -
val random_float : float -> float t
-
val random_array : 'a array -> 'a t
-Sequence of choices of an element in the array
-
- -
val random_list : 'a list -> 'a t
-Infinite sequence of random elements of the list. Basically the - same as Sequence.random_array.
-
- -
val shuffle : 'a t -> 'a t
-shuffle seq returns a perfect shuffle of seq. - Uses O(length seq) memory and time. Eager.
-Since 0.7
-
- -
val shuffle_buffer : 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/SequenceLabels.IO.html b/api/SequenceLabels.IO.html deleted file mode 100644 index 2ba30bf..0000000 --- a/api/SequenceLabels.IO.html +++ /dev/null @@ -1,62 +0,0 @@ - - - - - - - - - - - - - - - -SequenceLabels.IO - - -
Previous - Up - 
-

Module SequenceLabels.IO

- -
module IO: sig .. end
- -
val lines_of : ?mode:int ->
       ?flags:Pervasives.open_flag list -> string -> string SequenceLabels.t
-lines_of filename reads all lines of the given file. It raises the - same exception as would opening the file and read from it, except - from End_of_file (which is caught). The file is always properly - closed. - Every time the sequence is iterated on, the file is opened again, so - different iterations might return different results
-
-
mode : default 0o644
-
flags : default: [Open_rdonly]
- -
val chunks_of : ?mode:int ->
       ?flags:Pervasives.open_flag list ->
       ?size:int -> string -> string SequenceLabels.t
-Read chunks of the given size from the file. The last chunk might be - smaller. Behaves like SequenceLabels.IO.lines_of regarding errors and options. - Every time the sequence is iterated on, the file is opened again, so - different iterations might return different results
-
- -
val write_to : ?mode:int ->
       ?flags:Pervasives.open_flag list -> string -> string SequenceLabels.t -> unit
-write_to filename seq writes all strings from seq into the given - file. It takes care of opening and closing the file.
-
-
mode : default 0o644
-
flags : used by open_out_gen. Default: [Open_creat;Open_wronly].
- -
val write_bytes_to : ?mode:int ->
       ?flags:Pervasives.open_flag list ->
       string -> Bytes.t SequenceLabels.t -> unit
-Since 0.5.4
-
- -
val write_lines : ?mode:int ->
       ?flags:Pervasives.open_flag list -> string -> string SequenceLabels.t -> unit
-Same as SequenceLabels.IO.write_to, but intercales '\n' between each string
-
- -
val write_bytes_lines : ?mode:int ->
       ?flags:Pervasives.open_flag list ->
       string -> Bytes.t SequenceLabels.t -> unit
-Since 0.5.4
-
- \ No newline at end of file diff --git a/api/SequenceLabels.Infix.html b/api/SequenceLabels.Infix.html deleted file mode 100644 index f483099..0000000 --- a/api/SequenceLabels.Infix.html +++ /dev/null @@ -1,58 +0,0 @@ - - - - - - - - - - - - - - - - -SequenceLabels.Infix - - -
Previous - Up - Next -
-

Module SequenceLabels.Infix

- -
module Infix: sig .. end
- -
val (--) : int -> int -> int SequenceLabels.t
-a -- b is the range of integers from a to b, both included, - in increasing order. It will therefore be empty if a > b.
-
- -
val (--^) : int -> int -> int SequenceLabels.t
-a --^ b is the range of integers from b to a, both included, - in decreasing order (starts from a). - It will therefore be empty if a < b.
-
- -
val (>>=) : 'a SequenceLabels.t -> ('a -> 'b SequenceLabels.t) -> 'b SequenceLabels.t
-Monadic bind (infix version of SequenceLabels.flat_map
-Since 0.5
-
- -
val (>|=) : 'a SequenceLabels.t -> ('a -> 'b) -> 'b SequenceLabels.t
-Infix version of SequenceLabels.map
-Since 0.5
-
- -
val (<*>) : ('a -> 'b) SequenceLabels.t -> 'a SequenceLabels.t -> 'b SequenceLabels.t
-Applicative operator (product+application)
-Since 0.5
-
- -
val (<+>) : 'a SequenceLabels.t -> 'a SequenceLabels.t -> 'a SequenceLabels.t
-Concatenation of sequences
-Since 0.5
-
- \ No newline at end of file diff --git a/api/SequenceLabels.Map.Adapt.html b/api/SequenceLabels.Map.Adapt.html deleted file mode 100644 index 69b7756..0000000 --- a/api/SequenceLabels.Map.Adapt.html +++ /dev/null @@ -1,50 +0,0 @@ - - - - - - - - - - - - - - - -SequenceLabels.Map.Adapt - - -
 Up - Next -
-

Functor SequenceLabels.Map.Adapt

- -
module Adapt: 
functor (M : Map.S) -> S  with type key = M.key and type 'a t = 'a M.t
-Adapt a pre-existing Map module to make it sequence-aware
-
- - - - - -
Parameters: - - - - -
-M:Map.S -
-
-
- -
include Map.S
- -
val to_seq : 'a SequenceLabels.t -> (key * 'a) SequenceLabels.sequence
-
val of_seq : (key * 'a) SequenceLabels.sequence -> 'a SequenceLabels.t
-
val keys : 'a SequenceLabels.t -> key SequenceLabels.sequence
-
val values : 'a SequenceLabels.t -> 'a SequenceLabels.sequence
-
val to_list : 'a SequenceLabels.t -> (key * 'a) list
-
val of_list : (key * 'a) list -> 'a SequenceLabels.t
\ No newline at end of file diff --git a/api/SequenceLabels.Map.Make.html b/api/SequenceLabels.Map.Make.html deleted file mode 100644 index 1e3a2d2..0000000 --- a/api/SequenceLabels.Map.Make.html +++ /dev/null @@ -1,50 +0,0 @@ - - - - - - - - - - - - - - - -SequenceLabels.Map.Make - - -
Previous - Up - 
-

Functor SequenceLabels.Map.Make

- -
module Make: 
functor (V : Map.OrderedType) -> S  with type key = V.t
-Create an enriched Map module, with sequence-aware functions
-
- - - - - -
Parameters: - - - - -
-V:Map.OrderedType -
-
-
- -
include Map.S
- -
val to_seq : 'a SequenceLabels.t -> (key * 'a) SequenceLabels.sequence
-
val of_seq : (key * 'a) SequenceLabels.sequence -> 'a SequenceLabels.t
-
val keys : 'a SequenceLabels.t -> key SequenceLabels.sequence
-
val values : 'a SequenceLabels.t -> 'a SequenceLabels.sequence
-
val to_list : 'a SequenceLabels.t -> (key * 'a) list
-
val of_list : (key * 'a) list -> 'a SequenceLabels.t
\ No newline at end of file diff --git a/api/SequenceLabels.Map.S.html b/api/SequenceLabels.Map.S.html deleted file mode 100644 index 6c4dcf4..0000000 --- a/api/SequenceLabels.Map.S.html +++ /dev/null @@ -1,31 +0,0 @@ - - - - - - - - - - - - - - -SequenceLabels.Map.S - - -
 Up - 
-

Module type SequenceLabels.Map.S

- -
module type S = sig .. end
- -
include Map.S
- -
val to_seq : 'a SequenceLabels.t -> (key * 'a) SequenceLabels.sequence
-
val of_seq : (key * 'a) SequenceLabels.sequence -> 'a SequenceLabels.t
-
val keys : 'a SequenceLabels.t -> key SequenceLabels.sequence
-
val values : 'a SequenceLabels.t -> 'a SequenceLabels.sequence
-
val to_list : 'a SequenceLabels.t -> (key * 'a) list
-
val of_list : (key * 'a) list -> 'a SequenceLabels.t
\ No newline at end of file diff --git a/api/SequenceLabels.Map.html b/api/SequenceLabels.Map.html deleted file mode 100644 index 9843ddf..0000000 --- a/api/SequenceLabels.Map.html +++ /dev/null @@ -1,36 +0,0 @@ - - - - - - - - - - - - - - - - -SequenceLabels.Map - - -
Previous - Up - Next -
-

Module SequenceLabels.Map

- -
module Map: sig .. end
- -
module type S = sig .. end
-
module Adapt: 
functor (M : Map.S) -> S  with type key = M.key and type 'a t = 'a M.t
-Adapt a pre-existing Map module to make it sequence-aware -
- -
module Make: 
functor (V : Map.OrderedType) -> S  with type key = V.t
-Create an enriched Map module, with sequence-aware functions -
- \ No newline at end of file diff --git a/api/SequenceLabels.Set.Adapt.html b/api/SequenceLabels.Set.Adapt.html deleted file mode 100644 index 8dee383..0000000 --- a/api/SequenceLabels.Set.Adapt.html +++ /dev/null @@ -1,48 +0,0 @@ - - - - - - - - - - - - - - - -SequenceLabels.Set.Adapt - - -
 Up - Next -
-

Functor SequenceLabels.Set.Adapt

- -
module Adapt: 
functor (X : Set.S) -> S  with type elt = X.elt and type t = X.t
-Create an enriched Set module from the given one
-
- - - - - -
Parameters: - - - - -
-X:Set.S -
-
-
- -
include Set.S
- -
val of_seq : elt SequenceLabels.sequence -> SequenceLabels.t
-
val to_seq : SequenceLabels.t -> elt SequenceLabels.sequence
-
val to_list : SequenceLabels.t -> elt list
-
val of_list : elt list -> SequenceLabels.t
\ No newline at end of file diff --git a/api/SequenceLabels.Set.Make.html b/api/SequenceLabels.Set.Make.html deleted file mode 100644 index e4122e5..0000000 --- a/api/SequenceLabels.Set.Make.html +++ /dev/null @@ -1,48 +0,0 @@ - - - - - - - - - - - - - - - -SequenceLabels.Set.Make - - -
Previous - Up - 
-

Functor SequenceLabels.Set.Make

- -
module Make: 
functor (X : Set.OrderedType) -> S  with type elt = X.t
-Functor to build an extended Set module from an ordered type
-
- - - - - -
Parameters: - - - - -
-X:Set.OrderedType -
-
-
- -
include Set.S
- -
val of_seq : elt SequenceLabels.sequence -> SequenceLabels.t
-
val to_seq : SequenceLabels.t -> elt SequenceLabels.sequence
-
val to_list : SequenceLabels.t -> elt list
-
val of_list : elt list -> SequenceLabels.t
\ No newline at end of file diff --git a/api/SequenceLabels.Set.S.html b/api/SequenceLabels.Set.S.html deleted file mode 100644 index dc20498..0000000 --- a/api/SequenceLabels.Set.S.html +++ /dev/null @@ -1,29 +0,0 @@ - - - - - - - - - - - - - - -SequenceLabels.Set.S - - -
 Up - 
-

Module type SequenceLabels.Set.S

- -
module type S = sig .. end
- -
include Set.S
- -
val of_seq : elt SequenceLabels.sequence -> SequenceLabels.t
-
val to_seq : SequenceLabels.t -> elt SequenceLabels.sequence
-
val to_list : SequenceLabels.t -> elt list
-
val of_list : elt list -> SequenceLabels.t
\ No newline at end of file diff --git a/api/SequenceLabels.Set.html b/api/SequenceLabels.Set.html deleted file mode 100644 index 71d0be3..0000000 --- a/api/SequenceLabels.Set.html +++ /dev/null @@ -1,34 +0,0 @@ - - - - - - - - - - - - - - - -SequenceLabels.Set - - -
 Up - Next -
-

Module SequenceLabels.Set

- -
module Set: sig .. end
- -
module type S = sig .. end
-
module Adapt: 
functor (X : Set.S) -> S  with type elt = X.elt and type t = X.t
-Create an enriched Set module from the given one -
- -
module Make: 
functor (X : Set.OrderedType) -> S  with type elt = X.t
-Functor to build an extended Set module from an ordered type -
- \ No newline at end of file diff --git a/api/SequenceLabels.html b/api/SequenceLabels.html deleted file mode 100644 index 0f56ce8..0000000 --- a/api/SequenceLabels.html +++ /dev/null @@ -1,834 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -SequenceLabels - - -
Previous - Up - 
-

Module SequenceLabels

- -
module SequenceLabels: sig .. end
-

Simple and Efficient Iterators

-

- - Version of Sequence with labels
-Since 0.5.5
-

-
- -
type 'a t = ('a -> unit) -> unit
-
-A sequence of values of type 'a. If you give it a function 'a -> unit - it will be applied to every element of the sequence successively.
-
- - -
type 'a sequence = 'a t
- - -
type ('a, 'b) t2 = ('a -> 'b -> unit) -> unit
-
-Sequence of pairs of values of type 'a and 'b.
-
- - -
type 'a equal = 'a -> 'a -> bool
- - -
type 'a hash = 'a -> int
- -
-

Build a sequence


- -
val from_iter : (('a -> unit) -> unit) -> 'a t
-Build a sequence from a iter function
-
- -
val from_fun : (unit -> 'a option) -> 'a t
-Call the function repeatedly until it returns None. This - sequence is transient, use SequenceLabels.persistent if needed!
-
- -
val empty : 'a t
-Empty sequence. It contains no element.
-
- -
val singleton : 'a -> 'a t
-Singleton sequence, with exactly one element.
-
- -
val doubleton : 'a -> 'a -> 'a t
-Sequence with exactly two elements
-
- -
val init : f:(int -> 'a) -> 'a t
-init f is the infinite sequence f 0; f 1; f 2; ….
-Since 0.9
-
- -
val cons : 'a -> 'a t -> 'a t
-cons x l yields x, then yields from l. - Same as append (singleton x) l
-
- -
val snoc : 'a t -> 'a -> 'a t
-Same as SequenceLabels.cons but yields the element after iterating on l
-
- -
val return : 'a -> 'a t
-Synonym to SequenceLabels.singleton
-
- -
val pure : 'a -> 'a t
-Synonym to SequenceLabels.singleton
-
- -
val repeat : 'a -> 'a t
-Infinite sequence of the same element. You may want to look - at SequenceLabels.take and the likes if you iterate on it.
-
- -
val iterate : ('a -> 'a) -> 'a -> 'a t
-iterate f x is the infinite sequence x, f(x), f(f(x)), ...
-
- -
val forever : (unit -> 'b) -> 'b t
-Sequence that calls the given function to produce elements. - The sequence may be transient (depending on the function), and definitely - is infinite. You may want to use SequenceLabels.take and SequenceLabels.persistent.
-
- -
val cycle : 'a t -> 'a t
-Cycle forever through the given sequence. Assume the given sequence can - be traversed any amount of times (not transient). This yields an - infinite sequence, you should use something like SequenceLabels.take not to loop - forever.
-
-
-

Consume a sequence


- -
val iter : f:('a -> unit) -> 'a t -> unit
-Consume the sequence, passing all its arguments to the function. - Basically iter f seq is just seq f.
-
- -
val iteri : f:(int -> 'a -> unit) -> 'a t -> unit
-Iterate on elements and their index in the sequence
-
- -
val fold : f:('a -> 'b -> 'a) -> init:'a -> 'b t -> 'a
-Fold over elements of the sequence, consuming it
-
- -
val foldi : f:('a -> int -> 'b -> 'a) -> init:'a -> 'b t -> 'a
-Fold over elements of the sequence and their index, consuming it
-
- -
val fold_map : f:('acc -> 'a -> 'acc * 'b) ->
       init:'acc -> 'a t -> 'b t
-fold_map f acc l is like SequenceLabels.map, but it carries some state as in - SequenceLabels.fold. The state is not returned, it is just used to thread some - information to the map function.
-Since 0.9
-
- -
val fold_filter_map : f:('acc -> 'a -> 'acc * 'b option) ->
       init:'acc -> 'a t -> 'b t
-fold_filter_map f acc l is a SequenceLabels.fold_map-like function, but the - function can choose to skip an element by retuning None.
-Since 0.9
-
- -
val map : f:('a -> 'b) -> 'a t -> 'b t
-Map objects of the sequence into other elements, lazily
-
- -
val mapi : f:(int -> 'a -> 'b) -> 'a t -> 'b t
-Map objects, along with their index in the sequence
-
- -
val map_by_2 : f:('a -> 'a -> 'a) -> 'a t -> 'a t
-Map objects two by two. lazily. - The last element is kept in the sequence if the count is odd.
-Since 0.7
-
- -
val for_all : f:('a -> bool) -> 'a t -> bool
-Do all elements satisfy the predicate?
-
- -
val exists : f:('a -> bool) -> 'a t -> bool
-Exists there some element satisfying the predicate?
-
- -
val mem : ?eq:('a -> 'a -> bool) -> x:'a -> 'a t -> bool
-Is the value a member of the sequence?
-Since 0.5
-
-
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 find_map : f:('a -> 'b option) -> 'a t -> 'b option
-Alias to SequenceLabels.find
-Since 0.10
-
- -
val findi : f:(int -> 'a -> 'b option) -> 'a t -> 'b option
-Indexed version of SequenceLabels.find
-Since 0.9
-
- -
val find_mapi : f:(int -> 'a -> 'b option) -> 'a t -> 'b option
-Alias to SequenceLabels.findi
-Since 0.10
-
- -
val find_pred : f:('a -> bool) -> 'a t -> 'a option
-find_pred p l finds the first element of l that satisfies p, - or returns None if no element satisfies p
-Since 0.9
-
- -
val find_pred_exn : f:('a -> bool) -> 'a t -> 'a
-Unsafe version of SequenceLabels.find_pred
-Since 0.9
-Raises Not_found if no such element is found
-
- -
val length : 'a t -> int
-How long is the sequence? Forces the sequence.
-
- -
val is_empty : 'a t -> bool
-Is the sequence empty? Forces the sequence.
-
-
-

Transform a sequence


- -
val filter : f:('a -> bool) -> 'a t -> 'a t
-Filter on elements of the sequence
-
- -
val append : 'a t -> 'a t -> 'a t
-Append two sequences. Iterating on the result is like iterating - on the first, then on the second.
-
- -
val append_l : 'a t list -> 'a t
-Append sequences. Iterating on the result is like iterating - on the each sequence of the list in order.
-Since 0.11
-
- -
val concat : 'a t t -> 'a t
-Concatenate a sequence of sequences into one sequence.
-
- -
val flatten : 'a t t -> 'a t
-Alias for SequenceLabels.concat
-
- -
val flat_map : f:('a -> 'b t) -> 'a t -> 'b t
-Alias to flatMap with a more explicit name
-
- -
val flat_map_l : f:('a -> 'b list) -> 'a t -> 'b t
-Convenience function combining SequenceLabels.flat_map and SequenceLabels.of_list
-Since 0.9
-
- -
val filter_map : f:('a -> 'b option) -> 'a t -> 'b t
-Alias to fmap with a more explicit name
-
- -
val filter_mapi : f:(int -> 'a -> 'b option) -> 'a t -> 'b t
-Map with indices, and only keep non-None elements
-Since 0.11
-
- -
val seq_list : 'a t list -> 'a list t
-seq_list l returns all the ways to pick one element in each sub-sequence - in l. Assumes the sub-sequences can be iterated on several times.
-Since 0.11
-
- -
val seq_list_map : f:('a -> 'b t) -> 'a list -> 'b list t
-seq_list_map f l maps f over every element of l, - then calls SequenceLabels.seq_list
-Since 0.11
-
- -
val intersperse : x:'a -> 'a t -> 'a t
-Insert the single element between every element of the sequence
-
-
-

Caching


- -
val persistent : 'a t -> 'a t
-Iterate on the sequence, storing elements in an efficient internal structure.. - The resulting sequence can be iterated on as many times as needed. - Note: calling persistent on an already persistent sequence - will still make a new copy of the sequence!
-
- -
val persistent_lazy : 'a t -> 'a t
-Lazy version of SequenceLabels.persistent. When calling persistent_lazy s, - a new sequence s' is immediately returned (without actually consuming - s) in constant time; the first time s' is iterated on, - it also consumes s and caches its content into a inner data - structure that will back s' for future iterations. -

- - warning: on the first traversal of s', if the traversal - is interrupted prematurely (SequenceLabels.take, etc.) then s' will not be - memorized, and the next call to s' will traverse s again.
-

-
-

Misc


- -
val sort : ?cmp:('a -> 'a -> int) -> 'a t -> 'a t
-Sort the sequence. Eager, O(n) ram and O(n ln(n)) time. - It iterates on elements of the argument sequence immediately, - before it sorts them.
-
- -
val sort_uniq : ?cmp:('a -> 'a -> int) -> 'a t -> 'a t
-Sort the sequence and remove duplicates. Eager, same as sort
-
- -
val sorted : ?cmp:('a -> 'a -> int) -> 'a t -> bool
-Checks whether the sequence is sorted. Eager, same as SequenceLabels.sort.
-Since 0.9
-
- -
val group_succ_by : ?eq:('a -> 'a -> bool) -> 'a t -> 'a list t
-Group equal consecutive elements. - Formerly synonym to group.
-Since 0.6
-
- -
val group_by : ?hash:('a -> int) ->
       ?eq:('a -> 'a -> bool) -> 'a t -> 'a list t
-Group equal elements, disregarding their order of appearance. - The result sequence is traversable as many times as required. - precondition: for any x and y, if eq x y then hash x=hash y must hold.
-Since 0.6
-
- -
val count : ?hash:('a -> int) ->
       ?eq:('a -> 'a -> bool) -> 'a t -> ('a * int) t
-Map each distinct element to its number of occurrences in the whole seq. - Similar to group_by seq |> map (fun l->List.hd l, List.length l)
-Since 0.10
-
- -
val uniq : ?eq:('a -> 'a -> bool) -> 'a t -> 'a t
-Remove consecutive duplicate elements. Basically this is - like fun seq -> map List.hd (group seq).
-
- -
val product : 'a t -> 'b t -> ('a * 'b) t
-Cartesian product of the sequences. When calling product a b, - the caller MUST ensure that b can be traversed as many times - as required (several times), possibly by calling SequenceLabels.persistent on it - beforehand.
-
- -
val diagonal_l : 'a list -> ('a * 'a) t
-All pairs of distinct positions of the list. diagonal l will - return the sequence of all List.nth i l, List.nth j l if i < j.
-Since 0.9
-
- -
val diagonal : 'a t -> ('a * 'a) t
-All pairs of distinct positions of the sequence. - Iterates only once on the sequence, which must be finite.
-Since 0.9
-
- -
val product2 : 'a t -> 'b t -> ('a, 'b) t2
-Binary version of SequenceLabels.product. Same requirements.
-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.
-
- -
val join_by : ?eq:'key equal ->
       ?hash:'key hash ->
       ('a -> 'key) ->
       ('b -> 'key) ->
       merge:('key -> 'a -> 'b -> 'c option) ->
       'a t -> 'b t -> 'c t
-join key1 key2 ~merge is a binary operation - that takes two sequences a and b, projects their - elements resp. with key1 and key2, and combine - values (x,y) from (a,b) with the same key - using merge. If merge returns None, the combination - of values is discarded. - precondition: for any x and y, if eq x y then hash x=hash y must hold.
-Since 0.10
-
- -
val join_all_by : ?eq:'key equal ->
       ?hash:'key hash ->
       ('a -> 'key) ->
       ('b -> 'key) ->
       merge:('key -> 'a list -> 'b list -> 'c option) ->
       'a t -> 'b t -> 'c t
-join_all_by key1 key2 ~merge is a binary operation - that takes two sequences a and b, projects their - elements resp. with key1 and key2, and, for each key k - occurring in at least one of them: -
-Since 0.10
-
- -
val group_join_by : ?eq:'a equal ->
       ?hash:'a hash ->
       ('b -> 'a) ->
       'a t -> 'b t -> ('a * 'b list) t
-group_join_by key2 associates to every element x of - the first sequence, all the elements y of the second - sequence such that eq x (key y). Elements of the first - sequences without corresponding values in the second one - are mapped to [] - precondition: for any x and y, if eq x y then hash x=hash y must hold.
-Since 0.10
-
- -
val inter : ?eq:'a equal ->
       ?hash:'a hash ->
       'a t -> 'a t -> 'a t
-Intersection of two collections. Each element will occur at most once - in the result. Eager. - precondition: for any x and y, if eq x y then hash x=hash y must hold.
-Since 0.10
-
- -
val union : ?eq:'a equal ->
       ?hash:'a hash ->
       'a t -> 'a t -> 'a t
-Union of two collections. Each element will occur at most once - in the result. Eager. - precondition: for any x and y, if eq x y then hash x=hash y must hold.
-Since 0.10
-
- -
val diff : ?eq:'a equal ->
       ?hash:'a hash ->
       'a t -> 'a t -> 'a t
-Set difference. Eager.
-Since 0.10
-
- -
val subset : ?eq:'a equal ->
       ?hash:'a hash ->
       'a t -> 'a t -> bool
-subset a b returns true if all elements of a belong to b. Eager. - precondition: for any x and y, if eq x y then hash x=hash y must hold.
-Since 0.10
-
- -
val unfoldr : ('b -> ('a * 'b) option) -> 'b -> 'a t
-unfoldr f b will apply f to b. If it - yields Some (x,b') then x is returned - and unfoldr recurses with b'.
-
- -
val scan : ('b -> 'a -> 'b) -> 'b -> 'a t -> 'b t
-Sequence of intermediate results
-
- -
val max : ?lt:('a -> 'a -> bool) -> 'a t -> 'a option
-Max element of the sequence, using the given comparison function.
-Returns None if the sequence is empty, Some m where m is the maximal - element otherwise
-
- -
val max_exn : ?lt:('a -> 'a -> bool) -> 'a t -> 'a
-Unsafe version of SequenceLabels.max
-Since 0.10
-Raises Not_found if the sequence is empty
-
- -
val min : ?lt:('a -> 'a -> bool) -> 'a t -> 'a option
-Min element of the sequence, using the given comparison function. - see SequenceLabels.max for more details.
-
- -
val min_exn : ?lt:('a -> 'a -> bool) -> 'a t -> 'a
-Unsafe version of SequenceLabels.min
-Since 0.10
-Raises Not_found if the sequence is empty
-
- -
val sum : int t -> int
-Sum of elements
-Since 0.11
-
- -
val sumf : float t -> float
-Sum of elements, using Kahan summation
-Since 0.11
-
- -
val head : 'a t -> 'a option
-First element, if any, otherwise None
-Since 0.5.1
-
- -
val head_exn : 'a t -> 'a
-First element, if any, fails
-Since 0.5.1
-Raises Invalid_argument if the sequence is empty
-
- -
val take : int -> 'a t -> 'a t
-Take at most n elements from the sequence. Works on infinite - sequences.
-
- -
val take_while : f:('a -> bool) -> 'a t -> 'a t
-Take elements while they satisfy the predicate, then stops iterating. - Will work on an infinite sequence s if the predicate is false for at - least one element of s.
-
- -
val fold_while : f:('a -> 'b -> 'a * [ `Continue | `Stop ]) ->
       init:'a -> 'b t -> 'a
-Folds over elements of the sequence, stopping early if the accumulator - returns ('a, `Stop)
-Since 0.5.5
-
- -
val drop : int -> 'a t -> 'a t
-Drop the n first elements of the sequence. Lazy.
-
- -
val drop_while : f:('a -> bool) -> 'a t -> 'a t
-Predicate version of SequenceLabels.drop
-
- -
val rev : 'a t -> 'a t
-Reverse the sequence. O(n) memory and time, needs the - sequence to be finite. The result is persistent and does - not depend on the input being repeatable.
-
-
-

Binary sequences


- -
val empty2 : ('a, 'b) t2
-
val is_empty2 : ('a, 'b) t2 -> bool
-
val length2 : ('a, 'b) t2 -> int
-
val zip : ('a, 'b) t2 -> ('a * 'b) t
-
val unzip : ('a * 'b) t -> ('a, 'b) t2
-
val zip_i : 'a t -> (int, 'a) t2
-Zip elements of the sequence with their index in the sequence
-
- -
val fold2 : f:('c -> 'a -> 'b -> 'c) -> init:'c -> ('a, 'b) t2 -> 'c
-
val iter2 : f:('a -> 'b -> unit) -> ('a, 'b) t2 -> unit
-
val map2 : f:('a -> 'b -> 'c) -> ('a, 'b) t2 -> 'c t
-
val map2_2 : ('a -> 'b -> 'c) ->
       ('a -> 'b -> 'd) -> ('a, 'b) t2 -> ('c, 'd) t2
-map2_2 f g seq2 maps each x, y of seq2 into f x y, g x y
-
-
-

Basic data structures converters


- -
val to_list : 'a t -> 'a list
-Convert the sequence into a list. Preserves order of elements. - This function is tail-recursive, but consumes 2*n memory. - If order doesn't matter to you, consider SequenceLabels.to_rev_list.
-
- -
val to_rev_list : 'a t -> 'a list
-Get the list of the reversed sequence (more efficient than SequenceLabels.to_list)
-
- -
val of_list : 'a list -> 'a t
-
val on_list : ('a t -> 'b t) -> 'a list -> 'b list
-on_list f l is equivalent to to_list @@ f @@ of_list l.
-Since 0.5.2
-
- -
val pair_with_idx : 'a t -> (int * 'a) t
-Similar to SequenceLabels.zip_i but returns a normal sequence of tuples
-Since 0.11
-
- -
val to_opt : 'a t -> 'a option
-Alias to SequenceLabels.head
-Since 0.5.1
-
- -
val to_array : 'a t -> 'a array
-Convert to an array. Currently not very efficient because - an intermediate list is used.
-
- -
val of_array : 'a array -> 'a t
-
val of_array_i : 'a array -> (int * 'a) t
-Elements of the array, with their index
-
- -
val of_array2 : 'a array -> (int, 'a) t2
-
val array_slice : 'a array -> int -> int -> 'a t
-array_slice a i j Sequence of elements whose indexes range - from i to j
-
- -
val of_opt : 'a option -> 'a t
-Iterate on 0 or 1 values.
-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
-Convert to a stream. linear in memory and time (a copy is made in memory)
-
- -
val to_stack : 'a Stack.t -> 'a t -> unit
-Push elements of the sequence on the stack
-
- -
val of_stack : 'a Stack.t -> 'a t
-Sequence of elements of the stack (same order as Stack.iter)
-
- -
val to_queue : 'a Queue.t -> 'a t -> unit
-Push elements of the sequence into the queue
-
- -
val of_queue : 'a Queue.t -> 'a t
-Sequence of elements contained in the queue, FIFO order
-
- -
val hashtbl_add : ('a, 'b) Hashtbl.t -> ('a * 'b) t -> unit
-Add elements of the sequence to the hashtable, with - Hashtbl.add
-
- -
val hashtbl_replace : ('a, 'b) Hashtbl.t -> ('a * 'b) t -> unit
-Add elements of the sequence to the hashtable, with - Hashtbl.replace (erases conflicting bindings)
-
- -
val to_hashtbl : ('a * 'b) t -> ('a, 'b) Hashtbl.t
-Build a hashtable from a sequence of key/value pairs
-
- -
val to_hashtbl2 : ('a, 'b) t2 -> ('a, 'b) Hashtbl.t
-Build a hashtable from a sequence of key/value pairs
-
- -
val of_hashtbl : ('a, 'b) Hashtbl.t -> ('a * 'b) t
-Sequence of key/value pairs from the hashtable
-
- -
val of_hashtbl2 : ('a, 'b) Hashtbl.t -> ('a, 'b) t2
-Sequence of key/value pairs from the hashtable
-
- -
val hashtbl_keys : ('a, 'b) Hashtbl.t -> 'a t
-
val hashtbl_values : ('a, 'b) Hashtbl.t -> 'b t
-
val of_str : string -> char t
-
val to_str : char t -> string
-
val concat_str : string t -> string
-Concatenate strings together, eagerly. - Also see SequenceLabels.intersperse to add a separator.
-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 SequenceLabels.persistent.
-Raises OneShotSequence when used more than once.
-
- -
val to_buffer : char t -> Buffer.t -> unit
-Copy content of the sequence into the buffer
-
- -
val int_range : start:int -> stop:int -> int t
-Iterator on integers in start...stop by steps 1. Also see - (--) for an infix version.
-
- -
val int_range_dec : start:int -> stop:int -> int t
-Iterator on decreasing integers in stop...start by steps -1. - See (--^) for an infix version
-
- -
val int_range_by : step:int -> start:int -> stop:int -> int t
-int_range_by ~step ~start:i ~stop:j is the range starting at i, including j, - where the difference between successive elements is step. - use a negative step for a decreasing sequence.
-Since 0.9
-Raises Invalid_argument if step=0
-
- -
val bools : bool t
-Iterates on true and false
-Since 0.9
-
- -
val of_set : (module Set.S with type elt = 'a and type t = 'b) ->
       'b -> 'a t
-Convert the given set to a sequence. The set module must be provided.
-
- -
val to_set : (module Set.S with type elt = 'a and type t = 'b) ->
       'a t -> 'b
-Convert the sequence to a set, given the proper set module
-
- -
type 'a gen = unit -> 'a option
- - -
type 'a klist = unit -> [ `Cons of 'a * 'a klist | `Nil ]
- - -
val of_gen : 'a gen -> 'a t
-Traverse eagerly the generator and build a sequence from it
-
- -
val to_gen : 'a t -> 'a gen
-Make the sequence persistent (O(n)) and then iterate on it. Eager.
-
- -
val of_klist : 'a klist -> 'a t
-Iterate on the lazy list
-
- -
val to_klist : 'a t -> 'a klist
-Make the sequence persistent and then iterate on it. Eager.
-
-
-

Functorial conversions between sets and sequences


- -
module Set: sig .. end

-

Conversion between maps and sequences.


- -
module Map: sig .. end

-

Infinite sequences of random values


- -
val random_int : int -> int t
-Infinite sequence of random integers between 0 and - the given higher bound (see Random.int)
-
- -
val random_bool : bool t
-Infinite sequence of random bool values
-
- -
val random_float : float -> float t
-
val random_array : 'a array -> 'a t
-Sequence of choices of an element in the array
-
- -
val random_list : 'a list -> 'a t
-Infinite sequence of random elements of the list. Basically the - same as SequenceLabels.random_array.
-
- -
val shuffle : 'a t -> 'a t
-shuffle seq returns a perfect shuffle of seq. - Uses O(length seq) memory and time. Eager.
-Since 0.7
-
- -
val shuffle_buffer : n:int -> 'a t -> 'a t
-shuffle_buffer n seq returns a sequence of element of seq in random - order. The shuffling is not uniform. Uses O(n) memory. -

- - The first n elements of the sequence are consumed immediately. The - rest is consumed lazily.
-Since 0.7
-

-
-

Sampling


- -
val sample : n:int -> 'a t -> 'a array
-sample n seq returns k samples of seq, with uniform probability. - It will consume the sequence and use O(n) memory. -

- - It returns an array of size min (length seq) n.
-Since 0.7
-

-
-

Infix functions


- -
module Infix: sig .. end
-
include SequenceLabels.Infix
-
-

Pretty printing of sequences


- -
val pp_seq : ?sep:string ->
       (Format.formatter -> 'a -> unit) ->
       Format.formatter -> 'a t -> unit
-Pretty print a sequence of 'a, using the given pretty printer - to print each elements. An optional separator string can be provided.
-
- -
val pp_buf : ?sep:string ->
       (Buffer.t -> 'a -> unit) -> Buffer.t -> 'a t -> unit
-Print into a buffer
-
- -
val to_string : ?sep:string -> ('a -> string) -> 'a t -> string
-Print into a string
-
-
-

Basic IO

-

- - Very basic interface to manipulate files as sequence of chunks/lines. The - sequences take care of opening and closing files properly; every time - one iterates over a sequence, the file is opened/closed again. -

- - Example: copy a file "a" into file "b", removing blank lines: -

- - 

      Sequence.(IO.lines_of "a" |> filter (fun l-> l<> "") |> IO.write_lines "b");;
-
-

- - By chunks of 4096 bytes: -

- - 

      Sequence.IO.(chunks_of ~size:4096 "a" |> write_to "b");;
-
-

- - Read the lines of a file into a list: -

- - 

      Sequence.IO.lines "a" |> Sequence.to_list
-

- -
module IO: sig .. end
\ No newline at end of file diff --git a/api/html.stamp b/api/html.stamp deleted file mode 100644 index 68ed6d1..0000000 --- a/api/html.stamp +++ /dev/null @@ -1 +0,0 @@ -70c0e7d0d0f1803f43e8d143c98b447b \ No newline at end of file diff --git a/api/index.html b/api/index.html deleted file mode 100644 index df5de79..0000000 --- a/api/index.html +++ /dev/null @@ -1,37 +0,0 @@ - - - - - - - - - - - - - - - - -

- -

- - - -
Sequence
-Simple and Efficient Iterators -
-
SequenceLabels
-Simple and Efficient Iterators -
-
- - \ No newline at end of file diff --git a/api/index_attributes.html b/api/index_attributes.html deleted file mode 100644 index fd87078..0000000 --- a/api/index_attributes.html +++ /dev/null @@ -1,22 +0,0 @@ - - - - - - - - - - - - -Index of class attributes - - -
 Up - 
-

Index of class attributes

- -
- - \ No newline at end of file diff --git a/api/index_class_types.html b/api/index_class_types.html deleted file mode 100644 index b770b72..0000000 --- a/api/index_class_types.html +++ /dev/null @@ -1,22 +0,0 @@ - - - - - - - - - - - - -Index of class types - - -
 Up - 
-

Index of class types

- -
- - \ No newline at end of file diff --git a/api/index_classes.html b/api/index_classes.html deleted file mode 100644 index 18291c9..0000000 --- a/api/index_classes.html +++ /dev/null @@ -1,22 +0,0 @@ - - - - - - - - - - - - -Index of classes - - -
 Up - 
-

Index of classes

- -
- - \ No newline at end of file diff --git a/api/index_exceptions.html b/api/index_exceptions.html deleted file mode 100644 index 3f869fd..0000000 --- a/api/index_exceptions.html +++ /dev/null @@ -1,35 +0,0 @@ - - - - - - - - - - - - -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_extensions.html b/api/index_extensions.html deleted file mode 100644 index dd40036..0000000 --- a/api/index_extensions.html +++ /dev/null @@ -1,22 +0,0 @@ - - - - - - - - - - - - -Index of extensions - - -
 Up - 
-

Index of extensions

- -
- - \ No newline at end of file diff --git a/api/index_methods.html b/api/index_methods.html deleted file mode 100644 index 2077d4a..0000000 --- a/api/index_methods.html +++ /dev/null @@ -1,22 +0,0 @@ - - - - - - - - - - - - -Index of class methods - - -
 Up - 
-

Index of class methods

- -
- - \ No newline at end of file diff --git a/api/index_module_types.html b/api/index_module_types.html deleted file mode 100644 index cbb64b0..0000000 --- a/api/index_module_types.html +++ /dev/null @@ -1,31 +0,0 @@ - - - - - - - - - - - - -Index of module types - - -
 Up - 
-

Index of module types

- - - - - - - - - - -

S
S [SequenceLabels.Map]
S [SequenceLabels.Set]
S [Sequence.Map]
S [Sequence.Set]
- - \ No newline at end of file diff --git a/api/index_modules.html b/api/index_modules.html deleted file mode 100644 index f919368..0000000 --- a/api/index_modules.html +++ /dev/null @@ -1,92 +0,0 @@ - - - - - - - - - - - - -Index of modules - - -
 Up - 
-

Index of modules

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

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 -
-
Adapt [Sequence.Set]
-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 -
-
Make [Sequence.Set]
-Functor to build an extended Set module from an ordered type -
-
Map [SequenceLabels]
Map [Sequence]

S
Sequence
-Simple and Efficient Iterators -
-
SequenceLabels
-Simple and Efficient Iterators -
-
Set [SequenceLabels]
Set [Sequence]
- - \ No newline at end of file diff --git a/api/index_types.html b/api/index_types.html deleted file mode 100644 index b9e1784..0000000 --- a/api/index_types.html +++ /dev/null @@ -1,68 +0,0 @@ - - - - - - - - - - - - -Index of types - - -
 Up - 
-

Index of types

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

E
equal [SequenceLabels]
equal [Sequence]

G
gen [SequenceLabels]
gen [Sequence]

H
hash [SequenceLabels]
hash [Sequence]

K
klist [SequenceLabels]
klist [Sequence]

S
sequence [SequenceLabels]
sequence [Sequence]

T
t [SequenceLabels]
-A sequence of values of type 'a. -
-
t [Sequence]
-A sequence of values of type 'a. -
-
t2 [SequenceLabels]
-Sequence of pairs of values of type 'a and 'b. -
-
t2 [Sequence]
-Sequence of pairs of values of type 'a and 'b. -
-
- - \ No newline at end of file diff --git a/api/index_values.html b/api/index_values.html deleted file mode 100644 index 3cdbc60..0000000 --- a/api/index_values.html +++ /dev/null @@ -1,1604 +0,0 @@ - - - - - - - - - - - - -Index of values - - -
 Up - 
-

Index of values

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

(--) [SequenceLabels.Infix]
-a -- b is the range of integers from a to b, both included, - in increasing order. -
-
(--) [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_l [SequenceLabels]
-Append sequences. -
-
append_l [Sequence]
-Append 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 -
-

B
bools [SequenceLabels]
-Iterates on true and false -
-
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. -
-
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. -
-
count [SequenceLabels]
-Map each distinct element to its number of occurrences in the whole seq. -
-
count [Sequence]
-Map each distinct element to its number of occurrences in the whole seq. -
-
cycle [SequenceLabels]
-Cycle forever through the given sequence. -
-
cycle [Sequence]
-Cycle forever through the given sequence. -
-

D
diagonal [SequenceLabels]
-All pairs of distinct positions of the sequence. -
-
diagonal [Sequence]
-All pairs of distinct positions of the sequence. -
-
diagonal_l [SequenceLabels]
-All pairs of distinct positions of the list. -
-
diagonal_l [Sequence]
-All pairs of distinct positions of the list. -
-
diff [SequenceLabels]
-Set difference. -
-
diff [Sequence]
-Set difference. -
-
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_while [SequenceLabels]
-Predicate version of SequenceLabels.drop -
-
drop_while [Sequence]
-Predicate version of Sequence.drop -
-

E
empty [SequenceLabels]
-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 -
-
filter_map [SequenceLabels]
-Alias to fmap with a more explicit name -
-
filter_map [Sequence]
-Map and only keep non-None elements - Formerly fmap -
-
filter_mapi [SequenceLabels]
-Map with indices, and only keep non-None elements -
-
filter_mapi [Sequence]
-Map with indices, and only keep non-None elements -
-
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 -
-
find_map [SequenceLabels]
-Alias to SequenceLabels.find -
-
find_map [Sequence]
-Alias to Sequence.find -
-
find_mapi [SequenceLabels]
-Alias to SequenceLabels.findi -
-
find_mapi [Sequence]
-Alias to Sequence.findi -
-
find_pred [SequenceLabels]
-find_pred p l finds the first element of l that satisfies p, - or returns None if no element satisfies p -
-
find_pred [Sequence]
-find_pred p l finds the first element of l that satisfies p, - or returns None if no element satisfies p -
-
find_pred_exn [SequenceLabels]
-Unsafe version of SequenceLabels.find_pred -
-
find_pred_exn [Sequence]
-Unsafe version of Sequence.find_pred -
-
findi [SequenceLabels]
-Indexed version of SequenceLabels.find -
-
findi [Sequence]
-Indexed version of Sequence.find -
-
flat_map [SequenceLabels]
-Alias to flatMap with a more explicit name -
-
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_filter_map [SequenceLabels]
-fold_filter_map f acc l is a SequenceLabels.fold_map-like function, but the - function can choose to skip an element by retuning None. -
-
fold_filter_map [Sequence]
-fold_filter_map f acc l is a Sequence.fold_map-like function, but the - function can choose to skip an element by retuning None. -
-
fold_map [SequenceLabels]
-fold_map f acc l is like SequenceLabels.map, but it carries some state as in - SequenceLabels.fold. -
-
fold_map [Sequence]
-fold_map f acc l is like Sequence.map, but it carries some state as in - Sequence.fold. -
-
fold_while [SequenceLabels]
-Folds over elements of the sequence, stopping early if the accumulator - 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. -
-
from_fun [SequenceLabels]
-Call the function repeatedly until it returns None. -
-
from_fun [Sequence]
-Call the function repeatedly until it returns None. -
-
from_iter [SequenceLabels]
-Build a sequence from a iter function -
-
from_iter [Sequence]
-Build a sequence from a iter function -
-

G
group_by [SequenceLabels]
-Group equal elements, disregarding their order of appearance. -
-
group_by [Sequence]
-Group equal elements, disregarding their order of appearance. -
-
group_join_by [SequenceLabels]
-group_join_by key2 associates to every element x of - the first sequence, all the elements y of the second - sequence such that eq x (key y). -
-
group_join_by [Sequence]
-group_join_by key2 associates to every element x of - the first sequence, all the elements y of the second - sequence such that eq x (key y). -
-
group_succ_by [SequenceLabels]
-Group equal consecutive elements. -
-
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_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_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
init [SequenceLabels]
-init f is the infinite sequence f 0; f 1; f 2; …. -
-
init [Sequence]
-init f is the infinite sequence f 0; f 1; f 2; …. -
-
int_range [SequenceLabels]
-Iterator on integers in start...stop by steps 1. -
-
int_range [Sequence]
-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. -
-
inter [SequenceLabels]
-Intersection of two collections. -
-
inter [Sequence]
-Intersection of two collections. -
-
intersperse [SequenceLabels]
-Insert the single element between every element of the sequence -
-
intersperse [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? Forces the sequence. -
-
is_empty2 [SequenceLabels]
is_empty2 [Sequence]
iter [SequenceLabels]
-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]
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)), ... -
-
iteri [SequenceLabels]
-Iterate on elements and their index in the sequence -
-
iteri [Sequence]
-Iterate on elements and their index in the 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. -
-
join_all_by [SequenceLabels]
-join_all_by key1 key2 ~merge is a binary operation - that takes two sequences a and b, projects their - elements resp. -
-
join_all_by [Sequence]
-join_all_by key1 key2 ~merge is a binary operation - that takes two sequences a and b, projects their - elements resp. -
-
join_by [SequenceLabels]
-join key1 key2 ~merge is a binary operation - that takes two sequences a and b, projects their - elements resp. -
-
join_by [Sequence]
-join key1 key2 ~merge is a binary operation - that takes two sequences a and b, projects their - elements resp. -
-

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

L
length [SequenceLabels]
-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_exn [SequenceLabels]
-Unsafe version of SequenceLabels.max -
-
max_exn [Sequence]
-Unsafe version of Sequence.max -
-
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_exn [SequenceLabels]
-Unsafe version of SequenceLabels.min -
-
min_exn [Sequence]
-Unsafe version of Sequence.min -
-

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_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
pair_with_idx [SequenceLabels]
-Similar to SequenceLabels.zip_i but returns a normal sequence of tuples -
-
pair_with_idx [Sequence]
-Similar to Sequence.zip_i but returns a normal sequence of tuples -
-
persistent [SequenceLabels]
-Iterate on the sequence, storing elements in an efficient internal structure.. -
-
persistent [Sequence]
-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. -
-
product [SequenceLabels]
-Cartesian product of the sequences. -
-
product [Sequence]
-Cartesian product of the sequences. -
-
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. -
-
return [SequenceLabels]
-Synonym to SequenceLabels.singleton -
-
return [Sequence]
-Synonym to Sequence.singleton -
-
rev [SequenceLabels]
-Reverse the sequence. -
-
rev [Sequence]
-Reverse the 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 -
-
seq_list [SequenceLabels]
-seq_list l returns all the ways to pick one element in each sub-sequence - in l. -
-
seq_list [Sequence]
-seq_list l returns all the ways to pick one element in each sub-sequence - in l. -
-
seq_list_map [SequenceLabels]
-seq_list_map f l maps f over every element of l, - then calls SequenceLabels.seq_list -
-
seq_list_map [Sequence]
-seq_list_map f l maps f over every element of l, - then calls Sequence.seq_list -
-
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, 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 the sequence. -
-
sort_uniq [SequenceLabels]
-Sort the sequence and remove duplicates. -
-
sort_uniq [Sequence]
-Sort the sequence and remove duplicates. -
-
sorted [SequenceLabels]
-Checks whether the sequence is sorted. -
-
sorted [Sequence]
-Checks whether the sequence is sorted. -
-
subset [SequenceLabels]
-subset a b returns true if all elements of a belong to b. -
-
subset [Sequence]
-subset a b returns true if all elements of a belong to b. -
-
sum [SequenceLabels]
-Sum of elements -
-
sum [Sequence]
-Sum of elements -
-
sumf [SequenceLabels]
-Sum of elements, using Kahan summation -
-
sumf [Sequence]
-Sum of elements, using Kahan summation -
-

T
take [SequenceLabels]
-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_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_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 [SequenceLabels]
-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. -
-
union [SequenceLabels]
-Union of two collections. -
-
union [Sequence]
-Union of two collections. -
-
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 -
-
- - \ No newline at end of file diff --git a/api/style.css b/api/style.css deleted file mode 100644 index d8a7615..0000000 --- a/api/style.css +++ /dev/null @@ -1,39 +0,0 @@ -.keyword { font-weight : bold ; color : Red } -.keywordsign { color : #C04600 } -.comment { color : Green } -.constructor { color : Blue } -.type { color : #5C6585 } -.string { color : Maroon } -.warning { color : Red ; font-weight : bold } -.info { margin-left : 3em; margin-right: 3em } -.param_info { margin-top: 4px; margin-left : 3em; margin-right : 3em } -.code { color : #465F91 ; } -.typetable { border-style : hidden } -.paramstable { border-style : hidden ; padding: 5pt 5pt} -tr { background-color : White } -td.typefieldcomment { background-color : #FFFFFF ; font-size: smaller ;} -div.sig_block {margin-left: 2em} -*:target { background: yellow; } -body {font: 13px sans-serif; color: black; text-align: left; padding: 5px; margin: 0} -h1 { font-size : 20pt ; text-align: center; } -h2 { font-size : 20pt ; border: 1px solid #000000; margin-top: 5px; margin-bottom: 2px;text-align: center; background-color: #90BDFF ;padding: 2px; } -h3 { font-size : 20pt ; border: 1px solid #000000; margin-top: 5px; margin-bottom: 2px;text-align: center; background-color: #90DDFF ;padding: 2px; } -h4 { font-size : 20pt ; border: 1px solid #000000; margin-top: 5px; margin-bottom: 2px;text-align: center; background-color: #90EDFF ;padding: 2px; } -h5 { font-size : 20pt ; border: 1px solid #000000; margin-top: 5px; margin-bottom: 2px;text-align: center; background-color: #90FDFF ;padding: 2px; } -h6 { font-size : 20pt ; border: 1px solid #000000; margin-top: 5px; margin-bottom: 2px;text-align: center; background-color: #90BDFF ; padding: 2px; } -div.h7 { font-size : 20pt ; border: 1px solid #000000; margin-top: 5px; margin-bottom: 2px;text-align: center; background-color: #E0FFFF ; padding: 2px; } -div.h8 { font-size : 20pt ; border: 1px solid #000000; margin-top: 5px; margin-bottom: 2px;text-align: center; background-color: #F0FFFF ; padding: 2px; } -div.h9 { font-size : 20pt ; border: 1px solid #000000; margin-top: 5px; margin-bottom: 2px;text-align: center; background-color: #FFFFFF ; padding: 2px; } -a {color: #416DFF; text-decoration: none} -a:hover {background-color: #ddd; text-decoration: underline} -pre { margin-bottom: 4px; font-family: monospace; } -pre.verbatim, pre.codepre { } -.indextable {border: 1px #ddd solid; border-collapse: collapse} -.indextable td, .indextable th {border: 1px #ddd solid; min-width: 80px} -.indextable td.module {background-color: #eee ; padding-left: 2px; padding-right: 2px} -.indextable td.module a {color: #4E6272; text-decoration: none; display: block; width: 100%} -.indextable td.module a:hover {text-decoration: underline; background-color: transparent} -.deprecated {color: #888; font-style: italic} -.indextable tr td div.info { margin-left: 2px; margin-right: 2px } -ul.indexlist { margin-left: 0; padding-left: 0;} -ul.indexlist li { list-style-type: none ; margin-left: 0; padding-left: 0; } \ No newline at end of file diff --git a/api/type_Sequence.IO.html b/api/type_Sequence.IO.html deleted file mode 100644 index 9891a95..0000000 --- a/api/type_Sequence.IO.html +++ /dev/null @@ -1,35 +0,0 @@ - - - - - - - - - - - -Sequence.IO - - -sig
-  val lines_of :
-    ?mode:int ->
-    ?flags:Pervasives.open_flag list -> string -> string Sequence.t
-  val chunks_of :
-    ?mode:int ->
-    ?flags:Pervasives.open_flag list ->
-    ?size:int -> string -> string Sequence.t
-  val write_to :
-    ?mode:int ->
-    ?flags:Pervasives.open_flag list -> string -> string Sequence.t -> unit
-  val write_bytes_to :
-    ?mode:int ->
-    ?flags:Pervasives.open_flag list -> string -> Bytes.t Sequence.t -> unit
-  val write_lines :
-    ?mode:int ->
-    ?flags:Pervasives.open_flag list -> string -> string Sequence.t -> unit
-  val write_bytes_lines :
-    ?mode:int ->
-    ?flags:Pervasives.open_flag list -> string -> Bytes.t Sequence.t -> unit
-end \ No newline at end of file diff --git a/api/type_Sequence.Infix.html b/api/type_Sequence.Infix.html deleted file mode 100644 index f4e10ae..0000000 --- a/api/type_Sequence.Infix.html +++ /dev/null @@ -1,22 +0,0 @@ - - - - - - - - - - - -Sequence.Infix - - -sig
-  val ( -- ) : int -> int -> int Sequence.t
-  val ( --^ ) : int -> int -> int Sequence.t
-  val ( >>= ) : 'a Sequence.t -> ('a -> 'b Sequence.t) -> 'b Sequence.t
-  val ( >|= ) : 'a Sequence.t -> ('a -> 'b) -> 'b Sequence.t
-  val ( <*> ) : ('a -> 'b) Sequence.t -> 'a Sequence.t -> 'b Sequence.t
-  val ( <+> ) : 'a Sequence.t -> 'a Sequence.t -> 'a Sequence.t
-end \ No newline at end of file diff --git a/api/type_Sequence.Map.Adapt.html b/api/type_Sequence.Map.Adapt.html deleted file mode 100644 index 272a74e..0000000 --- a/api/type_Sequence.Map.Adapt.html +++ /dev/null @@ -1,59 +0,0 @@ - - - - - - - - - - - -Sequence.Map.Adapt - - -functor (M : Map.S) ->
-  sig
-    type key = M.key
-    type 'a t = 'a M.t
-    val empty : 'a t
-    val is_empty : 'a t -> bool
-    val mem : key -> 'a t -> bool
-    val add : key -> 'a -> 'a t -> 'a t
-    val singleton : key -> 'a -> 'a t
-    val remove : key -> 'a t -> 'a t
-    val merge :
-      (key -> 'a option -> 'b option -> 'c option) -> 'a t -> 'b t -> 'c t
-    val union : (key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
-    val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
-    val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
-    val iter : (key -> 'a -> unit) -> 'a t -> unit
-    val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
-    val for_all : (key -> 'a -> bool) -> 'a t -> bool
-    val exists : (key -> 'a -> bool) -> 'a t -> bool
-    val filter : (key -> 'a -> bool) -> 'a t -> 'a t
-    val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
-    val cardinal : 'a t -> int
-    val bindings : 'a t -> (key * 'a) list
-    val min_binding : 'a t -> key * 'a
-    val min_binding_opt : 'a t -> (key * 'a) option
-    val max_binding : 'a t -> key * 'a
-    val max_binding_opt : 'a t -> (key * 'a) option
-    val choose : 'a t -> key * 'a
-    val choose_opt : 'a t -> (key * 'a) option
-    val split : key -> 'a t -> 'a t * 'a option * 'a t
-    val find : key -> 'a t -> 'a
-    val find_opt : key -> 'a t -> 'a option
-    val find_first : (key -> bool) -> 'a t -> key * 'a
-    val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option
-    val find_last : (key -> bool) -> 'a t -> key * 'a
-    val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option
-    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 deleted file mode 100644 index a1021b0..0000000 --- a/api/type_Sequence.Map.Make.html +++ /dev/null @@ -1,59 +0,0 @@ - - - - - - - - - - - -Sequence.Map.Make - - -functor (V : Map.OrderedType) ->
-  sig
-    type key = V.t
-    type +'a t
-    val empty : 'a t
-    val is_empty : 'a t -> bool
-    val mem : key -> 'a t -> bool
-    val add : key -> 'a -> 'a t -> 'a t
-    val singleton : key -> 'a -> 'a t
-    val remove : key -> 'a t -> 'a t
-    val merge :
-      (key -> 'a option -> 'b option -> 'c option) -> 'a t -> 'b t -> 'c t
-    val union : (key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
-    val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
-    val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
-    val iter : (key -> 'a -> unit) -> 'a t -> unit
-    val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
-    val for_all : (key -> 'a -> bool) -> 'a t -> bool
-    val exists : (key -> 'a -> bool) -> 'a t -> bool
-    val filter : (key -> 'a -> bool) -> 'a t -> 'a t
-    val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
-    val cardinal : 'a t -> int
-    val bindings : 'a t -> (key * 'a) list
-    val min_binding : 'a t -> key * 'a
-    val min_binding_opt : 'a t -> (key * 'a) option
-    val max_binding : 'a t -> key * 'a
-    val max_binding_opt : 'a t -> (key * 'a) option
-    val choose : 'a t -> key * 'a
-    val choose_opt : 'a t -> (key * 'a) option
-    val split : key -> 'a t -> 'a t * 'a option * 'a t
-    val find : key -> 'a t -> 'a
-    val find_opt : key -> 'a t -> 'a option
-    val find_first : (key -> bool) -> 'a t -> key * 'a
-    val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option
-    val find_last : (key -> bool) -> 'a t -> key * 'a
-    val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option
-    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 deleted file mode 100644 index 0d179c2..0000000 --- a/api/type_Sequence.Map.S.html +++ /dev/null @@ -1,58 +0,0 @@ - - - - - - - - - - - -Sequence.Map.S - - -sig
-  type key
-  type +'a t
-  val empty : 'a t
-  val is_empty : 'a t -> bool
-  val mem : key -> 'a t -> bool
-  val add : key -> 'a -> 'a t -> 'a t
-  val singleton : key -> 'a -> 'a t
-  val remove : key -> 'a t -> 'a t
-  val merge :
-    (key -> 'a option -> 'b option -> 'c option) -> 'a t -> 'b t -> 'c t
-  val union : (key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
-  val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
-  val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
-  val iter : (key -> 'a -> unit) -> 'a t -> unit
-  val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
-  val for_all : (key -> 'a -> bool) -> 'a t -> bool
-  val exists : (key -> 'a -> bool) -> 'a t -> bool
-  val filter : (key -> 'a -> bool) -> 'a t -> 'a t
-  val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
-  val cardinal : 'a t -> int
-  val bindings : 'a t -> (key * 'a) list
-  val min_binding : 'a t -> key * 'a
-  val min_binding_opt : 'a t -> (key * 'a) option
-  val max_binding : 'a t -> key * 'a
-  val max_binding_opt : 'a t -> (key * 'a) option
-  val choose : 'a t -> key * 'a
-  val choose_opt : 'a t -> (key * 'a) option
-  val split : key -> 'a t -> 'a t * 'a option * 'a t
-  val find : key -> 'a t -> 'a
-  val find_opt : key -> 'a t -> 'a option
-  val find_first : (key -> bool) -> 'a t -> key * 'a
-  val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option
-  val find_last : (key -> bool) -> 'a t -> key * 'a
-  val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option
-  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 deleted file mode 100644 index 7b8f21d..0000000 --- a/api/type_Sequence.Map.html +++ /dev/null @@ -1,155 +0,0 @@ - - - - - - - - - - - -Sequence.Map - - -sig
-  module type S =
-    sig
-      type key
-      type +'a t
-      val empty : 'a t
-      val is_empty : 'a t -> bool
-      val mem : key -> 'a t -> bool
-      val add : key -> 'a -> 'a t -> 'a t
-      val singleton : key -> 'a -> 'a t
-      val remove : key -> 'a t -> 'a t
-      val merge :
-        (key -> 'a option -> 'b option -> 'c option) -> 'a t -> 'b t -> 'c t
-      val union : (key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
-      val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
-      val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
-      val iter : (key -> 'a -> unit) -> 'a t -> unit
-      val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
-      val for_all : (key -> 'a -> bool) -> 'a t -> bool
-      val exists : (key -> 'a -> bool) -> 'a t -> bool
-      val filter : (key -> 'a -> bool) -> 'a t -> 'a t
-      val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
-      val cardinal : 'a t -> int
-      val bindings : 'a t -> (key * 'a) list
-      val min_binding : 'a t -> key * 'a
-      val min_binding_opt : 'a t -> (key * 'a) option
-      val max_binding : 'a t -> key * 'a
-      val max_binding_opt : 'a t -> (key * 'a) option
-      val choose : 'a t -> key * 'a
-      val choose_opt : 'a t -> (key * 'a) option
-      val split : key -> 'a t -> 'a t * 'a option * 'a t
-      val find : key -> 'a t -> 'a
-      val find_opt : key -> 'a t -> 'a option
-      val find_first : (key -> bool) -> 'a t -> key * 'a
-      val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option
-      val find_last : (key -> bool) -> 'a t -> key * 'a
-      val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option
-      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 min_binding_opt : 'a t -> (key * 'a) option
-        val max_binding : 'a t -> key * 'a
-        val max_binding_opt : 'a t -> (key * 'a) option
-        val choose : 'a t -> key * 'a
-        val choose_opt : 'a t -> (key * 'a) option
-        val split : key -> 'a t -> 'a t * 'a option * 'a t
-        val find : key -> 'a t -> 'a
-        val find_opt : key -> 'a t -> 'a option
-        val find_first : (key -> bool) -> 'a t -> key * 'a
-        val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option
-        val find_last : (key -> bool) -> 'a t -> key * 'a
-        val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option
-        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 min_binding_opt : 'a t -> (key * 'a) option
-        val max_binding : 'a t -> key * 'a
-        val max_binding_opt : 'a t -> (key * 'a) option
-        val choose : 'a t -> key * 'a
-        val choose_opt : 'a t -> (key * 'a) option
-        val split : key -> 'a t -> 'a t * 'a option * 'a t
-        val find : key -> 'a t -> 'a
-        val find_opt : key -> 'a t -> 'a option
-        val find_first : (key -> bool) -> 'a t -> key * 'a
-        val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option
-        val find_last : (key -> bool) -> 'a t -> key * 'a
-        val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option
-        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 deleted file mode 100644 index 8aa5abe..0000000 --- a/api/type_Sequence.Set.Adapt.html +++ /dev/null @@ -1,57 +0,0 @@ - - - - - - - - - - - -Sequence.Set.Adapt - - -functor (X : Set.S) ->
-  sig
-    type elt = X.elt
-    type t = X.t
-    val empty : t
-    val is_empty : t -> bool
-    val mem : elt -> t -> bool
-    val add : elt -> t -> t
-    val singleton : elt -> t
-    val remove : elt -> t -> t
-    val union : t -> t -> t
-    val inter : t -> t -> t
-    val diff : t -> t -> t
-    val compare : t -> t -> int
-    val equal : t -> t -> bool
-    val subset : t -> t -> bool
-    val iter : (elt -> unit) -> t -> unit
-    val map : (elt -> elt) -> t -> t
-    val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
-    val for_all : (elt -> bool) -> t -> bool
-    val exists : (elt -> bool) -> t -> bool
-    val filter : (elt -> bool) -> t -> t
-    val partition : (elt -> bool) -> t -> t * t
-    val cardinal : t -> int
-    val elements : t -> elt list
-    val min_elt : t -> elt
-    val min_elt_opt : t -> elt option
-    val max_elt : t -> elt
-    val max_elt_opt : t -> elt option
-    val choose : t -> elt
-    val choose_opt : t -> elt option
-    val split : elt -> t -> t * bool * t
-    val find : elt -> t -> elt
-    val find_opt : elt -> t -> elt option
-    val find_first : (elt -> bool) -> t -> elt
-    val find_first_opt : (elt -> bool) -> t -> elt option
-    val find_last : (elt -> bool) -> t -> elt
-    val find_last_opt : (elt -> bool) -> t -> elt option
-    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 deleted file mode 100644 index ab6713f..0000000 --- a/api/type_Sequence.Set.Make.html +++ /dev/null @@ -1,57 +0,0 @@ - - - - - - - - - - - -Sequence.Set.Make - - -functor (X : Set.OrderedType) ->
-  sig
-    type elt = X.t
-    type t
-    val empty : t
-    val is_empty : t -> bool
-    val mem : elt -> t -> bool
-    val add : elt -> t -> t
-    val singleton : elt -> t
-    val remove : elt -> t -> t
-    val union : t -> t -> t
-    val inter : t -> t -> t
-    val diff : t -> t -> t
-    val compare : t -> t -> int
-    val equal : t -> t -> bool
-    val subset : t -> t -> bool
-    val iter : (elt -> unit) -> t -> unit
-    val map : (elt -> elt) -> t -> t
-    val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
-    val for_all : (elt -> bool) -> t -> bool
-    val exists : (elt -> bool) -> t -> bool
-    val filter : (elt -> bool) -> t -> t
-    val partition : (elt -> bool) -> t -> t * t
-    val cardinal : t -> int
-    val elements : t -> elt list
-    val min_elt : t -> elt
-    val min_elt_opt : t -> elt option
-    val max_elt : t -> elt
-    val max_elt_opt : t -> elt option
-    val choose : t -> elt
-    val choose_opt : t -> elt option
-    val split : elt -> t -> t * bool * t
-    val find : elt -> t -> elt
-    val find_opt : elt -> t -> elt option
-    val find_first : (elt -> bool) -> t -> elt
-    val find_first_opt : (elt -> bool) -> t -> elt option
-    val find_last : (elt -> bool) -> t -> elt
-    val find_last_opt : (elt -> bool) -> t -> elt option
-    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 deleted file mode 100644 index 97a082d..0000000 --- a/api/type_Sequence.Set.S.html +++ /dev/null @@ -1,56 +0,0 @@ - - - - - - - - - - - -Sequence.Set.S - - -sig
-  type elt
-  type t
-  val empty : t
-  val is_empty : t -> bool
-  val mem : elt -> t -> bool
-  val add : elt -> t -> t
-  val singleton : elt -> t
-  val remove : elt -> t -> t
-  val union : t -> t -> t
-  val inter : t -> t -> t
-  val diff : t -> t -> t
-  val compare : t -> t -> int
-  val equal : t -> t -> bool
-  val subset : t -> t -> bool
-  val iter : (elt -> unit) -> t -> unit
-  val map : (elt -> elt) -> t -> t
-  val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
-  val for_all : (elt -> bool) -> t -> bool
-  val exists : (elt -> bool) -> t -> bool
-  val filter : (elt -> bool) -> t -> t
-  val partition : (elt -> bool) -> t -> t * t
-  val cardinal : t -> int
-  val elements : t -> elt list
-  val min_elt : t -> elt
-  val min_elt_opt : t -> elt option
-  val max_elt : t -> elt
-  val max_elt_opt : t -> elt option
-  val choose : t -> elt
-  val choose_opt : t -> elt option
-  val split : elt -> t -> t * bool * t
-  val find : elt -> t -> elt
-  val find_opt : elt -> t -> elt option
-  val find_first : (elt -> bool) -> t -> elt
-  val find_first_opt : (elt -> bool) -> t -> elt option
-  val find_last : (elt -> bool) -> t -> elt
-  val find_last_opt : (elt -> bool) -> t -> elt option
-  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 deleted file mode 100644 index cd974ef..0000000 --- a/api/type_Sequence.Set.html +++ /dev/null @@ -1,147 +0,0 @@ - - - - - - - - - - - -Sequence.Set - - -sig
-  module type S =
-    sig
-      type elt
-      type t
-      val empty : t
-      val is_empty : t -> bool
-      val mem : elt -> t -> bool
-      val add : elt -> t -> t
-      val singleton : elt -> t
-      val remove : elt -> t -> t
-      val union : t -> t -> t
-      val inter : t -> t -> t
-      val diff : t -> t -> t
-      val compare : t -> t -> int
-      val equal : t -> t -> bool
-      val subset : t -> t -> bool
-      val iter : (elt -> unit) -> t -> unit
-      val map : (elt -> elt) -> t -> t
-      val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
-      val for_all : (elt -> bool) -> t -> bool
-      val exists : (elt -> bool) -> t -> bool
-      val filter : (elt -> bool) -> t -> t
-      val partition : (elt -> bool) -> t -> t * t
-      val cardinal : t -> int
-      val elements : t -> elt list
-      val min_elt : t -> elt
-      val min_elt_opt : t -> elt option
-      val max_elt : t -> elt
-      val max_elt_opt : t -> elt option
-      val choose : t -> elt
-      val choose_opt : t -> elt option
-      val split : elt -> t -> t * bool * t
-      val find : elt -> t -> elt
-      val find_opt : elt -> t -> elt option
-      val find_first : (elt -> bool) -> t -> elt
-      val find_first_opt : (elt -> bool) -> t -> elt option
-      val find_last : (elt -> bool) -> t -> elt
-      val find_last_opt : (elt -> bool) -> t -> elt option
-      val of_seq : elt Sequence.sequence -> Sequence.t
-      val to_seq : Sequence.t -> elt Sequence.sequence
-      val to_list : Sequence.t -> elt list
-      val of_list : elt list -> Sequence.t
-    end
-  module Adapt :
-    functor (X : Set.S) ->
-      sig
-        type elt = X.elt
-        type t = X.t
-        val empty : t
-        val is_empty : t -> bool
-        val mem : elt -> t -> bool
-        val add : elt -> t -> t
-        val singleton : elt -> t
-        val remove : elt -> t -> t
-        val union : t -> t -> t
-        val inter : t -> t -> t
-        val diff : t -> t -> t
-        val compare : t -> t -> int
-        val equal : t -> t -> bool
-        val subset : t -> t -> bool
-        val iter : (elt -> unit) -> t -> unit
-        val map : (elt -> elt) -> t -> t
-        val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
-        val for_all : (elt -> bool) -> t -> bool
-        val exists : (elt -> bool) -> t -> bool
-        val filter : (elt -> bool) -> t -> t
-        val partition : (elt -> bool) -> t -> t * t
-        val cardinal : t -> int
-        val elements : t -> elt list
-        val min_elt : t -> elt
-        val min_elt_opt : t -> elt option
-        val max_elt : t -> elt
-        val max_elt_opt : t -> elt option
-        val choose : t -> elt
-        val choose_opt : t -> elt option
-        val split : elt -> t -> t * bool * t
-        val find : elt -> t -> elt
-        val find_opt : elt -> t -> elt option
-        val find_first : (elt -> bool) -> t -> elt
-        val find_first_opt : (elt -> bool) -> t -> elt option
-        val find_last : (elt -> bool) -> t -> elt
-        val find_last_opt : (elt -> bool) -> t -> elt option
-        val of_seq : elt sequence -> t
-        val to_seq : t -> elt sequence
-        val to_list : t -> elt list
-        val of_list : elt list -> t
-      end
-  module Make :
-    functor (X : Set.OrderedType) ->
-      sig
-        type elt = X.t
-        type t
-        val empty : t
-        val is_empty : t -> bool
-        val mem : elt -> t -> bool
-        val add : elt -> t -> t
-        val singleton : elt -> t
-        val remove : elt -> t -> t
-        val union : t -> t -> t
-        val inter : t -> t -> t
-        val diff : t -> t -> t
-        val compare : t -> t -> int
-        val equal : t -> t -> bool
-        val subset : t -> t -> bool
-        val iter : (elt -> unit) -> t -> unit
-        val map : (elt -> elt) -> t -> t
-        val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
-        val for_all : (elt -> bool) -> t -> bool
-        val exists : (elt -> bool) -> t -> bool
-        val filter : (elt -> bool) -> t -> t
-        val partition : (elt -> bool) -> t -> t * t
-        val cardinal : t -> int
-        val elements : t -> elt list
-        val min_elt : t -> elt
-        val min_elt_opt : t -> elt option
-        val max_elt : t -> elt
-        val max_elt_opt : t -> elt option
-        val choose : t -> elt
-        val choose_opt : t -> elt option
-        val split : elt -> t -> t * bool * t
-        val find : elt -> t -> elt
-        val find_opt : elt -> t -> elt option
-        val find_first : (elt -> bool) -> t -> elt
-        val find_first_opt : (elt -> bool) -> t -> elt option
-        val find_last : (elt -> bool) -> t -> elt
-        val find_last_opt : (elt -> bool) -> t -> elt option
-        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.TypeClass.html b/api/type_Sequence.TypeClass.html deleted file mode 100644 index 93c139f..0000000 --- a/api/type_Sequence.TypeClass.html +++ /dev/null @@ -1,26 +0,0 @@ - - - - - - - - -Sequence.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 \ No newline at end of file diff --git a/api/type_Sequence.html b/api/type_Sequence.html deleted file mode 100644 index 155c6d1..0000000 --- a/api/type_Sequence.html +++ /dev/null @@ -1,533 +0,0 @@ - - - - - - - - - - - -Sequence - - -sig
-  type 'a t = ('a -> unit) -> unit
-  type 'a sequence = 'a Sequence.t
-  type ('a, 'b) t2 = ('a -> 'b -> unit) -> unit
-  type 'a equal = 'a -> 'a -> bool
-  type 'a hash = 'a -> int
-  val from_iter : (('a -> unit) -> unit) -> 'a Sequence.t
-  val from_fun : (unit -> 'a option) -> 'a Sequence.t
-  val empty : 'a Sequence.t
-  val singleton : 'a -> 'a Sequence.t
-  val doubleton : 'a -> 'a -> 'a Sequence.t
-  val init : (int -> 'a) -> 'a Sequence.t
-  val cons : 'a -> 'a Sequence.t -> 'a Sequence.t
-  val snoc : 'a Sequence.t -> 'a -> 'a Sequence.t
-  val return : 'a -> 'a Sequence.t
-  val pure : 'a -> 'a Sequence.t
-  val repeat : 'a -> 'a Sequence.t
-  val iterate : ('a -> 'a) -> 'a -> 'a Sequence.t
-  val forever : (unit -> 'b) -> 'b Sequence.t
-  val cycle : 'a Sequence.t -> 'a Sequence.t
-  val iter : ('a -> unit) -> 'a Sequence.t -> unit
-  val iteri : (int -> 'a -> unit) -> 'a Sequence.t -> unit
-  val fold : ('a -> 'b -> 'a) -> 'a -> 'b Sequence.t -> 'a
-  val foldi : ('a -> int -> 'b -> 'a) -> 'a -> 'b Sequence.t -> 'a
-  val fold_map :
-    ('acc -> 'a -> 'acc * 'b) -> 'acc -> 'a Sequence.t -> 'b Sequence.t
-  val fold_filter_map :
-    ('acc -> 'a -> 'acc * 'b option) ->
-    'acc -> 'a Sequence.t -> 'b Sequence.t
-  val map : ('a -> 'b) -> 'a Sequence.t -> 'b Sequence.t
-  val mapi : (int -> 'a -> 'b) -> 'a Sequence.t -> 'b Sequence.t
-  val map_by_2 : ('a -> 'a -> 'a) -> 'a Sequence.t -> 'a Sequence.t
-  val for_all : ('a -> bool) -> 'a Sequence.t -> bool
-  val exists : ('a -> bool) -> 'a Sequence.t -> bool
-  val mem : ?eq:('a -> 'a -> bool) -> 'a -> 'a Sequence.t -> bool
-  val find : ('a -> 'b option) -> 'a Sequence.t -> 'b option
-  val find_map : ('a -> 'b option) -> 'a Sequence.t -> 'b option
-  val findi : (int -> 'a -> 'b option) -> 'a Sequence.t -> 'b option
-  val find_mapi : (int -> 'a -> 'b option) -> 'a Sequence.t -> 'b option
-  val find_pred : ('a -> bool) -> 'a Sequence.t -> 'a option
-  val find_pred_exn : ('a -> bool) -> 'a Sequence.t -> 'a
-  val length : 'a Sequence.t -> int
-  val is_empty : 'a Sequence.t -> bool
-  val filter : ('a -> bool) -> 'a Sequence.t -> 'a Sequence.t
-  val append : 'a Sequence.t -> 'a Sequence.t -> 'a Sequence.t
-  val append_l : 'a Sequence.t list -> '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 seq_list : 'a Sequence.t list -> 'a list Sequence.t
-  val seq_list_map : ('a -> 'b Sequence.t) -> 'a list -> 'b list Sequence.t
-  val filter_map : ('a -> 'b option) -> 'a Sequence.t -> 'b Sequence.t
-  val filter_mapi :
-    (int -> 'a -> 'b option) -> 'a Sequence.t -> 'b Sequence.t
-  val intersperse : 'a -> 'a Sequence.t -> 'a Sequence.t
-  val persistent : 'a Sequence.t -> 'a Sequence.t
-  val persistent_lazy : 'a Sequence.t -> 'a Sequence.t
-  val sort : ?cmp:('a -> 'a -> int) -> 'a Sequence.t -> 'a Sequence.t
-  val sort_uniq : ?cmp:('a -> 'a -> int) -> 'a Sequence.t -> 'a Sequence.t
-  val sorted : ?cmp:('a -> 'a -> int) -> 'a Sequence.t -> bool
-  val group_succ_by :
-    ?eq:('a -> 'a -> bool) -> 'a Sequence.t -> 'a list Sequence.t
-  val group_by :
-    ?hash:('a -> int) ->
-    ?eq:('a -> 'a -> bool) -> 'a Sequence.t -> 'a list Sequence.t
-  val count :
-    ?hash:('a -> int) ->
-    ?eq:('a -> 'a -> bool) -> 'a Sequence.t -> ('a * int) Sequence.t
-  val uniq : ?eq:('a -> 'a -> bool) -> 'a Sequence.t -> 'a Sequence.t
-  val product : 'a Sequence.t -> 'b Sequence.t -> ('a * 'b) Sequence.t
-  val diagonal_l : 'a list -> ('a * 'a) Sequence.t
-  val diagonal : 'a Sequence.t -> ('a * 'a) Sequence.t
-  val product2 : 'a Sequence.t -> 'b Sequence.t -> ('a, 'b) Sequence.t2
-  val join :
-    join_row:('a -> 'b -> 'c option) ->
-    'a Sequence.t -> 'b Sequence.t -> 'c Sequence.t
-  val join_by :
-    ?eq:'key Sequence.equal ->
-    ?hash:'key Sequence.hash ->
-    ('a -> 'key) ->
-    ('b -> 'key) ->
-    merge:('key -> 'a -> 'b -> 'c option) ->
-    'a Sequence.t -> 'b Sequence.t -> 'c Sequence.t
-  val join_all_by :
-    ?eq:'key Sequence.equal ->
-    ?hash:'key Sequence.hash ->
-    ('a -> 'key) ->
-    ('b -> 'key) ->
-    merge:('key -> 'a list -> 'b list -> 'c option) ->
-    'a Sequence.t -> 'b Sequence.t -> 'c Sequence.t
-  val group_join_by :
-    ?eq:'a Sequence.equal ->
-    ?hash:'a Sequence.hash ->
-    ('b -> 'a) -> 'a Sequence.t -> 'b Sequence.t -> ('a * 'b list) Sequence.t
-  val inter :
-    ?eq:'a Sequence.equal ->
-    ?hash:'a Sequence.hash -> 'a Sequence.t -> 'a Sequence.t -> 'a Sequence.t
-  val union :
-    ?eq:'a Sequence.equal ->
-    ?hash:'a Sequence.hash -> 'a Sequence.t -> 'a Sequence.t -> 'a Sequence.t
-  val diff :
-    ?eq:'a Sequence.equal ->
-    ?hash:'a Sequence.hash -> 'a Sequence.t -> 'a Sequence.t -> 'a Sequence.t
-  val subset :
-    ?eq:'a Sequence.equal ->
-    ?hash:'a Sequence.hash -> 'a Sequence.t -> 'a Sequence.t -> bool
-  val unfoldr : ('b -> ('a * 'b) option) -> 'b -> 'a Sequence.t
-  val scan : ('b -> 'a -> 'b) -> 'b -> 'a Sequence.t -> 'b Sequence.t
-  val max : ?lt:('a -> 'a -> bool) -> 'a Sequence.t -> 'a option
-  val max_exn : ?lt:('a -> 'a -> bool) -> 'a Sequence.t -> 'a
-  val min : ?lt:('a -> 'a -> bool) -> 'a Sequence.t -> 'a option
-  val min_exn : ?lt:('a -> 'a -> bool) -> 'a Sequence.t -> 'a
-  val sum : int Sequence.t -> int
-  val sumf : float Sequence.t -> float
-  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 pair_with_idx : 'a Sequence.t -> (int * 'a) Sequence.t
-  val to_opt : 'a Sequence.t -> 'a option
-  val to_array : 'a Sequence.t -> 'a array
-  val of_array : 'a array -> 'a Sequence.t
-  val of_array_i : 'a array -> (int * 'a) Sequence.t
-  val of_array2 : 'a array -> (int, 'a) Sequence.t2
-  val array_slice : 'a array -> int -> int -> 'a Sequence.t
-  val of_opt : 'a option -> 'a Sequence.t
-  val of_stream : 'a Stream.t -> 'a Sequence.t
-  val to_stream : 'a Sequence.t -> 'a Stream.t
-  val to_stack : 'a Stack.t -> 'a Sequence.t -> unit
-  val of_stack : 'a Stack.t -> 'a Sequence.t
-  val to_queue : 'a Queue.t -> 'a Sequence.t -> unit
-  val of_queue : 'a Queue.t -> 'a Sequence.t
-  val hashtbl_add : ('a, 'b) Hashtbl.t -> ('a * 'b) Sequence.t -> unit
-  val hashtbl_replace : ('a, 'b) Hashtbl.t -> ('a * 'b) Sequence.t -> unit
-  val to_hashtbl : ('a * 'b) Sequence.t -> ('a, 'b) Hashtbl.t
-  val to_hashtbl2 : ('a, 'b) Sequence.t2 -> ('a, 'b) Hashtbl.t
-  val of_hashtbl : ('a, 'b) Hashtbl.t -> ('a * 'b) Sequence.t
-  val of_hashtbl2 : ('a, 'b) Hashtbl.t -> ('a, 'b) Sequence.t2
-  val hashtbl_keys : ('a, 'b) Hashtbl.t -> 'a Sequence.t
-  val hashtbl_values : ('a, 'b) Hashtbl.t -> 'b Sequence.t
-  val of_str : string -> char Sequence.t
-  val to_str : char Sequence.t -> string
-  val concat_str : string Sequence.t -> string
-  exception OneShotSequence
-  val of_in_channel : Pervasives.in_channel -> char Sequence.t
-  val to_buffer : char Sequence.t -> Buffer.t -> unit
-  val int_range : start:int -> stop:int -> int Sequence.t
-  val int_range_dec : start:int -> stop:int -> int Sequence.t
-  val int_range_by : step:int -> int -> int -> int Sequence.t
-  val bools : bool Sequence.t
-  val of_set :
-    (module Set.S with type elt = 'a and type t = 'b) -> 'b -> 'a Sequence.t
-  val to_set :
-    (module Set.S with type elt = 'a and type t = 'b) -> 'a Sequence.t -> 'b
-  type 'a gen = unit -> 'a option
-  type 'a klist = unit -> [ `Cons of 'a * 'a Sequence.klist | `Nil ]
-  val of_gen : 'a Sequence.gen -> 'a Sequence.t
-  val to_gen : 'a Sequence.t -> 'a Sequence.gen
-  val of_klist : 'a Sequence.klist -> 'a Sequence.t
-  val to_klist : 'a Sequence.t -> 'a Sequence.klist
-  module Set :
-    sig
-      module type S =
-        sig
-          type elt
-          type t
-          val empty : t
-          val is_empty : t -> bool
-          val mem : elt -> t -> bool
-          val add : elt -> t -> t
-          val singleton : elt -> t
-          val remove : elt -> t -> t
-          val union : t -> t -> t
-          val inter : t -> t -> t
-          val diff : t -> t -> t
-          val compare : t -> t -> int
-          val equal : t -> t -> bool
-          val subset : t -> t -> bool
-          val iter : (elt -> unit) -> t -> unit
-          val map : (elt -> elt) -> t -> t
-          val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
-          val for_all : (elt -> bool) -> t -> bool
-          val exists : (elt -> bool) -> t -> bool
-          val filter : (elt -> bool) -> t -> t
-          val partition : (elt -> bool) -> t -> t * t
-          val cardinal : t -> int
-          val elements : t -> elt list
-          val min_elt : t -> elt
-          val min_elt_opt : t -> elt option
-          val max_elt : t -> elt
-          val max_elt_opt : t -> elt option
-          val choose : t -> elt
-          val choose_opt : t -> elt option
-          val split : elt -> t -> t * bool * t
-          val find : elt -> t -> elt
-          val find_opt : elt -> t -> elt option
-          val find_first : (elt -> bool) -> t -> elt
-          val find_first_opt : (elt -> bool) -> t -> elt option
-          val find_last : (elt -> bool) -> t -> elt
-          val find_last_opt : (elt -> bool) -> t -> elt option
-          val of_seq : elt Sequence.sequence -> Sequence.t
-          val to_seq : Sequence.t -> elt Sequence.sequence
-          val to_list : Sequence.t -> elt list
-          val of_list : elt list -> Sequence.t
-        end
-      module Adapt :
-        functor (X : Set.S) ->
-          sig
-            type elt = X.elt
-            type t = X.t
-            val empty : t
-            val is_empty : t -> bool
-            val mem : elt -> t -> bool
-            val add : elt -> t -> t
-            val singleton : elt -> t
-            val remove : elt -> t -> t
-            val union : t -> t -> t
-            val inter : t -> t -> t
-            val diff : t -> t -> t
-            val compare : t -> t -> int
-            val equal : t -> t -> bool
-            val subset : t -> t -> bool
-            val iter : (elt -> unit) -> t -> unit
-            val map : (elt -> elt) -> t -> t
-            val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
-            val for_all : (elt -> bool) -> t -> bool
-            val exists : (elt -> bool) -> t -> bool
-            val filter : (elt -> bool) -> t -> t
-            val partition : (elt -> bool) -> t -> t * t
-            val cardinal : t -> int
-            val elements : t -> elt list
-            val min_elt : t -> elt
-            val min_elt_opt : t -> elt option
-            val max_elt : t -> elt
-            val max_elt_opt : t -> elt option
-            val choose : t -> elt
-            val choose_opt : t -> elt option
-            val split : elt -> t -> t * bool * t
-            val find : elt -> t -> elt
-            val find_opt : elt -> t -> elt option
-            val find_first : (elt -> bool) -> t -> elt
-            val find_first_opt : (elt -> bool) -> t -> elt option
-            val find_last : (elt -> bool) -> t -> elt
-            val find_last_opt : (elt -> bool) -> t -> elt option
-            val of_seq : elt sequence -> t
-            val to_seq : t -> elt sequence
-            val to_list : t -> elt list
-            val of_list : elt list -> t
-          end
-      module Make :
-        functor (X : Set.OrderedType) ->
-          sig
-            type elt = X.t
-            type t
-            val empty : t
-            val is_empty : t -> bool
-            val mem : elt -> t -> bool
-            val add : elt -> t -> t
-            val singleton : elt -> t
-            val remove : elt -> t -> t
-            val union : t -> t -> t
-            val inter : t -> t -> t
-            val diff : t -> t -> t
-            val compare : t -> t -> int
-            val equal : t -> t -> bool
-            val subset : t -> t -> bool
-            val iter : (elt -> unit) -> t -> unit
-            val map : (elt -> elt) -> t -> t
-            val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
-            val for_all : (elt -> bool) -> t -> bool
-            val exists : (elt -> bool) -> t -> bool
-            val filter : (elt -> bool) -> t -> t
-            val partition : (elt -> bool) -> t -> t * t
-            val cardinal : t -> int
-            val elements : t -> elt list
-            val min_elt : t -> elt
-            val min_elt_opt : t -> elt option
-            val max_elt : t -> elt
-            val max_elt_opt : t -> elt option
-            val choose : t -> elt
-            val choose_opt : t -> elt option
-            val split : elt -> t -> t * bool * t
-            val find : elt -> t -> elt
-            val find_opt : elt -> t -> elt option
-            val find_first : (elt -> bool) -> t -> elt
-            val find_first_opt : (elt -> bool) -> t -> elt option
-            val find_last : (elt -> bool) -> t -> elt
-            val find_last_opt : (elt -> bool) -> t -> elt option
-            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 min_binding_opt : 'a t -> (key * 'a) option
-          val max_binding : 'a t -> key * 'a
-          val max_binding_opt : 'a t -> (key * 'a) option
-          val choose : 'a t -> key * 'a
-          val choose_opt : 'a t -> (key * 'a) option
-          val split : key -> 'a t -> 'a t * 'a option * 'a t
-          val find : key -> 'a t -> 'a
-          val find_opt : key -> 'a t -> 'a option
-          val find_first : (key -> bool) -> 'a t -> key * 'a
-          val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option
-          val find_last : (key -> bool) -> 'a t -> key * 'a
-          val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option
-          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 min_binding_opt : 'a t -> (key * 'a) option
-            val max_binding : 'a t -> key * 'a
-            val max_binding_opt : 'a t -> (key * 'a) option
-            val choose : 'a t -> key * 'a
-            val choose_opt : 'a t -> (key * 'a) option
-            val split : key -> 'a t -> 'a t * 'a option * 'a t
-            val find : key -> 'a t -> 'a
-            val find_opt : key -> 'a t -> 'a option
-            val find_first : (key -> bool) -> 'a t -> key * 'a
-            val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option
-            val find_last : (key -> bool) -> 'a t -> key * 'a
-            val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option
-            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 min_binding_opt : 'a t -> (key * 'a) option
-            val max_binding : 'a t -> key * 'a
-            val max_binding_opt : 'a t -> (key * 'a) option
-            val choose : 'a t -> key * 'a
-            val choose_opt : 'a t -> (key * 'a) option
-            val split : key -> 'a t -> 'a t * 'a option * 'a t
-            val find : key -> 'a t -> 'a
-            val find_opt : key -> 'a t -> 'a option
-            val find_first : (key -> bool) -> 'a t -> key * 'a
-            val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option
-            val find_last : (key -> bool) -> 'a t -> key * 'a
-            val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option
-            val map : ('a -> 'b) -> 'a t -> 'b t
-            val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
-            val to_seq : 'a t -> (key * 'a) sequence
-            val of_seq : (key * 'a) sequence -> 'a t
-            val keys : 'a t -> key sequence
-            val values : 'a t -> 'a sequence
-            val to_list : 'a t -> (key * 'a) list
-            val of_list : (key * 'a) list -> 'a t
-          end
-    end
-  val random_int : int -> int Sequence.t
-  val random_bool : bool Sequence.t
-  val random_float : float -> float Sequence.t
-  val random_array : 'a array -> 'a Sequence.t
-  val random_list : 'a list -> 'a Sequence.t
-  val shuffle : 'a Sequence.t -> 'a Sequence.t
-  val shuffle_buffer : int -> 'a Sequence.t -> 'a Sequence.t
-  val sample : int -> 'a Sequence.t -> 'a array
-  module Infix :
-    sig
-      val ( -- ) : int -> int -> int Sequence.t
-      val ( --^ ) : int -> int -> int Sequence.t
-      val ( >>= ) : 'a Sequence.t -> ('a -> 'b Sequence.t) -> 'b Sequence.t
-      val ( >|= ) : 'a Sequence.t -> ('a -> 'b) -> 'b Sequence.t
-      val ( <*> ) : ('a -> 'b) Sequence.t -> 'a Sequence.t -> 'b Sequence.t
-      val ( <+> ) : 'a Sequence.t -> 'a Sequence.t -> 'a Sequence.t
-    end
-  val ( -- ) : int -> int -> int t
-  val ( --^ ) : int -> int -> int t
-  val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
-  val ( >|= ) : 'a t -> ('a -> 'b) -> 'b t
-  val ( <*> ) : ('a -> 'b) t -> 'a t -> 'b t
-  val ( <+> ) : 'a t -> 'a t -> 'a t
-  val pp_seq :
-    ?sep:string ->
-    (Format.formatter -> 'a -> unit) ->
-    Format.formatter -> 'a Sequence.t -> unit
-  val pp_buf :
-    ?sep:string ->
-    (Buffer.t -> 'a -> unit) -> Buffer.t -> 'a Sequence.t -> unit
-  val to_string : ?sep:string -> ('a -> string) -> 'a Sequence.t -> string
-  module IO :
-    sig
-      val lines_of :
-        ?mode:int ->
-        ?flags:Pervasives.open_flag list -> string -> string Sequence.t
-      val chunks_of :
-        ?mode:int ->
-        ?flags:Pervasives.open_flag list ->
-        ?size:int -> string -> string Sequence.t
-      val write_to :
-        ?mode:int ->
-        ?flags:Pervasives.open_flag list ->
-        string -> string Sequence.t -> unit
-      val write_bytes_to :
-        ?mode:int ->
-        ?flags:Pervasives.open_flag list ->
-        string -> Bytes.t Sequence.t -> unit
-      val write_lines :
-        ?mode:int ->
-        ?flags:Pervasives.open_flag list ->
-        string -> string Sequence.t -> unit
-      val write_bytes_lines :
-        ?mode:int ->
-        ?flags:Pervasives.open_flag list ->
-        string -> Bytes.t Sequence.t -> unit
-    end
-end \ No newline at end of file diff --git a/api/type_SequenceLabels.IO.html b/api/type_SequenceLabels.IO.html deleted file mode 100644 index 79e2cd1..0000000 --- a/api/type_SequenceLabels.IO.html +++ /dev/null @@ -1,39 +0,0 @@ - - - - - - - - - - - -SequenceLabels.IO - - -sig
-  val lines_of :
-    ?mode:int ->
-    ?flags:Pervasives.open_flag list -> string -> string SequenceLabels.t
-  val chunks_of :
-    ?mode:int ->
-    ?flags:Pervasives.open_flag list ->
-    ?size:int -> string -> string SequenceLabels.t
-  val write_to :
-    ?mode:int ->
-    ?flags:Pervasives.open_flag list ->
-    string -> string SequenceLabels.t -> unit
-  val write_bytes_to :
-    ?mode:int ->
-    ?flags:Pervasives.open_flag list ->
-    string -> Bytes.t SequenceLabels.t -> unit
-  val write_lines :
-    ?mode:int ->
-    ?flags:Pervasives.open_flag list ->
-    string -> string SequenceLabels.t -> unit
-  val write_bytes_lines :
-    ?mode:int ->
-    ?flags:Pervasives.open_flag list ->
-    string -> Bytes.t SequenceLabels.t -> unit
-end \ No newline at end of file diff --git a/api/type_SequenceLabels.Infix.html b/api/type_SequenceLabels.Infix.html deleted file mode 100644 index 52db5d5..0000000 --- a/api/type_SequenceLabels.Infix.html +++ /dev/null @@ -1,25 +0,0 @@ - - - - - - - - - - - -SequenceLabels.Infix - - -sig
-  val ( -- ) : int -> int -> int SequenceLabels.t
-  val ( --^ ) : int -> int -> int SequenceLabels.t
-  val ( >>= ) :
-    'a SequenceLabels.t -> ('a -> 'b SequenceLabels.t) -> 'b SequenceLabels.t
-  val ( >|= ) : 'a SequenceLabels.t -> ('a -> 'b) -> 'b SequenceLabels.t
-  val ( <*> ) :
-    ('a -> 'b) SequenceLabels.t -> 'a SequenceLabels.t -> 'b SequenceLabels.t
-  val ( <+> ) :
-    'a SequenceLabels.t -> 'a SequenceLabels.t -> 'a SequenceLabels.t
-end \ No newline at end of file diff --git a/api/type_SequenceLabels.Map.Adapt.html b/api/type_SequenceLabels.Map.Adapt.html deleted file mode 100644 index b678040..0000000 --- a/api/type_SequenceLabels.Map.Adapt.html +++ /dev/null @@ -1,59 +0,0 @@ - - - - - - - - - - - -SequenceLabels.Map.Adapt - - -functor (M : Map.S) ->
-  sig
-    type key = M.key
-    type 'a t = 'a M.t
-    val empty : 'a t
-    val is_empty : 'a t -> bool
-    val mem : key -> 'a t -> bool
-    val add : key -> 'a -> 'a t -> 'a t
-    val singleton : key -> 'a -> 'a t
-    val remove : key -> 'a t -> 'a t
-    val merge :
-      (key -> 'a option -> 'b option -> 'c option) -> 'a t -> 'b t -> 'c t
-    val union : (key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
-    val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
-    val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
-    val iter : (key -> 'a -> unit) -> 'a t -> unit
-    val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
-    val for_all : (key -> 'a -> bool) -> 'a t -> bool
-    val exists : (key -> 'a -> bool) -> 'a t -> bool
-    val filter : (key -> 'a -> bool) -> 'a t -> 'a t
-    val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
-    val cardinal : 'a t -> int
-    val bindings : 'a t -> (key * 'a) list
-    val min_binding : 'a t -> key * 'a
-    val min_binding_opt : 'a t -> (key * 'a) option
-    val max_binding : 'a t -> key * 'a
-    val max_binding_opt : 'a t -> (key * 'a) option
-    val choose : 'a t -> key * 'a
-    val choose_opt : 'a t -> (key * 'a) option
-    val split : key -> 'a t -> 'a t * 'a option * 'a t
-    val find : key -> 'a t -> 'a
-    val find_opt : key -> 'a t -> 'a option
-    val find_first : (key -> bool) -> 'a t -> key * 'a
-    val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option
-    val find_last : (key -> bool) -> 'a t -> key * 'a
-    val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option
-    val map : ('a -> 'b) -> 'a t -> 'b t
-    val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
-    val to_seq : 'a t -> (key * 'a) sequence
-    val of_seq : (key * 'a) sequence -> 'a t
-    val keys : 'a t -> key sequence
-    val values : 'a t -> 'a sequence
-    val to_list : 'a t -> (key * 'a) list
-    val of_list : (key * 'a) list -> 'a t
-  end \ No newline at end of file diff --git a/api/type_SequenceLabels.Map.Make.html b/api/type_SequenceLabels.Map.Make.html deleted file mode 100644 index 1fd146f..0000000 --- a/api/type_SequenceLabels.Map.Make.html +++ /dev/null @@ -1,59 +0,0 @@ - - - - - - - - - - - -SequenceLabels.Map.Make - - -functor (V : Map.OrderedType) ->
-  sig
-    type key = V.t
-    type +'a t
-    val empty : 'a t
-    val is_empty : 'a t -> bool
-    val mem : key -> 'a t -> bool
-    val add : key -> 'a -> 'a t -> 'a t
-    val singleton : key -> 'a -> 'a t
-    val remove : key -> 'a t -> 'a t
-    val merge :
-      (key -> 'a option -> 'b option -> 'c option) -> 'a t -> 'b t -> 'c t
-    val union : (key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
-    val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
-    val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
-    val iter : (key -> 'a -> unit) -> 'a t -> unit
-    val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
-    val for_all : (key -> 'a -> bool) -> 'a t -> bool
-    val exists : (key -> 'a -> bool) -> 'a t -> bool
-    val filter : (key -> 'a -> bool) -> 'a t -> 'a t
-    val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
-    val cardinal : 'a t -> int
-    val bindings : 'a t -> (key * 'a) list
-    val min_binding : 'a t -> key * 'a
-    val min_binding_opt : 'a t -> (key * 'a) option
-    val max_binding : 'a t -> key * 'a
-    val max_binding_opt : 'a t -> (key * 'a) option
-    val choose : 'a t -> key * 'a
-    val choose_opt : 'a t -> (key * 'a) option
-    val split : key -> 'a t -> 'a t * 'a option * 'a t
-    val find : key -> 'a t -> 'a
-    val find_opt : key -> 'a t -> 'a option
-    val find_first : (key -> bool) -> 'a t -> key * 'a
-    val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option
-    val find_last : (key -> bool) -> 'a t -> key * 'a
-    val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option
-    val map : ('a -> 'b) -> 'a t -> 'b t
-    val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
-    val to_seq : 'a t -> (key * 'a) sequence
-    val of_seq : (key * 'a) sequence -> 'a t
-    val keys : 'a t -> key sequence
-    val values : 'a t -> 'a sequence
-    val to_list : 'a t -> (key * 'a) list
-    val of_list : (key * 'a) list -> 'a t
-  end \ No newline at end of file diff --git a/api/type_SequenceLabels.Map.S.html b/api/type_SequenceLabels.Map.S.html deleted file mode 100644 index ce91ffc..0000000 --- a/api/type_SequenceLabels.Map.S.html +++ /dev/null @@ -1,58 +0,0 @@ - - - - - - - - - - - -SequenceLabels.Map.S - - -sig
-  type key
-  type +'a t
-  val empty : 'a t
-  val is_empty : 'a t -> bool
-  val mem : key -> 'a t -> bool
-  val add : key -> 'a -> 'a t -> 'a t
-  val singleton : key -> 'a -> 'a t
-  val remove : key -> 'a t -> 'a t
-  val merge :
-    (key -> 'a option -> 'b option -> 'c option) -> 'a t -> 'b t -> 'c t
-  val union : (key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
-  val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
-  val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
-  val iter : (key -> 'a -> unit) -> 'a t -> unit
-  val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
-  val for_all : (key -> 'a -> bool) -> 'a t -> bool
-  val exists : (key -> 'a -> bool) -> 'a t -> bool
-  val filter : (key -> 'a -> bool) -> 'a t -> 'a t
-  val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
-  val cardinal : 'a t -> int
-  val bindings : 'a t -> (key * 'a) list
-  val min_binding : 'a t -> key * 'a
-  val min_binding_opt : 'a t -> (key * 'a) option
-  val max_binding : 'a t -> key * 'a
-  val max_binding_opt : 'a t -> (key * 'a) option
-  val choose : 'a t -> key * 'a
-  val choose_opt : 'a t -> (key * 'a) option
-  val split : key -> 'a t -> 'a t * 'a option * 'a t
-  val find : key -> 'a t -> 'a
-  val find_opt : key -> 'a t -> 'a option
-  val find_first : (key -> bool) -> 'a t -> key * 'a
-  val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option
-  val find_last : (key -> bool) -> 'a t -> key * 'a
-  val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option
-  val map : ('a -> 'b) -> 'a t -> 'b t
-  val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
-  val to_seq : 'a SequenceLabels.t -> (key * 'a) SequenceLabels.sequence
-  val of_seq : (key * 'a) SequenceLabels.sequence -> 'a SequenceLabels.t
-  val keys : 'a SequenceLabels.t -> key SequenceLabels.sequence
-  val values : 'a SequenceLabels.t -> 'a SequenceLabels.sequence
-  val to_list : 'a SequenceLabels.t -> (key * 'a) list
-  val of_list : (key * 'a) list -> 'a SequenceLabels.t
-end \ No newline at end of file diff --git a/api/type_SequenceLabels.Map.html b/api/type_SequenceLabels.Map.html deleted file mode 100644 index 510cea3..0000000 --- a/api/type_SequenceLabels.Map.html +++ /dev/null @@ -1,155 +0,0 @@ - - - - - - - - - - - -SequenceLabels.Map - - -sig
-  module type S =
-    sig
-      type key
-      type +'a t
-      val empty : 'a t
-      val is_empty : 'a t -> bool
-      val mem : key -> 'a t -> bool
-      val add : key -> 'a -> 'a t -> 'a t
-      val singleton : key -> 'a -> 'a t
-      val remove : key -> 'a t -> 'a t
-      val merge :
-        (key -> 'a option -> 'b option -> 'c option) -> 'a t -> 'b t -> 'c t
-      val union : (key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
-      val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
-      val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
-      val iter : (key -> 'a -> unit) -> 'a t -> unit
-      val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
-      val for_all : (key -> 'a -> bool) -> 'a t -> bool
-      val exists : (key -> 'a -> bool) -> 'a t -> bool
-      val filter : (key -> 'a -> bool) -> 'a t -> 'a t
-      val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
-      val cardinal : 'a t -> int
-      val bindings : 'a t -> (key * 'a) list
-      val min_binding : 'a t -> key * 'a
-      val min_binding_opt : 'a t -> (key * 'a) option
-      val max_binding : 'a t -> key * 'a
-      val max_binding_opt : 'a t -> (key * 'a) option
-      val choose : 'a t -> key * 'a
-      val choose_opt : 'a t -> (key * 'a) option
-      val split : key -> 'a t -> 'a t * 'a option * 'a t
-      val find : key -> 'a t -> 'a
-      val find_opt : key -> 'a t -> 'a option
-      val find_first : (key -> bool) -> 'a t -> key * 'a
-      val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option
-      val find_last : (key -> bool) -> 'a t -> key * 'a
-      val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option
-      val map : ('a -> 'b) -> 'a t -> 'b t
-      val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
-      val to_seq : 'a SequenceLabels.t -> (key * 'a) SequenceLabels.sequence
-      val of_seq : (key * 'a) SequenceLabels.sequence -> 'a SequenceLabels.t
-      val keys : 'a SequenceLabels.t -> key SequenceLabels.sequence
-      val values : 'a SequenceLabels.t -> 'a SequenceLabels.sequence
-      val to_list : 'a SequenceLabels.t -> (key * 'a) list
-      val of_list : (key * 'a) list -> 'a SequenceLabels.t
-    end
-  module Adapt :
-    functor (M : Map.S) ->
-      sig
-        type key = M.key
-        type 'a t = 'a M.t
-        val empty : 'a t
-        val is_empty : 'a t -> bool
-        val mem : key -> 'a t -> bool
-        val add : key -> 'a -> 'a t -> 'a t
-        val singleton : key -> 'a -> 'a t
-        val remove : key -> 'a t -> 'a t
-        val merge :
-          (key -> 'a option -> 'b option -> 'c option) ->
-          'a t -> 'b t -> 'c t
-        val union : (key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
-        val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
-        val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
-        val iter : (key -> 'a -> unit) -> 'a t -> unit
-        val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
-        val for_all : (key -> 'a -> bool) -> 'a t -> bool
-        val exists : (key -> 'a -> bool) -> 'a t -> bool
-        val filter : (key -> 'a -> bool) -> 'a t -> 'a t
-        val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
-        val cardinal : 'a t -> int
-        val bindings : 'a t -> (key * 'a) list
-        val min_binding : 'a t -> key * 'a
-        val min_binding_opt : 'a t -> (key * 'a) option
-        val max_binding : 'a t -> key * 'a
-        val max_binding_opt : 'a t -> (key * 'a) option
-        val choose : 'a t -> key * 'a
-        val choose_opt : 'a t -> (key * 'a) option
-        val split : key -> 'a t -> 'a t * 'a option * 'a t
-        val find : key -> 'a t -> 'a
-        val find_opt : key -> 'a t -> 'a option
-        val find_first : (key -> bool) -> 'a t -> key * 'a
-        val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option
-        val find_last : (key -> bool) -> 'a t -> key * 'a
-        val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option
-        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 min_binding_opt : 'a t -> (key * 'a) option
-        val max_binding : 'a t -> key * 'a
-        val max_binding_opt : 'a t -> (key * 'a) option
-        val choose : 'a t -> key * 'a
-        val choose_opt : 'a t -> (key * 'a) option
-        val split : key -> 'a t -> 'a t * 'a option * 'a t
-        val find : key -> 'a t -> 'a
-        val find_opt : key -> 'a t -> 'a option
-        val find_first : (key -> bool) -> 'a t -> key * 'a
-        val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option
-        val find_last : (key -> bool) -> 'a t -> key * 'a
-        val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option
-        val map : ('a -> 'b) -> 'a t -> 'b t
-        val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
-        val to_seq : 'a t -> (key * 'a) sequence
-        val of_seq : (key * 'a) sequence -> 'a t
-        val keys : 'a t -> key sequence
-        val values : 'a t -> 'a sequence
-        val to_list : 'a t -> (key * 'a) list
-        val of_list : (key * 'a) list -> 'a t
-      end
-end \ No newline at end of file diff --git a/api/type_SequenceLabels.Set.Adapt.html b/api/type_SequenceLabels.Set.Adapt.html deleted file mode 100644 index 9e89d3c..0000000 --- a/api/type_SequenceLabels.Set.Adapt.html +++ /dev/null @@ -1,57 +0,0 @@ - - - - - - - - - - - -SequenceLabels.Set.Adapt - - -functor (X : Set.S) ->
-  sig
-    type elt = X.elt
-    type t = X.t
-    val empty : t
-    val is_empty : t -> bool
-    val mem : elt -> t -> bool
-    val add : elt -> t -> t
-    val singleton : elt -> t
-    val remove : elt -> t -> t
-    val union : t -> t -> t
-    val inter : t -> t -> t
-    val diff : t -> t -> t
-    val compare : t -> t -> int
-    val equal : t -> t -> bool
-    val subset : t -> t -> bool
-    val iter : (elt -> unit) -> t -> unit
-    val map : (elt -> elt) -> t -> t
-    val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
-    val for_all : (elt -> bool) -> t -> bool
-    val exists : (elt -> bool) -> t -> bool
-    val filter : (elt -> bool) -> t -> t
-    val partition : (elt -> bool) -> t -> t * t
-    val cardinal : t -> int
-    val elements : t -> elt list
-    val min_elt : t -> elt
-    val min_elt_opt : t -> elt option
-    val max_elt : t -> elt
-    val max_elt_opt : t -> elt option
-    val choose : t -> elt
-    val choose_opt : t -> elt option
-    val split : elt -> t -> t * bool * t
-    val find : elt -> t -> elt
-    val find_opt : elt -> t -> elt option
-    val find_first : (elt -> bool) -> t -> elt
-    val find_first_opt : (elt -> bool) -> t -> elt option
-    val find_last : (elt -> bool) -> t -> elt
-    val find_last_opt : (elt -> bool) -> t -> elt option
-    val of_seq : elt sequence -> t
-    val to_seq : t -> elt sequence
-    val to_list : t -> elt list
-    val of_list : elt list -> t
-  end \ No newline at end of file diff --git a/api/type_SequenceLabels.Set.Make.html b/api/type_SequenceLabels.Set.Make.html deleted file mode 100644 index c4ae436..0000000 --- a/api/type_SequenceLabels.Set.Make.html +++ /dev/null @@ -1,57 +0,0 @@ - - - - - - - - - - - -SequenceLabels.Set.Make - - -functor (X : Set.OrderedType) ->
-  sig
-    type elt = X.t
-    type t
-    val empty : t
-    val is_empty : t -> bool
-    val mem : elt -> t -> bool
-    val add : elt -> t -> t
-    val singleton : elt -> t
-    val remove : elt -> t -> t
-    val union : t -> t -> t
-    val inter : t -> t -> t
-    val diff : t -> t -> t
-    val compare : t -> t -> int
-    val equal : t -> t -> bool
-    val subset : t -> t -> bool
-    val iter : (elt -> unit) -> t -> unit
-    val map : (elt -> elt) -> t -> t
-    val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
-    val for_all : (elt -> bool) -> t -> bool
-    val exists : (elt -> bool) -> t -> bool
-    val filter : (elt -> bool) -> t -> t
-    val partition : (elt -> bool) -> t -> t * t
-    val cardinal : t -> int
-    val elements : t -> elt list
-    val min_elt : t -> elt
-    val min_elt_opt : t -> elt option
-    val max_elt : t -> elt
-    val max_elt_opt : t -> elt option
-    val choose : t -> elt
-    val choose_opt : t -> elt option
-    val split : elt -> t -> t * bool * t
-    val find : elt -> t -> elt
-    val find_opt : elt -> t -> elt option
-    val find_first : (elt -> bool) -> t -> elt
-    val find_first_opt : (elt -> bool) -> t -> elt option
-    val find_last : (elt -> bool) -> t -> elt
-    val find_last_opt : (elt -> bool) -> t -> elt option
-    val of_seq : elt sequence -> t
-    val to_seq : t -> elt sequence
-    val to_list : t -> elt list
-    val of_list : elt list -> t
-  end \ No newline at end of file diff --git a/api/type_SequenceLabels.Set.S.html b/api/type_SequenceLabels.Set.S.html deleted file mode 100644 index d429e01..0000000 --- a/api/type_SequenceLabels.Set.S.html +++ /dev/null @@ -1,56 +0,0 @@ - - - - - - - - - - - -SequenceLabels.Set.S - - -sig
-  type elt
-  type t
-  val empty : t
-  val is_empty : t -> bool
-  val mem : elt -> t -> bool
-  val add : elt -> t -> t
-  val singleton : elt -> t
-  val remove : elt -> t -> t
-  val union : t -> t -> t
-  val inter : t -> t -> t
-  val diff : t -> t -> t
-  val compare : t -> t -> int
-  val equal : t -> t -> bool
-  val subset : t -> t -> bool
-  val iter : (elt -> unit) -> t -> unit
-  val map : (elt -> elt) -> t -> t
-  val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
-  val for_all : (elt -> bool) -> t -> bool
-  val exists : (elt -> bool) -> t -> bool
-  val filter : (elt -> bool) -> t -> t
-  val partition : (elt -> bool) -> t -> t * t
-  val cardinal : t -> int
-  val elements : t -> elt list
-  val min_elt : t -> elt
-  val min_elt_opt : t -> elt option
-  val max_elt : t -> elt
-  val max_elt_opt : t -> elt option
-  val choose : t -> elt
-  val choose_opt : t -> elt option
-  val split : elt -> t -> t * bool * t
-  val find : elt -> t -> elt
-  val find_opt : elt -> t -> elt option
-  val find_first : (elt -> bool) -> t -> elt
-  val find_first_opt : (elt -> bool) -> t -> elt option
-  val find_last : (elt -> bool) -> t -> elt
-  val find_last_opt : (elt -> bool) -> t -> elt option
-  val of_seq : elt SequenceLabels.sequence -> SequenceLabels.t
-  val to_seq : SequenceLabels.t -> elt SequenceLabels.sequence
-  val to_list : SequenceLabels.t -> elt list
-  val of_list : elt list -> SequenceLabels.t
-end \ No newline at end of file diff --git a/api/type_SequenceLabels.Set.html b/api/type_SequenceLabels.Set.html deleted file mode 100644 index 142d356..0000000 --- a/api/type_SequenceLabels.Set.html +++ /dev/null @@ -1,147 +0,0 @@ - - - - - - - - - - - -SequenceLabels.Set - - -sig
-  module type S =
-    sig
-      type elt
-      type t
-      val empty : t
-      val is_empty : t -> bool
-      val mem : elt -> t -> bool
-      val add : elt -> t -> t
-      val singleton : elt -> t
-      val remove : elt -> t -> t
-      val union : t -> t -> t
-      val inter : t -> t -> t
-      val diff : t -> t -> t
-      val compare : t -> t -> int
-      val equal : t -> t -> bool
-      val subset : t -> t -> bool
-      val iter : (elt -> unit) -> t -> unit
-      val map : (elt -> elt) -> t -> t
-      val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
-      val for_all : (elt -> bool) -> t -> bool
-      val exists : (elt -> bool) -> t -> bool
-      val filter : (elt -> bool) -> t -> t
-      val partition : (elt -> bool) -> t -> t * t
-      val cardinal : t -> int
-      val elements : t -> elt list
-      val min_elt : t -> elt
-      val min_elt_opt : t -> elt option
-      val max_elt : t -> elt
-      val max_elt_opt : t -> elt option
-      val choose : t -> elt
-      val choose_opt : t -> elt option
-      val split : elt -> t -> t * bool * t
-      val find : elt -> t -> elt
-      val find_opt : elt -> t -> elt option
-      val find_first : (elt -> bool) -> t -> elt
-      val find_first_opt : (elt -> bool) -> t -> elt option
-      val find_last : (elt -> bool) -> t -> elt
-      val find_last_opt : (elt -> bool) -> t -> elt option
-      val of_seq : elt SequenceLabels.sequence -> SequenceLabels.t
-      val to_seq : SequenceLabels.t -> elt SequenceLabels.sequence
-      val to_list : SequenceLabels.t -> elt list
-      val of_list : elt list -> SequenceLabels.t
-    end
-  module Adapt :
-    functor (X : Set.S) ->
-      sig
-        type elt = X.elt
-        type t = X.t
-        val empty : t
-        val is_empty : t -> bool
-        val mem : elt -> t -> bool
-        val add : elt -> t -> t
-        val singleton : elt -> t
-        val remove : elt -> t -> t
-        val union : t -> t -> t
-        val inter : t -> t -> t
-        val diff : t -> t -> t
-        val compare : t -> t -> int
-        val equal : t -> t -> bool
-        val subset : t -> t -> bool
-        val iter : (elt -> unit) -> t -> unit
-        val map : (elt -> elt) -> t -> t
-        val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
-        val for_all : (elt -> bool) -> t -> bool
-        val exists : (elt -> bool) -> t -> bool
-        val filter : (elt -> bool) -> t -> t
-        val partition : (elt -> bool) -> t -> t * t
-        val cardinal : t -> int
-        val elements : t -> elt list
-        val min_elt : t -> elt
-        val min_elt_opt : t -> elt option
-        val max_elt : t -> elt
-        val max_elt_opt : t -> elt option
-        val choose : t -> elt
-        val choose_opt : t -> elt option
-        val split : elt -> t -> t * bool * t
-        val find : elt -> t -> elt
-        val find_opt : elt -> t -> elt option
-        val find_first : (elt -> bool) -> t -> elt
-        val find_first_opt : (elt -> bool) -> t -> elt option
-        val find_last : (elt -> bool) -> t -> elt
-        val find_last_opt : (elt -> bool) -> t -> elt option
-        val of_seq : elt sequence -> t
-        val to_seq : t -> elt sequence
-        val to_list : t -> elt list
-        val of_list : elt list -> t
-      end
-  module Make :
-    functor (X : Set.OrderedType) ->
-      sig
-        type elt = X.t
-        type t
-        val empty : t
-        val is_empty : t -> bool
-        val mem : elt -> t -> bool
-        val add : elt -> t -> t
-        val singleton : elt -> t
-        val remove : elt -> t -> t
-        val union : t -> t -> t
-        val inter : t -> t -> t
-        val diff : t -> t -> t
-        val compare : t -> t -> int
-        val equal : t -> t -> bool
-        val subset : t -> t -> bool
-        val iter : (elt -> unit) -> t -> unit
-        val map : (elt -> elt) -> t -> t
-        val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
-        val for_all : (elt -> bool) -> t -> bool
-        val exists : (elt -> bool) -> t -> bool
-        val filter : (elt -> bool) -> t -> t
-        val partition : (elt -> bool) -> t -> t * t
-        val cardinal : t -> int
-        val elements : t -> elt list
-        val min_elt : t -> elt
-        val min_elt_opt : t -> elt option
-        val max_elt : t -> elt
-        val max_elt_opt : t -> elt option
-        val choose : t -> elt
-        val choose_opt : t -> elt option
-        val split : elt -> t -> t * bool * t
-        val find : elt -> t -> elt
-        val find_opt : elt -> t -> elt option
-        val find_first : (elt -> bool) -> t -> elt
-        val find_first_opt : (elt -> bool) -> t -> elt option
-        val find_last : (elt -> bool) -> t -> elt
-        val find_last_opt : (elt -> bool) -> t -> elt option
-        val of_seq : elt sequence -> t
-        val to_seq : t -> elt sequence
-        val to_list : t -> elt list
-        val of_list : elt list -> t
-      end
-end \ No newline at end of file diff --git a/api/type_SequenceLabels.html b/api/type_SequenceLabels.html deleted file mode 100644 index 1d4e424..0000000 --- a/api/type_SequenceLabels.html +++ /dev/null @@ -1,576 +0,0 @@ - - - - - - - - - - - -SequenceLabels - - -sig
-  type 'a t = ('a -> unit) -> unit
-  type 'a sequence = 'a SequenceLabels.t
-  type ('a, 'b) t2 = ('a -> 'b -> unit) -> unit
-  type 'a equal = 'a -> 'a -> bool
-  type 'a hash = 'a -> int
-  val from_iter : (('a -> unit) -> unit) -> 'a SequenceLabels.t
-  val from_fun : (unit -> 'a option) -> 'a SequenceLabels.t
-  val empty : 'a SequenceLabels.t
-  val singleton : 'a -> 'a SequenceLabels.t
-  val doubleton : 'a -> 'a -> 'a SequenceLabels.t
-  val init : f:(int -> 'a) -> 'a SequenceLabels.t
-  val cons : 'a -> 'a SequenceLabels.t -> 'a SequenceLabels.t
-  val snoc : 'a SequenceLabels.t -> 'a -> 'a SequenceLabels.t
-  val return : 'a -> 'a SequenceLabels.t
-  val pure : 'a -> 'a SequenceLabels.t
-  val repeat : 'a -> 'a SequenceLabels.t
-  val iterate : ('a -> 'a) -> 'a -> 'a SequenceLabels.t
-  val forever : (unit -> 'b) -> 'b SequenceLabels.t
-  val cycle : 'a SequenceLabels.t -> 'a SequenceLabels.t
-  val iter : f:('a -> unit) -> 'a SequenceLabels.t -> unit
-  val iteri : f:(int -> 'a -> unit) -> 'a SequenceLabels.t -> unit
-  val fold : f:('a -> 'b -> 'a) -> init:'a -> 'b SequenceLabels.t -> 'a
-  val foldi :
-    f:('a -> int -> 'b -> 'a) -> init:'a -> 'b SequenceLabels.t -> 'a
-  val fold_map :
-    f:('acc -> 'a -> 'acc * 'b) ->
-    init:'acc -> 'a SequenceLabels.t -> 'b SequenceLabels.t
-  val fold_filter_map :
-    f:('acc -> 'a -> 'acc * 'b option) ->
-    init:'acc -> 'a SequenceLabels.t -> 'b SequenceLabels.t
-  val map : f:('a -> 'b) -> 'a SequenceLabels.t -> 'b SequenceLabels.t
-  val mapi :
-    f:(int -> 'a -> 'b) -> 'a SequenceLabels.t -> 'b SequenceLabels.t
-  val map_by_2 :
-    f:('a -> 'a -> 'a) -> 'a SequenceLabels.t -> 'a SequenceLabels.t
-  val for_all : f:('a -> bool) -> 'a SequenceLabels.t -> bool
-  val exists : f:('a -> bool) -> 'a SequenceLabels.t -> bool
-  val mem : ?eq:('a -> 'a -> bool) -> x:'a -> 'a SequenceLabels.t -> bool
-  val find : ('a -> 'b option) -> 'a SequenceLabels.t -> 'b option
-  val find_map : f:('a -> 'b option) -> 'a SequenceLabels.t -> 'b option
-  val findi : f:(int -> 'a -> 'b option) -> 'a SequenceLabels.t -> 'b option
-  val find_mapi :
-    f:(int -> 'a -> 'b option) -> 'a SequenceLabels.t -> 'b option
-  val find_pred : f:('a -> bool) -> 'a SequenceLabels.t -> 'a option
-  val find_pred_exn : f:('a -> bool) -> 'a SequenceLabels.t -> 'a
-  val length : 'a SequenceLabels.t -> int
-  val is_empty : 'a SequenceLabels.t -> bool
-  val filter : f:('a -> bool) -> 'a SequenceLabels.t -> 'a SequenceLabels.t
-  val append :
-    'a SequenceLabels.t -> 'a SequenceLabels.t -> 'a SequenceLabels.t
-  val append_l : 'a SequenceLabels.t list -> 'a SequenceLabels.t
-  val concat : 'a SequenceLabels.t SequenceLabels.t -> 'a SequenceLabels.t
-  val flatten : 'a SequenceLabels.t SequenceLabels.t -> 'a SequenceLabels.t
-  val flat_map :
-    f:('a -> 'b SequenceLabels.t) ->
-    'a SequenceLabels.t -> 'b SequenceLabels.t
-  val flat_map_l :
-    f:('a -> 'b list) -> 'a SequenceLabels.t -> 'b SequenceLabels.t
-  val filter_map :
-    f:('a -> 'b option) -> 'a SequenceLabels.t -> 'b SequenceLabels.t
-  val filter_mapi :
-    f:(int -> 'a -> 'b option) -> 'a SequenceLabels.t -> 'b SequenceLabels.t
-  val seq_list : 'a SequenceLabels.t list -> 'a list SequenceLabels.t
-  val seq_list_map :
-    f:('a -> 'b SequenceLabels.t) -> 'a list -> 'b list SequenceLabels.t
-  val intersperse : x:'a -> 'a SequenceLabels.t -> 'a SequenceLabels.t
-  val persistent : 'a SequenceLabels.t -> 'a SequenceLabels.t
-  val persistent_lazy : 'a SequenceLabels.t -> 'a SequenceLabels.t
-  val sort :
-    ?cmp:('a -> 'a -> int) -> 'a SequenceLabels.t -> 'a SequenceLabels.t
-  val sort_uniq :
-    ?cmp:('a -> 'a -> int) -> 'a SequenceLabels.t -> 'a SequenceLabels.t
-  val sorted : ?cmp:('a -> 'a -> int) -> 'a SequenceLabels.t -> bool
-  val group_succ_by :
-    ?eq:('a -> 'a -> bool) -> 'a SequenceLabels.t -> 'a list SequenceLabels.t
-  val group_by :
-    ?hash:('a -> int) ->
-    ?eq:('a -> 'a -> bool) -> 'a SequenceLabels.t -> 'a list SequenceLabels.t
-  val count :
-    ?hash:('a -> int) ->
-    ?eq:('a -> 'a -> bool) ->
-    'a SequenceLabels.t -> ('a * int) SequenceLabels.t
-  val uniq :
-    ?eq:('a -> 'a -> bool) -> 'a SequenceLabels.t -> 'a SequenceLabels.t
-  val product :
-    'a SequenceLabels.t -> 'b SequenceLabels.t -> ('a * 'b) SequenceLabels.t
-  val diagonal_l : 'a list -> ('a * 'a) SequenceLabels.t
-  val diagonal : 'a SequenceLabels.t -> ('a * 'a) SequenceLabels.t
-  val product2 :
-    'a SequenceLabels.t -> 'b SequenceLabels.t -> ('a, 'b) SequenceLabels.t2
-  val join :
-    join_row:('a -> 'b -> 'c option) ->
-    'a SequenceLabels.t -> 'b SequenceLabels.t -> 'c SequenceLabels.t
-  val join_by :
-    ?eq:'key SequenceLabels.equal ->
-    ?hash:'key SequenceLabels.hash ->
-    ('a -> 'key) ->
-    ('b -> 'key) ->
-    merge:('key -> 'a -> 'b -> 'c option) ->
-    'a SequenceLabels.t -> 'b SequenceLabels.t -> 'c SequenceLabels.t
-  val join_all_by :
-    ?eq:'key SequenceLabels.equal ->
-    ?hash:'key SequenceLabels.hash ->
-    ('a -> 'key) ->
-    ('b -> 'key) ->
-    merge:('key -> 'a list -> 'b list -> 'c option) ->
-    'a SequenceLabels.t -> 'b SequenceLabels.t -> 'c SequenceLabels.t
-  val group_join_by :
-    ?eq:'a SequenceLabels.equal ->
-    ?hash:'a SequenceLabels.hash ->
-    ('b -> 'a) ->
-    'a SequenceLabels.t ->
-    'b SequenceLabels.t -> ('a * 'b list) SequenceLabels.t
-  val inter :
-    ?eq:'a SequenceLabels.equal ->
-    ?hash:'a SequenceLabels.hash ->
-    'a SequenceLabels.t -> 'a SequenceLabels.t -> 'a SequenceLabels.t
-  val union :
-    ?eq:'a SequenceLabels.equal ->
-    ?hash:'a SequenceLabels.hash ->
-    'a SequenceLabels.t -> 'a SequenceLabels.t -> 'a SequenceLabels.t
-  val diff :
-    ?eq:'a SequenceLabels.equal ->
-    ?hash:'a SequenceLabels.hash ->
-    'a SequenceLabels.t -> 'a SequenceLabels.t -> 'a SequenceLabels.t
-  val subset :
-    ?eq:'a SequenceLabels.equal ->
-    ?hash:'a SequenceLabels.hash ->
-    'a SequenceLabels.t -> 'a SequenceLabels.t -> bool
-  val unfoldr : ('b -> ('a * 'b) option) -> 'b -> 'a SequenceLabels.t
-  val scan :
-    ('b -> 'a -> 'b) -> 'b -> 'a SequenceLabels.t -> 'b SequenceLabels.t
-  val max : ?lt:('a -> 'a -> bool) -> 'a SequenceLabels.t -> 'a option
-  val max_exn : ?lt:('a -> 'a -> bool) -> 'a SequenceLabels.t -> 'a
-  val min : ?lt:('a -> 'a -> bool) -> 'a SequenceLabels.t -> 'a option
-  val min_exn : ?lt:('a -> 'a -> bool) -> 'a SequenceLabels.t -> 'a
-  val sum : int SequenceLabels.t -> int
-  val sumf : float SequenceLabels.t -> float
-  val head : 'a SequenceLabels.t -> 'a option
-  val head_exn : 'a SequenceLabels.t -> 'a
-  val take : int -> 'a SequenceLabels.t -> 'a SequenceLabels.t
-  val take_while :
-    f:('a -> bool) -> 'a SequenceLabels.t -> 'a SequenceLabels.t
-  val fold_while :
-    f:('a -> 'b -> 'a * [ `Continue | `Stop ]) ->
-    init:'a -> 'b SequenceLabels.t -> 'a
-  val drop : int -> 'a SequenceLabels.t -> 'a SequenceLabels.t
-  val drop_while :
-    f:('a -> bool) -> 'a SequenceLabels.t -> 'a SequenceLabels.t
-  val rev : 'a SequenceLabels.t -> 'a SequenceLabels.t
-  val empty2 : ('a, 'b) SequenceLabels.t2
-  val is_empty2 : ('a, 'b) SequenceLabels.t2 -> bool
-  val length2 : ('a, 'b) SequenceLabels.t2 -> int
-  val zip : ('a, 'b) SequenceLabels.t2 -> ('a * 'b) SequenceLabels.t
-  val unzip : ('a * 'b) SequenceLabels.t -> ('a, 'b) SequenceLabels.t2
-  val zip_i : 'a SequenceLabels.t -> (int, 'a) SequenceLabels.t2
-  val fold2 :
-    f:('c -> 'a -> 'b -> 'c) -> init:'c -> ('a, 'b) SequenceLabels.t2 -> 'c
-  val iter2 : f:('a -> 'b -> unit) -> ('a, 'b) SequenceLabels.t2 -> unit
-  val map2 :
-    f:('a -> 'b -> 'c) -> ('a, 'b) SequenceLabels.t2 -> 'c SequenceLabels.t
-  val map2_2 :
-    ('a -> 'b -> 'c) ->
-    ('a -> 'b -> 'd) ->
-    ('a, 'b) SequenceLabels.t2 -> ('c, 'd) SequenceLabels.t2
-  val to_list : 'a SequenceLabels.t -> 'a list
-  val to_rev_list : 'a SequenceLabels.t -> 'a list
-  val of_list : 'a list -> 'a SequenceLabels.t
-  val on_list :
-    ('a SequenceLabels.t -> 'b SequenceLabels.t) -> 'a list -> 'b list
-  val pair_with_idx : 'a SequenceLabels.t -> (int * 'a) SequenceLabels.t
-  val to_opt : 'a SequenceLabels.t -> 'a option
-  val to_array : 'a SequenceLabels.t -> 'a array
-  val of_array : 'a array -> 'a SequenceLabels.t
-  val of_array_i : 'a array -> (int * 'a) SequenceLabels.t
-  val of_array2 : 'a array -> (int, 'a) SequenceLabels.t2
-  val array_slice : 'a array -> int -> int -> 'a SequenceLabels.t
-  val of_opt : 'a option -> 'a SequenceLabels.t
-  val of_stream : 'a Stream.t -> 'a SequenceLabels.t
-  val to_stream : 'a SequenceLabels.t -> 'a Stream.t
-  val to_stack : 'a Stack.t -> 'a SequenceLabels.t -> unit
-  val of_stack : 'a Stack.t -> 'a SequenceLabels.t
-  val to_queue : 'a Queue.t -> 'a SequenceLabels.t -> unit
-  val of_queue : 'a Queue.t -> 'a SequenceLabels.t
-  val hashtbl_add : ('a, 'b) Hashtbl.t -> ('a * 'b) SequenceLabels.t -> unit
-  val hashtbl_replace :
-    ('a, 'b) Hashtbl.t -> ('a * 'b) SequenceLabels.t -> unit
-  val to_hashtbl : ('a * 'b) SequenceLabels.t -> ('a, 'b) Hashtbl.t
-  val to_hashtbl2 : ('a, 'b) SequenceLabels.t2 -> ('a, 'b) Hashtbl.t
-  val of_hashtbl : ('a, 'b) Hashtbl.t -> ('a * 'b) SequenceLabels.t
-  val of_hashtbl2 : ('a, 'b) Hashtbl.t -> ('a, 'b) SequenceLabels.t2
-  val hashtbl_keys : ('a, 'b) Hashtbl.t -> 'a SequenceLabels.t
-  val hashtbl_values : ('a, 'b) Hashtbl.t -> 'b SequenceLabels.t
-  val of_str : string -> char SequenceLabels.t
-  val to_str : char SequenceLabels.t -> string
-  val concat_str : string SequenceLabels.t -> string
-  exception OneShotSequence
-  val of_in_channel : Pervasives.in_channel -> char SequenceLabels.t
-  val to_buffer : char SequenceLabels.t -> Buffer.t -> unit
-  val int_range : start:int -> stop:int -> int SequenceLabels.t
-  val int_range_dec : start:int -> stop:int -> int SequenceLabels.t
-  val int_range_by :
-    step:int -> start:int -> stop:int -> int SequenceLabels.t
-  val bools : bool SequenceLabels.t
-  val of_set :
-    (module Set.S with type elt = 'a and type t = 'b) ->
-    'b -> 'a SequenceLabels.t
-  val to_set :
-    (module Set.S with type elt = 'a and type t = 'b) ->
-    'a SequenceLabels.t -> 'b
-  type 'a gen = unit -> 'a option
-  type 'a klist = unit -> [ `Cons of 'a * 'a SequenceLabels.klist | `Nil ]
-  val of_gen : 'a SequenceLabels.gen -> 'a SequenceLabels.t
-  val to_gen : 'a SequenceLabels.t -> 'a SequenceLabels.gen
-  val of_klist : 'a SequenceLabels.klist -> 'a SequenceLabels.t
-  val to_klist : 'a SequenceLabels.t -> 'a SequenceLabels.klist
-  module Set :
-    sig
-      module type S =
-        sig
-          type elt
-          type t
-          val empty : t
-          val is_empty : t -> bool
-          val mem : elt -> t -> bool
-          val add : elt -> t -> t
-          val singleton : elt -> t
-          val remove : elt -> t -> t
-          val union : t -> t -> t
-          val inter : t -> t -> t
-          val diff : t -> t -> t
-          val compare : t -> t -> int
-          val equal : t -> t -> bool
-          val subset : t -> t -> bool
-          val iter : (elt -> unit) -> t -> unit
-          val map : (elt -> elt) -> t -> t
-          val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
-          val for_all : (elt -> bool) -> t -> bool
-          val exists : (elt -> bool) -> t -> bool
-          val filter : (elt -> bool) -> t -> t
-          val partition : (elt -> bool) -> t -> t * t
-          val cardinal : t -> int
-          val elements : t -> elt list
-          val min_elt : t -> elt
-          val min_elt_opt : t -> elt option
-          val max_elt : t -> elt
-          val max_elt_opt : t -> elt option
-          val choose : t -> elt
-          val choose_opt : t -> elt option
-          val split : elt -> t -> t * bool * t
-          val find : elt -> t -> elt
-          val find_opt : elt -> t -> elt option
-          val find_first : (elt -> bool) -> t -> elt
-          val find_first_opt : (elt -> bool) -> t -> elt option
-          val find_last : (elt -> bool) -> t -> elt
-          val find_last_opt : (elt -> bool) -> t -> elt option
-          val of_seq : elt SequenceLabels.sequence -> SequenceLabels.t
-          val to_seq : SequenceLabels.t -> elt SequenceLabels.sequence
-          val to_list : SequenceLabels.t -> elt list
-          val of_list : elt list -> SequenceLabels.t
-        end
-      module Adapt :
-        functor (X : Set.S) ->
-          sig
-            type elt = X.elt
-            type t = X.t
-            val empty : t
-            val is_empty : t -> bool
-            val mem : elt -> t -> bool
-            val add : elt -> t -> t
-            val singleton : elt -> t
-            val remove : elt -> t -> t
-            val union : t -> t -> t
-            val inter : t -> t -> t
-            val diff : t -> t -> t
-            val compare : t -> t -> int
-            val equal : t -> t -> bool
-            val subset : t -> t -> bool
-            val iter : (elt -> unit) -> t -> unit
-            val map : (elt -> elt) -> t -> t
-            val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
-            val for_all : (elt -> bool) -> t -> bool
-            val exists : (elt -> bool) -> t -> bool
-            val filter : (elt -> bool) -> t -> t
-            val partition : (elt -> bool) -> t -> t * t
-            val cardinal : t -> int
-            val elements : t -> elt list
-            val min_elt : t -> elt
-            val min_elt_opt : t -> elt option
-            val max_elt : t -> elt
-            val max_elt_opt : t -> elt option
-            val choose : t -> elt
-            val choose_opt : t -> elt option
-            val split : elt -> t -> t * bool * t
-            val find : elt -> t -> elt
-            val find_opt : elt -> t -> elt option
-            val find_first : (elt -> bool) -> t -> elt
-            val find_first_opt : (elt -> bool) -> t -> elt option
-            val find_last : (elt -> bool) -> t -> elt
-            val find_last_opt : (elt -> bool) -> t -> elt option
-            val of_seq : elt sequence -> t
-            val to_seq : t -> elt sequence
-            val to_list : t -> elt list
-            val of_list : elt list -> t
-          end
-      module Make :
-        functor (X : Set.OrderedType) ->
-          sig
-            type elt = X.t
-            type t
-            val empty : t
-            val is_empty : t -> bool
-            val mem : elt -> t -> bool
-            val add : elt -> t -> t
-            val singleton : elt -> t
-            val remove : elt -> t -> t
-            val union : t -> t -> t
-            val inter : t -> t -> t
-            val diff : t -> t -> t
-            val compare : t -> t -> int
-            val equal : t -> t -> bool
-            val subset : t -> t -> bool
-            val iter : (elt -> unit) -> t -> unit
-            val map : (elt -> elt) -> t -> t
-            val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
-            val for_all : (elt -> bool) -> t -> bool
-            val exists : (elt -> bool) -> t -> bool
-            val filter : (elt -> bool) -> t -> t
-            val partition : (elt -> bool) -> t -> t * t
-            val cardinal : t -> int
-            val elements : t -> elt list
-            val min_elt : t -> elt
-            val min_elt_opt : t -> elt option
-            val max_elt : t -> elt
-            val max_elt_opt : t -> elt option
-            val choose : t -> elt
-            val choose_opt : t -> elt option
-            val split : elt -> t -> t * bool * t
-            val find : elt -> t -> elt
-            val find_opt : elt -> t -> elt option
-            val find_first : (elt -> bool) -> t -> elt
-            val find_first_opt : (elt -> bool) -> t -> elt option
-            val find_last : (elt -> bool) -> t -> elt
-            val find_last_opt : (elt -> bool) -> t -> elt option
-            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 min_binding_opt : 'a t -> (key * 'a) option
-          val max_binding : 'a t -> key * 'a
-          val max_binding_opt : 'a t -> (key * 'a) option
-          val choose : 'a t -> key * 'a
-          val choose_opt : 'a t -> (key * 'a) option
-          val split : key -> 'a t -> 'a t * 'a option * 'a t
-          val find : key -> 'a t -> 'a
-          val find_opt : key -> 'a t -> 'a option
-          val find_first : (key -> bool) -> 'a t -> key * 'a
-          val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option
-          val find_last : (key -> bool) -> 'a t -> key * 'a
-          val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option
-          val map : ('a -> 'b) -> 'a t -> 'b t
-          val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
-          val to_seq :
-            'a SequenceLabels.t -> (key * 'a) SequenceLabels.sequence
-          val of_seq :
-            (key * 'a) SequenceLabels.sequence -> 'a SequenceLabels.t
-          val keys : 'a SequenceLabels.t -> key SequenceLabels.sequence
-          val values : 'a SequenceLabels.t -> 'a SequenceLabels.sequence
-          val to_list : 'a SequenceLabels.t -> (key * 'a) list
-          val of_list : (key * 'a) list -> 'a SequenceLabels.t
-        end
-      module Adapt :
-        functor (M : Map.S) ->
-          sig
-            type key = M.key
-            type 'a t = 'a M.t
-            val empty : 'a t
-            val is_empty : 'a t -> bool
-            val mem : key -> 'a t -> bool
-            val add : key -> 'a -> 'a t -> 'a t
-            val singleton : key -> 'a -> 'a t
-            val remove : key -> 'a t -> 'a t
-            val merge :
-              (key -> 'a option -> 'b option -> 'c option) ->
-              'a t -> 'b t -> 'c t
-            val union :
-              (key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
-            val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
-            val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
-            val iter : (key -> 'a -> unit) -> 'a t -> unit
-            val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
-            val for_all : (key -> 'a -> bool) -> 'a t -> bool
-            val exists : (key -> 'a -> bool) -> 'a t -> bool
-            val filter : (key -> 'a -> bool) -> 'a t -> 'a t
-            val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
-            val cardinal : 'a t -> int
-            val bindings : 'a t -> (key * 'a) list
-            val min_binding : 'a t -> key * 'a
-            val min_binding_opt : 'a t -> (key * 'a) option
-            val max_binding : 'a t -> key * 'a
-            val max_binding_opt : 'a t -> (key * 'a) option
-            val choose : 'a t -> key * 'a
-            val choose_opt : 'a t -> (key * 'a) option
-            val split : key -> 'a t -> 'a t * 'a option * 'a t
-            val find : key -> 'a t -> 'a
-            val find_opt : key -> 'a t -> 'a option
-            val find_first : (key -> bool) -> 'a t -> key * 'a
-            val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option
-            val find_last : (key -> bool) -> 'a t -> key * 'a
-            val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option
-            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 min_binding_opt : 'a t -> (key * 'a) option
-            val max_binding : 'a t -> key * 'a
-            val max_binding_opt : 'a t -> (key * 'a) option
-            val choose : 'a t -> key * 'a
-            val choose_opt : 'a t -> (key * 'a) option
-            val split : key -> 'a t -> 'a t * 'a option * 'a t
-            val find : key -> 'a t -> 'a
-            val find_opt : key -> 'a t -> 'a option
-            val find_first : (key -> bool) -> 'a t -> key * 'a
-            val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option
-            val find_last : (key -> bool) -> 'a t -> key * 'a
-            val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option
-            val map : ('a -> 'b) -> 'a t -> 'b t
-            val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
-            val to_seq : 'a t -> (key * 'a) sequence
-            val of_seq : (key * 'a) sequence -> 'a t
-            val keys : 'a t -> key sequence
-            val values : 'a t -> 'a sequence
-            val to_list : 'a t -> (key * 'a) list
-            val of_list : (key * 'a) list -> 'a t
-          end
-    end
-  val random_int : int -> int SequenceLabels.t
-  val random_bool : bool SequenceLabels.t
-  val random_float : float -> float SequenceLabels.t
-  val random_array : 'a array -> 'a SequenceLabels.t
-  val random_list : 'a list -> 'a SequenceLabels.t
-  val shuffle : 'a SequenceLabels.t -> 'a SequenceLabels.t
-  val shuffle_buffer : n:int -> 'a SequenceLabels.t -> 'a SequenceLabels.t
-  val sample : n:int -> 'a SequenceLabels.t -> 'a array
-  module Infix :
-    sig
-      val ( -- ) : int -> int -> int SequenceLabels.t
-      val ( --^ ) : int -> int -> int SequenceLabels.t
-      val ( >>= ) :
-        'a SequenceLabels.t ->
-        ('a -> 'b SequenceLabels.t) -> 'b SequenceLabels.t
-      val ( >|= ) : 'a SequenceLabels.t -> ('a -> 'b) -> 'b SequenceLabels.t
-      val ( <*> ) :
-        ('a -> 'b) SequenceLabels.t ->
-        'a SequenceLabels.t -> 'b SequenceLabels.t
-      val ( <+> ) :
-        'a SequenceLabels.t -> 'a SequenceLabels.t -> 'a SequenceLabels.t
-    end
-  val ( -- ) : int -> int -> int t
-  val ( --^ ) : int -> int -> int t
-  val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
-  val ( >|= ) : 'a t -> ('a -> 'b) -> 'b t
-  val ( <*> ) : ('a -> 'b) t -> 'a t -> 'b t
-  val ( <+> ) : 'a t -> 'a t -> 'a t
-  val pp_seq :
-    ?sep:string ->
-    (Format.formatter -> 'a -> unit) ->
-    Format.formatter -> 'a SequenceLabels.t -> unit
-  val pp_buf :
-    ?sep:string ->
-    (Buffer.t -> 'a -> unit) -> Buffer.t -> 'a SequenceLabels.t -> unit
-  val to_string :
-    ?sep:string -> ('a -> string) -> 'a SequenceLabels.t -> string
-  module IO :
-    sig
-      val lines_of :
-        ?mode:int ->
-        ?flags:Pervasives.open_flag list -> string -> string SequenceLabels.t
-      val chunks_of :
-        ?mode:int ->
-        ?flags:Pervasives.open_flag list ->
-        ?size:int -> string -> string SequenceLabels.t
-      val write_to :
-        ?mode:int ->
-        ?flags:Pervasives.open_flag list ->
-        string -> string SequenceLabels.t -> unit
-      val write_bytes_to :
-        ?mode:int ->
-        ?flags:Pervasives.open_flag list ->
-        string -> Bytes.t SequenceLabels.t -> unit
-      val write_lines :
-        ?mode:int ->
-        ?flags:Pervasives.open_flag list ->
-        string -> string SequenceLabels.t -> unit
-      val write_bytes_lines :
-        ?mode:int ->
-        ?flags:Pervasives.open_flag list ->
-        string -> Bytes.t SequenceLabels.t -> unit
-    end
-end \ No newline at end of file diff --git a/images/bg_hr.png b/images/bg_hr.png deleted file mode 100644 index 7973bd6..0000000 Binary files a/images/bg_hr.png and /dev/null differ diff --git a/images/blacktocat.png b/images/blacktocat.png deleted file mode 100644 index 6e264fe..0000000 Binary files a/images/blacktocat.png and /dev/null differ diff --git a/images/icon_download.png b/images/icon_download.png deleted file mode 100644 index a2a287f..0000000 Binary files a/images/icon_download.png and /dev/null differ diff --git a/images/sprite_download.png b/images/sprite_download.png deleted file mode 100644 index f2babd5..0000000 Binary files a/images/sprite_download.png and /dev/null differ diff --git a/index.html b/index.html index bdbdbcb..f7c1c18 100644 --- a/index.html +++ b/index.html @@ -1,50 +1,17 @@ - - + - - - - - - - Sequence + index + + + - - - -
-
- View on GitHub - -

Sequence

-

Simple sequence abstract datatype, intented to transfer a finite number of elements from one data structure to another.

- -
- Download this project as a .zip file - Download this project as a tar.gz file -
-
-
- - -
-
-

Sequence

- Here is the documentation generated from the source. -
-
- - - - - - - - +
+

OCaml package documentation

+
    +
  1. sequence 1.0
    2. +
  2. sequence.bigarray 1.0
    3. +
+ + diff --git a/javascripts/main.js b/javascripts/main.js deleted file mode 100644 index d8135d3..0000000 --- a/javascripts/main.js +++ /dev/null @@ -1 +0,0 @@ -console.log('This would be the main JS file.'); diff --git a/odoc.css b/odoc.css new file mode 100644 index 0000000..e780892 --- /dev/null +++ b/odoc.css @@ -0,0 +1,234 @@ +@charset "UTF-8"; +/* Copyright (c) 2016 Daniel C. Bünzli. All rights reserved. + Distributed under the ISC license, see terms at the end of the file. + odoc 1.2.0 */ + +/* Reset a few things. */ + +html,body,div,span,applet,object,iframe,h1,h2,h3,h4,h5,h6,p,blockquote,pre, +a,abbr,acronym,address,big,cite,code,del,dfn,em,img,ins,kbd,q,s,samp, +small,strike,strong,sub,sup,tt,var,b,u,i,center,dl,dt,dd,ol,ul,li, +fieldset,form,label,legend,table,caption,tbody,tfoot,thead,tr,th,td, +article,aside,canvas,details,embed,figure,figcaption,footer,header,hgroup, +menu,nav,output,ruby,section,summary,time,mark,audio,video +{ margin:0; padding:0; border:0; /* outline: 0; */ + font-size:100%; font: inherit; line-height:inherit; vertical-align:baseline; + text-align: inherit; color: inherit; background: transparent; } + +table { border-collapse: collapse; border-spacing: 0; } +*, *:before, *:after { box-sizing: border-box; } + +body +{ font-family: Helvetica, "DejaVu Sans", Arial, sans-serif; + font-weight: normal; + font-size: 0.875rem; + line-height:1.25rem; + text-align: left; + min-width: 40ex; + max-width: 78ex; + padding: 1.25rem; + margin-left: 3.75rem; + color: #222; background: #FAFAFA; } + +/* Basic markup elements */ + +b, strong { font-weight: bold; } +em { font-style: italic; } + +sup { vertical-align: super; } +sub { vertical-align: sub; } +sup, sub { font-size : 0.75rem; line-height: 0; margin-left: 0.2ex; } + +p, div, img { margin-top: 1.25rem; } + +ul, ol +{ margin-top: 0.625rem; margin-bottom: 0.625rem; list-style-position: outside } + +ul { list-style-type: square } +ul > li { margin-left: 1.375rem; } +ol > li { margin-left: 1.7rem; } +li > *:first-child { margin-top: 0 } + +/* Text alignements, this should be forbidden. */ + +.left { text-align: left; } +.right { text-align: right; } +.center { text-align: center; } + +/* Links and anchors */ + +a { text-decoration:none; color:#2C5CBD; } +a:hover { box-shadow:0 1px 0 0 #2C5CBD; } +*:target /* Linked highlight */ +{ background-color: #FFF8E5; + box-shadow: 0 0 0 2px #FFF8E5, 0 0 0 3px #DDD; } + +.spec:hover > a.anchor, /* FIXME remove */ +.anchored:hover a.anchor { visibility: visible; } + +a.anchor:before { content: "#" } +a.anchor:hover { box-shadow: none; text-decoration: underline } +a.anchor +{ visibility: hidden; position: absolute; /* top: 0px; */ + margin-left: -3ex; + font-weight: normal; + font-style: normal; + padding-right: 1ex; padding-left: 1ex; /* To remain selectable */ + color: #AAA; } + +.xref-unresolved { box-shadow:0 1px 0 0 red } + +/* Section and document divisions. + Until at least 4.03 many of the modules of the stdlib start at .h7, + we restart the sequence there like h2 */ + +h1, h2, h3, h4, h5, h6, .h7, .h8, .h9, .h10 +{ font-weight: bold; margin-top: 1.25rem; } + +h1 + *, h2 + *, .h7 + * { margin-top: 0.625rem; } +h1, h2, .h7 +{ font-size: 1.25rem; + line-height: 2.4375rem; /* 2.5rem - border width */ + padding-top: 0.625rem; + border-top: solid; + border-width: 1px; + border-color: #DDD; } + +h3, .h8 { font-size: 1.125rem; } +h2 + h3, .h7 + .h8 { margin-top: 0.625rem; } + +/* Preformatted and code */ + +tt, code, pre +{ font-family: Menlo, "DejaVu Sans Mono", "Bitstream Vera Sans Mono", + monospace; + font-weight: normal; + font-size: 0.75rem; } + +pre +{ padding-left: 0.25rem; padding-right: 0.25rem; + margin-left: -0.25rem; margin-right: -0.25rem; + padding-top: 0.3125rem; padding-bottom: 0.3125rem; + margin-top: 1.25rem; /* margin-bottom: 0.625rem; */ + line-height: 1.1875rem; + background: #F1F1F1; } + +h1 tt, h1 code, h2 tt, h2 code, .h7 tt, .h7 code { font-size: 1.125rem } +h3 tt, h3 code { font-size: 1rem } + +/* Code lexemes */ + +.keyword { font-weight: bold; } + +/* Module member specification */ + +div.def { margin-top: 0rem; text-indent: -2ex; padding-left: 2ex; } +div.def + div.doc { margin-left: 1ex; margin-top: 0.15625rem } +div.doc > *:first-child { margin-top: 0rem; } + +/* Collapsible inlined include and module */ + +details +{ border-radius: 0.5rem; + border-left: 0.2rem solid; + border-color: #FAFAFA /* Background */; + margin-left: -1.5rem; + padding-left: 1.3rem; + padding-bottom: 0.625rem; } + +details[open] { border-color: #AAA; } + +/* Records and variants FIXME */ + +div.def table { text-indent: 0em; padding:0; margin-left: -2ex; } +td.def { padding-right: 2ex } +.record td.def { padding-left:2ex; } +td.doc *:first-child { margin-top: 0em } + +/* @ tags */ + +ul.at-tag { list-style-type: none; margin-left: 0; padding: 0; } +ul.at-tag li { margin-left:0; padding:0; } +ul.at-tag li p:first-child { margin-top: 0 } /* FIXME remove */ +span.at-tag { font-weight: bold } +.at-tag.deprecated { font-weight: normal; color: crimson } +.at-tag.raise { font-weight: bold; } + +/* FIXME random other things to review. */ + +.heading +{ margin-top: 0.625rem; + border-top: solid; + border-width: 1px; + border-color: #DDD; + text-align: right; + font-weight: normal; + font-style: italic; } + +.heading + .sig { margin-top: -1.25rem; } +.heading + .parameters { margin-top: -1.25rem; } + +/* Odig package index */ + +.by-name ol, .by-tag ol, .errors ol { list-style-type: none; margin-left:0; } +.by-name ol ol, .by-tag ol ol { margin-top:0; margin-bottom: 0 } +.by-name li, .by-tag li, .errors li { margin-left:0; } + +.by-name .version { font-size: 0.625rem; color: #AAA } +.by-name nav { margin-bottom: 0.625rem } +.by-name nav a +{ text-transform: uppercase; font-size: 1.125rem; + margin-right:1ex; color: #222; display: inline-block; } + +.by-tag nav a { margin-right:1ex; color: #222; display: inline-block; } +.by-tag > ol > li { margin-top: 0.625rem; } +.by-tag > ol > li > span, +.by-tag > ol > li > ol, +.by-tag > ol > li > ol > li { display: inline-block; margin-right: 1ex; } + +/* Odig package page */ + +.package nav { display: inline; font-size: 0.875rem; font-weight: normal; } +.package .version { font-size: 0.875rem; } + +h1 + .modules, h1 + .sel { margin-top: 0.625rem } +.sel { font-weight: normal; font-style: italic; + font-size:0.875rem; margin-top:1.25rem; } +.sel + .modules { margin-top:0.625rem; + margin-bottom: 1.25rem; margin-left: 1ex; } + +.modules { margin:0; } +.modules .module { min-width:8ex; padding-right: 2ex } + +.package.info { margin: 0;} +.package.info td:first-child { font-style: italic; padding-right: 2ex; } +.package.info ul { list-style-type: none; display: inline; margin:0; } +.package.info li { display: inline-block; margin:0; margin-right:1ex; } +#info-authors li, #info-maintainers li { display:block; } + +/* Mobile adjustements. */ + +@media only screen and (max-width: 78ex) +{ body { margin: auto; } } + +/* Print adjustements. */ + +@media print +{ body { color: black; background: white; } + body nav:first-child { visibility: hidden; }} + +/*--------------------------------------------------------------------------- + Copyright (c) 2016 Daniel C. Bünzli + + Permission to use, copy, modify, and/or distribute this software for any + purpose with or without fee is hereby granted, provided that the above + copyright notice and this permission notice appear in all copies. + + THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + ---------------------------------------------------------------------------*/ diff --git a/params.json b/params.json deleted file mode 100644 index 519ed4a..0000000 --- a/params.json +++ /dev/null @@ -1 +0,0 @@ -{"name":"Sequence","tagline":"Simple sequence abstract datatype, intented to transfer a finite number of elements from one data structure to another.","body":"## Sequence","google":"","note":"Don't delete this file! It's used internally to help with page regeneration."} \ No newline at end of file diff --git a/sequence.bigarray/SequenceBigarray/.jbuilder-keep b/sequence.bigarray/SequenceBigarray/.jbuilder-keep new file mode 100644 index 0000000..e69de29 diff --git a/sequence.bigarray/SequenceBigarray/index.html b/sequence.bigarray/SequenceBigarray/index.html new file mode 100644 index 0000000..00020c8 --- /dev/null +++ b/sequence.bigarray/SequenceBigarray/index.html @@ -0,0 +1,2 @@ + +SequenceBigarray (sequence.bigarray.SequenceBigarray)

Module SequenceBigarray

Interface and Helpers for bigarrays

val of_bigarray : ('a, _, _) Bigarray.Array1.t ‑> 'a Sequence.t

Iterate on the elements of a 1-D array

val mmap : string ‑> char Sequence.t

Map the file into memory, and read the characters.

\ No newline at end of file diff --git a/sequence.bigarray/index.html b/sequence.bigarray/index.html new file mode 100644 index 0000000..546ff19 --- /dev/null +++ b/sequence.bigarray/index.html @@ -0,0 +1,3 @@ + +sequence_bigarray-generated (sequence.bigarray.sequence_bigarray-generated)

Library sequence.bigarray

+This library exposes the following toplevel modules:

SequenceBigarray

.

\ No newline at end of file diff --git a/sequence/Sequence/.jbuilder-keep b/sequence/Sequence/.jbuilder-keep new file mode 100644 index 0000000..e69de29 diff --git a/sequence/Sequence/IO/index.html b/sequence/Sequence/IO/index.html new file mode 100644 index 0000000..8f33384 --- /dev/null +++ b/sequence/Sequence/IO/index.html @@ -0,0 +1,11 @@ + +IO (sequence.Sequence.IO)

Module Sequence.IO

val lines_of : ?⁠mode:int ‑> ?⁠flags:Pervasives.open_flag list ‑> string ‑> string t

lines_of filename reads all lines of the given file. It raises the +same exception as would opening the file and read from it, except +from End_of_file (which is caught). The file is always properly +closed. +Every time the sequence is iterated on, the file is opened again, so +different iterations might return different results

  • Parameter mode: default 0o644
  • Parameter flags: default: [Open_rdonly]
val chunks_of : ?⁠mode:int ‑> ?⁠flags:Pervasives.open_flag list ‑> ?⁠size:int ‑> string ‑> string t

Read chunks of the given size from the file. The last chunk might be +smaller. Behaves like lines_of regarding errors and options. +Every time the sequence is iterated on, the file is opened again, so +different iterations might return different results

val write_to : ?⁠mode:int ‑> ?⁠flags:Pervasives.open_flag list ‑> string ‑> string t ‑> unit

write_to filename seq writes all strings from seq into the given +file. It takes care of opening and closing the file.

  • Parameter mode: default 0o644
  • Parameter flags: used by open_out_gen. Default: [Open_creat;Open_wronly].
val write_bytes_to : ?⁠mode:int ‑> ?⁠flags:Pervasives.open_flag list ‑> string ‑> Bytes.t t ‑> unit
  • Since: 0.5.4
val write_lines : ?⁠mode:int ‑> ?⁠flags:Pervasives.open_flag list ‑> string ‑> string t ‑> unit

Same as write_to, but intercales '\n' between each string

val write_bytes_lines : ?⁠mode:int ‑> ?⁠flags:Pervasives.open_flag list ‑> string ‑> Bytes.t t ‑> unit
  • Since: 0.5.4
\ No newline at end of file diff --git a/sequence/Sequence/Infix/index.html b/sequence/Sequence/Infix/index.html new file mode 100644 index 0000000..6f3099e --- /dev/null +++ b/sequence/Sequence/Infix/index.html @@ -0,0 +1,5 @@ + +Infix (sequence.Sequence.Infix)

Module Sequence.Infix

val (--) : int ‑> int ‑> int 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 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 t ‑> ('a ‑> 'b t) ‑> 'b t

Monadic bind (infix version of flat_map

  • Since: 0.5
val (>|=) : 'a t ‑> ('a ‑> 'b) ‑> 'b t

Infix version of map

  • Since: 0.5
val (<*>) : ('a ‑> 'b) t ‑> 'a t ‑> 'b t

Applicative operator (product+application)

  • Since: 0.5
val (<+>) : 'a t ‑> 'a t ‑> 'a t

Concatenation of sequences

  • Since: 0.5
\ No newline at end of file diff --git a/sequence/Sequence/Map/index.html b/sequence/Sequence/Map/index.html new file mode 100644 index 0000000..5091f29 --- /dev/null +++ b/sequence/Sequence/Map/index.html @@ -0,0 +1,2 @@ + +Map (sequence.Sequence.Map)

Module Sequence.Map

module type S : sig ... end
module Adapt : functor (M : Map.S) -> S with type Adapt.key = M.key and type 'a Adapt.t = 'a M.t

Adapt a pre-existing Map module to make it sequence-aware

module Make : functor (V : Map.OrderedType) -> S with type Make.key = V.t

Create an enriched Map module, with sequence-aware functions

\ No newline at end of file diff --git a/sequence/Sequence/Map/module-type-S/index.html b/sequence/Sequence/Map/module-type-S/index.html new file mode 100644 index 0000000..95ff158 --- /dev/null +++ b/sequence/Sequence/Map/module-type-S/index.html @@ -0,0 +1,2 @@ + +S (sequence.Sequence.Map.S)

Module type Sequence.Map.S

include Map.S
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 min_binding_opt : 'a t ‑> (key * 'a) option
val max_binding : 'a t ‑> key * 'a
val max_binding_opt : 'a t ‑> (key * 'a) option
val choose : 'a t ‑> key * 'a
val choose_opt : 'a t ‑> (key * 'a) option
val split : key ‑> 'a t ‑> 'a t * 'a option * 'a t
val find : key ‑> 'a t ‑> 'a
val find_opt : key ‑> 'a t ‑> 'a option
val find_first : (key ‑> bool) ‑> 'a t ‑> key * 'a
val find_first_opt : (key ‑> bool) ‑> 'a t ‑> (key * 'a) option
val find_last : (key ‑> bool) ‑> 'a t ‑> key * 'a
val find_last_opt : (key ‑> bool) ‑> 'a t ‑> (key * 'a) option
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
\ No newline at end of file diff --git a/sequence/Sequence/Set/index.html b/sequence/Sequence/Set/index.html new file mode 100644 index 0000000..a456ff9 --- /dev/null +++ b/sequence/Sequence/Set/index.html @@ -0,0 +1,2 @@ + +Set (sequence.Sequence.Set)

Module Sequence.Set

module type S : sig ... end
module Adapt : functor (X : Set.S) -> S with type Adapt.elt = X.elt and type Adapt.t = X.t

Create an enriched Set module from the given one

module Make : functor (X : Set.OrderedType) -> S with type Make.elt = X.t

Functor to build an extended Set module from an ordered type

\ No newline at end of file diff --git a/sequence/Sequence/Set/module-type-S/index.html b/sequence/Sequence/Set/module-type-S/index.html new file mode 100644 index 0000000..4ed4401 --- /dev/null +++ b/sequence/Sequence/Set/module-type-S/index.html @@ -0,0 +1,2 @@ + +S (sequence.Sequence.Set.S)

Module type Sequence.Set.S

include Set.S
type elt
type t
val empty : t
val is_empty : t ‑> bool
val mem : elt ‑> t ‑> bool
val add : elt ‑> t ‑> t
val singleton : elt ‑> t
val remove : elt ‑> t ‑> t
val union : t ‑> t ‑> t
val inter : t ‑> t ‑> t
val diff : t ‑> t ‑> t
val compare : t ‑> t ‑> int
val equal : t ‑> t ‑> bool
val subset : t ‑> t ‑> bool
val iter : (elt ‑> unit) ‑> t ‑> unit
val map : (elt ‑> elt) ‑> t ‑> t
val fold : (elt ‑> 'a ‑> 'a) ‑> t ‑> 'a ‑> 'a
val for_all : (elt ‑> bool) ‑> t ‑> bool
val exists : (elt ‑> bool) ‑> t ‑> bool
val filter : (elt ‑> bool) ‑> t ‑> t
val partition : (elt ‑> bool) ‑> t ‑> t * t
val cardinal : t ‑> int
val elements : t ‑> elt list
val min_elt : t ‑> elt
val min_elt_opt : t ‑> elt option
val max_elt : t ‑> elt
val max_elt_opt : t ‑> elt option
val choose : t ‑> elt
val choose_opt : t ‑> elt option
val split : elt ‑> t ‑> t * bool * t
val find : elt ‑> t ‑> elt
val find_opt : elt ‑> t ‑> elt option
val find_first : (elt ‑> bool) ‑> t ‑> elt
val find_first_opt : (elt ‑> bool) ‑> t ‑> elt option
val find_last : (elt ‑> bool) ‑> t ‑> elt
val find_last_opt : (elt ‑> bool) ‑> t ‑> elt option
val of_list : elt list ‑> t
val of_seq : elt sequence ‑> t
val to_seq : t ‑> elt sequence
val to_list : t ‑> elt list
val of_list : elt list ‑> t
\ No newline at end of file diff --git a/sequence/Sequence/index.html b/sequence/Sequence/index.html new file mode 100644 index 0000000..2ddc4f7 --- /dev/null +++ b/sequence/Sequence/index.html @@ -0,0 +1,126 @@ + +Sequence (sequence.Sequence)

Module Sequence

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 +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 persistent +function is provided, storing elements of a transient iterator +in memory; the iterator can then be used several times (See further).

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, +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 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 t object is also repeatable. For one-time iter functions +such as iteration on a file descriptor or a Stream, +the 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

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

NOTE Type ('a, 'b) t2 = ('a -> 'b -> unit) -> unit +has been removed and subsumed by ('a * 'b) t

type 'a equal = 'a ‑> 'a ‑> bool
type 'a hash = 'a ‑> int

Build a sequence

val from_iter : (('a ‑> unit) ‑> unit) ‑> 'a t

Build a sequence from a iter function

val from_fun : (unit ‑> 'a option) ‑> 'a t

Call the function repeatedly until it returns None. This +sequence is transient, use persistent if needed!

val empty : 'a t

Empty sequence. It contains no element.

val singleton : 'a ‑> 'a t

Singleton sequence, with exactly one element.

val doubleton : 'a ‑> 'a ‑> 'a t

Sequence with exactly two elements

val init : (int ‑> 'a) ‑> 'a t

init f is the infinite sequence f 0; f 1; f 2; ….

  • Since: 0.9
val cons : 'a ‑> 'a t ‑> 'a t

cons x l yields x, then yields from l. +Same as append (singleton x) l

val snoc : 'a t ‑> 'a ‑> 'a t

Same as cons but yields the element after iterating on l

val return : 'a ‑> 'a t

Synonym to singleton

val pure : 'a ‑> 'a t

Synonym to singleton

val repeat : 'a ‑> 'a t

Infinite sequence of the same element. You may want to look +at 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 take and 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 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. +Basically iter f seq is just seq f.

val iteri : (int ‑> 'a ‑> unit) ‑> 'a t ‑> unit

Iterate on elements and their index in the sequence

val fold : ('a ‑> 'b ‑> 'a) ‑> 'a ‑> 'b t ‑> 'a

Fold over elements of the sequence, consuming it

val foldi : ('a ‑> int ‑> 'b ‑> 'a) ‑> 'a ‑> 'b t ‑> 'a

Fold over elements of the sequence and their index, consuming it

val fold_map : ('acc ‑> 'a ‑> 'acc * 'b) ‑> 'acc ‑> 'a t ‑> 'b t

fold_map f acc l is like map, but it carries some state as in +fold. The state is not returned, it is just used to thread some +information to the map function.

  • Since: 0.9
val fold_filter_map : ('acc ‑> 'a ‑> 'acc * 'b option) ‑> 'acc ‑> 'a t ‑> 'b t

fold_filter_map f acc l is a fold_map-like function, but the +function can choose to skip an element by retuning None.

  • Since: 0.9
val map : ('a ‑> 'b) ‑> 'a t ‑> 'b t

Map objects of the sequence into other elements, lazily

val mapi : (int ‑> 'a ‑> 'b) ‑> 'a t ‑> 'b t

Map objects, along with their index in the sequence

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

Exists there some element satisfying the predicate?

val mem : ?⁠eq:('a ‑> 'a ‑> bool) ‑> 'a ‑> 'a t ‑> bool

Is the value a member of the sequence?

  • Parameter eq: the equality predicate to use (default (=))
  • Since: 0.5
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 find_map : ('a ‑> 'b option) ‑> 'a t ‑> 'b option

Alias to find

  • Since: 0.10
val findi : (int ‑> 'a ‑> 'b option) ‑> 'a t ‑> 'b option

Indexed version of find

  • Since: 0.9
val find_mapi : (int ‑> 'a ‑> 'b option) ‑> 'a t ‑> 'b option

Alias to findi

  • Since: 0.10
val find_pred : ('a ‑> bool) ‑> 'a t ‑> 'a option

find_pred p l finds the first element of l that satisfies p, +or returns None if no element satisfies p

  • Since: 0.9
val find_pred_exn : ('a ‑> bool) ‑> 'a t ‑> 'a

Unsafe version of find_pred

  • Raises Not_found: if no such element is found
  • Since: 0.9
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

Filter on elements of the sequence

val append : 'a t ‑> 'a t ‑> 'a t

Append two sequences. Iterating on the result is like iterating +on the first, then on the second.

val append_l : 'a t list ‑> 'a t

Append sequences. Iterating on the result is like iterating +on the each sequence of the list in order.

  • Since: 0.11
val concat : 'a t t ‑> 'a t

Concatenate a sequence of sequences into one sequence.

val flatten : 'a t t ‑> 'a t

Alias for 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 concat. +Formerly flatMap

  • Since: 0.5
val flat_map_l : ('a ‑> 'b list) ‑> 'a t ‑> 'b t

Convenience function combining flat_map and of_list

  • Since: 0.9
val seq_list : 'a t list ‑> 'a list t

seq_list l returns all the ways to pick one element in each sub-sequence +in l. Assumes the sub-sequences can be iterated on several times.

  • Since: 0.11
val seq_list_map : ('a ‑> 'b t) ‑> 'a list ‑> 'b list t

seq_list_map f l maps f over every element of l, +then calls seq_list

  • Since: 0.11
val filter_map : ('a ‑> 'b option) ‑> 'a t ‑> 'b t

Map and only keep non-None elements +Formerly fmap

  • Since: 0.5
val filter_mapi : (int ‑> 'a ‑> 'b option) ‑> 'a t ‑> 'b t

Map with indices, and only keep non-None elements

  • Since: 0.11
val filter_count : ('a ‑> bool) ‑> 'a t ‑> int

Count how many elements satisfy the given predicate

  • Since: 1.0
val intersperse : 'a ‑> 'a t ‑> 'a t

Insert the single element between every element of the sequence

val keep_some : 'a option t ‑> 'a t

filter_some l retains only elements of the form Some x. +Same as filter_map (fun x->x)

  • Since: 1.0
val keep_ok : ('a, _) Result.result t ‑> 'a t

keep_ok l retains only elements of the form Ok x.

  • Since: 1.0
val keep_error : (_, 'e) Result.result t ‑> 'e t

keep_error l retains only elements of the form Error x.

  • Since: 1.0

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 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 (take, etc.) then s' will not be +memorized, and the next call to s' will traverse s again.

Misc

val sort : ?⁠cmp:('a ‑> 'a ‑> int) ‑> 'a t ‑> 'a t

Sort the sequence. Eager, O(n) ram and O(n ln(n)) time. +It iterates on elements of the argument sequence immediately, +before it sorts them.

val sort_uniq : ?⁠cmp:('a ‑> 'a ‑> int) ‑> 'a t ‑> 'a t

Sort the sequence and remove duplicates. Eager, same as sort

val sorted : ?⁠cmp:('a ‑> 'a ‑> int) ‑> 'a t ‑> bool

Checks whether the sequence is sorted. Eager, same as sort.

  • Since: 0.9
val group_succ_by : ?⁠eq:('a ‑> 'a ‑> bool) ‑> 'a t ‑> 'a list t

Group equal consecutive elements. Linear time. +Formerly synonym to group.

  • Since: 0.6
val group_by : ?⁠hash:('a ‑> int) ‑> ?⁠eq:('a ‑> 'a ‑> bool) ‑> 'a t ‑> 'a list t

Group equal elements, disregarding their order of appearance. +The result sequence is traversable as many times as required. +precondition: for any x and y, if eq x y then hash x=hash y must hold.

  • Since: 0.6
val count : ?⁠hash:('a ‑> int) ‑> ?⁠eq:('a ‑> 'a ‑> bool) ‑> 'a t ‑> ('a * int) t

Map each distinct element to its number of occurrences in the whole seq. +Similar to group_by seq |> map (fun l->List.hd l, List.length l) +precondition: for any x and y, if eq x y then hash x=hash y must hold.

  • Since: 0.10
val uniq : ?⁠eq:('a ‑> 'a ‑> bool) ‑> 'a t ‑> 'a t

Remove consecutive duplicate elements. Basically this is +like fun seq -> map List.hd (group seq).

val product : 'a t ‑> 'b t ‑> ('a * 'b) t

Cartesian product of the sequences. When calling product a b, +the caller MUST ensure that b can be traversed as many times +as required (several times), possibly by calling persistent on it +beforehand.

val diagonal_l : 'a list ‑> ('a * 'a) t

All pairs of distinct positions of the list. diagonal l will +return the sequence of all List.nth i l, List.nth j l if i < j.

  • Since: 0.9
val diagonal : 'a t ‑> ('a * 'a) t

All pairs of distinct positions of the sequence. +Iterates only once on the sequence, which must be finite.

  • Since: 0.9
val join : join_row:('a ‑> 'b ‑> 'c option) ‑> 'a t ‑> 'b t ‑> 'c t

join ~join_row a b combines every element of a with every +element of b using join_row. If join_row returns None, then +the two elements do not combine. Assume that b allows for multiple +iterations.

val join_by : ?⁠eq:'key equal ‑> ?⁠hash:'key hash ‑> ('a ‑> 'key) ‑> ('b ‑> 'key) ‑> merge:('key ‑> 'a ‑> 'b ‑> 'c option) ‑> 'a t ‑> 'b t ‑> 'c t

join key1 key2 ~merge is a binary operation +that takes two sequences a and b, projects their +elements resp. with key1 and key2, and combine +values (x,y) from (a,b) with the same key +using merge. If merge returns None, the combination +of values is discarded. +precondition: for any x and y, if eq x y then hash x=hash y must hold.

  • Since: 0.10
val join_all_by : ?⁠eq:'key equal ‑> ?⁠hash:'key hash ‑> ('a ‑> 'key) ‑> ('b ‑> 'key) ‑> merge:('key ‑> 'a list ‑> 'b list ‑> 'c option) ‑> 'a t ‑> 'b t ‑> 'c t

join_all_by key1 key2 ~merge is a binary operation +that takes two sequences a and b, projects their +elements resp. with key1 and key2, and, for each key k +occurring in at least one of them: +

  • compute the list l1 of elements of a that map to k
  • compute the list l2 of elements of b that map to k
  • call merge k l1 l2. If merge returns None, the combination +of values is discarded, otherwise it returns Some c +and c is inserted in the result.
  • Since: 0.10
val group_join_by : ?⁠eq:'a equal ‑> ?⁠hash:'a hash ‑> ('b ‑> 'a) ‑> 'a t ‑> 'b t ‑> ('a * 'b list) t

group_join_by key2 associates to every element x of +the first sequence, all the elements y of the second +sequence such that eq x (key y). Elements of the first +sequences without corresponding values in the second one +are mapped to [] +precondition: for any x and y, if eq x y then hash x=hash y must hold.

  • Since: 0.10
val inter : ?⁠eq:'a equal ‑> ?⁠hash:'a hash ‑> 'a t ‑> 'a t ‑> 'a t

Intersection of two collections. Each element will occur at most once +in the result. Eager. +precondition: for any x and y, if eq x y then hash x=hash y must hold.

  • Since: 0.10
val union : ?⁠eq:'a equal ‑> ?⁠hash:'a hash ‑> 'a t ‑> 'a t ‑> 'a t

Union of two collections. Each element will occur at most once +in the result. Eager. +precondition: for any x and y, if eq x y then hash x=hash y must hold.

  • Since: 0.10
val diff : ?⁠eq:'a equal ‑> ?⁠hash:'a hash ‑> 'a t ‑> 'a t ‑> 'a t

Set difference. Eager.

  • Since: 0.10
val subset : ?⁠eq:'a equal ‑> ?⁠hash:'a hash ‑> 'a t ‑> 'a t ‑> bool

subset a b returns true if all elements of a belong to b. Eager. +precondition: for any x and y, if eq x y then hash x=hash y must hold.

  • Since: 0.10
val unfoldr : ('b ‑> ('a * 'b) option) ‑> 'b ‑> 'a t

unfoldr f b will apply f to b. If it +yields Some (x,b') then x is returned +and unfoldr recurses with b'.

val scan : ('b ‑> 'a ‑> 'b) ‑> 'b ‑> 'a t ‑> 'b t

Sequence of intermediate results

val max : ?⁠lt:('a ‑> 'a ‑> bool) ‑> 'a t ‑> 'a option

Max element of the sequence, using the given comparison function.

  • Returns None if the sequence is empty, Some m where m is the maximal +element otherwise
val max_exn : ?⁠lt:('a ‑> 'a ‑> bool) ‑> 'a t ‑> 'a

Unsafe version of max

  • Raises Not_found: if the sequence is empty
  • Since: 0.10
val min : ?⁠lt:('a ‑> 'a ‑> bool) ‑> 'a t ‑> 'a option

Min element of the sequence, using the given comparison function. +see max for more details.

val min_exn : ?⁠lt:('a ‑> 'a ‑> bool) ‑> 'a t ‑> 'a

Unsafe version of min

  • Raises Not_found: if the sequence is empty
  • Since: 0.10
val sum : int t ‑> int

Sum of elements

  • Since: 0.11
val sumf : float t ‑> float

Sum of elements, using Kahan summation

  • Since: 0.11
val head : 'a t ‑> 'a option

First element, if any, otherwise None

  • Since: 0.5.1
val head_exn : 'a t ‑> 'a

First element, if any, fails

  • Raises Invalid_argument: if the sequence is empty
  • Since: 0.5.1
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 * [ `Stop | `Continue ]) ‑> '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 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.

val zip_i : 'a t ‑> (int * 'a) t
val fold2 : ('c ‑> 'a ‑> 'b ‑> 'c) ‑> 'c ‑> ('a * 'b) t ‑> 'c
val iter2 : ('a ‑> 'b ‑> unit) ‑> ('a * 'b) t ‑> unit
val map2 : ('a ‑> 'b ‑> 'c) ‑> ('a * 'b) t ‑> 'c t
val map2_2 : ('a ‑> 'b ‑> 'c) ‑> ('a ‑> 'b ‑> 'd) ‑> ('a * 'b) t ‑> ('c * 'd) t

map2_2 f g seq2 maps each x, y of seq2 into f x y, g x y

Basic data structures converters

val to_list : 'a t ‑> 'a list

Convert the sequence into a list. Preserves order of elements. +This function is tail-recursive, but consumes 2*n memory. +If order doesn't matter to you, consider to_rev_list.

val to_rev_list : 'a t ‑> 'a list

Get the list of the reversed sequence (more efficient than 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 pair_with_idx : 'a t ‑> (int * 'a) t

Similar to zip_i but returns a normal sequence of tuples

  • Since: 0.11
val to_opt : 'a t ‑> 'a option

Alias to head

  • Since: 0.5.1
val to_array : 'a t ‑> 'a array

Convert to an array. Currently not very efficient because +an intermediate list is used.

val of_array : 'a array ‑> 'a t
val of_array_i : 'a array ‑> (int * 'a) t

Elements of the array, with their index

val array_slice : 'a array ‑> int ‑> int ‑> 'a t

array_slice a i j Sequence of elements whose indexes range +from i to j

val of_opt : 'a option ‑> 'a t

Iterate on 0 or 1 values.

  • 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

Convert to a stream. linear in memory and time (a copy is made in memory)

val to_stack : 'a Stack.t ‑> 'a t ‑> unit

Push elements of the sequence on the stack

val of_stack : 'a Stack.t ‑> 'a t

Sequence of elements of the stack (same order as Stack.iter)

val to_queue : 'a Queue.t ‑> 'a t ‑> unit

Push elements of the sequence into the queue

val of_queue : 'a Queue.t ‑> 'a t

Sequence of elements contained in the queue, FIFO order

val hashtbl_add : ('a, 'b) Hashtbl.t ‑> ('a * 'b) t ‑> unit

Add elements of the sequence to the hashtable, with +Hashtbl.add

val hashtbl_replace : ('a, 'b) Hashtbl.t ‑> ('a * 'b) t ‑> unit

Add elements of the sequence to the hashtable, with +Hashtbl.replace (erases conflicting bindings)

val to_hashtbl : ('a * 'b) t ‑> ('a, 'b) Hashtbl.t

Build a hashtable from a sequence of key/value pairs

val of_hashtbl : ('a, 'b) Hashtbl.t ‑> ('a * 'b) t

Sequence of key/value pairs from the hashtable

val hashtbl_keys : ('a, 'b) Hashtbl.t ‑> 'a t
val hashtbl_values : ('a, 'b) Hashtbl.t ‑> 'b t
val of_str : string ‑> char t
val to_str : char t ‑> string
val concat_str : string t ‑> string

Concatenate strings together, eagerly. +Also see 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 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
val int_range_dec : start:int ‑> stop:int ‑> int t
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

Convert the sequence to a set, given the proper set module

type 'a gen = unit ‑> 'a option
type 'a klist = unit ‑> [ `Nil | `Cons of 'a * 'a klist ]
val of_gen : 'a gen ‑> 'a t

Traverse eagerly the generator and build a sequence from it

val to_gen : 'a t ‑> 'a gen

Make the sequence persistent (O(n)) and then iterate on it. Eager.

val of_klist : 'a klist ‑> 'a t

Iterate on the lazy list

val to_klist : 'a t ‑> 'a klist

Make the sequence persistent and then iterate on it. Eager.

Functorial conversions between sets and sequences

module Set : sig ... end

Conversion between maps and sequences.

module Map : sig ... end

Infinite sequences of random values

val random_int : int ‑> int t

Infinite sequence of random integers between 0 and +the given higher bound (see Random.int)

val random_bool : bool t

Infinite sequence of random bool values

val random_float : float ‑> float t
val random_array : 'a array ‑> 'a t

Sequence of choices of an element in the array

val random_list : 'a list ‑> 'a t

Infinite sequence of random elements of the list. Basically the +same as random_array.

val shuffle : 'a t ‑> 'a t

shuffle seq returns a perfect shuffle of seq. +Uses O(length seq) memory and time. Eager.

  • Since: 0.7
val shuffle_buffer : 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 module type of Infix
val (--) : int ‑> int ‑> int 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 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 t ‑> ('a ‑> 'b t) ‑> 'b t

Monadic bind (infix version of flat_map

  • Since: 0.5
val (>|=) : 'a t ‑> ('a ‑> 'b) ‑> 'b t

Infix version of map

  • Since: 0.5
val (<*>) : ('a ‑> 'b) t ‑> 'a t ‑> 'b t

Applicative operator (product+application)

  • Since: 0.5
val (<+>) : 'a t ‑> 'a t ‑> 'a t

Concatenation of sequences

  • Since: 0.5

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/sequence/SequenceLabels/.jbuilder-keep b/sequence/SequenceLabels/.jbuilder-keep new file mode 100644 index 0000000..e69de29 diff --git a/sequence/SequenceLabels/IO/index.html b/sequence/SequenceLabels/IO/index.html new file mode 100644 index 0000000..bb2b41e --- /dev/null +++ b/sequence/SequenceLabels/IO/index.html @@ -0,0 +1,11 @@ + +IO (sequence.SequenceLabels.IO)

Module SequenceLabels.IO

val lines_of : ?⁠mode:int ‑> ?⁠flags:Pervasives.open_flag list ‑> string ‑> string t

lines_of filename reads all lines of the given file. It raises the +same exception as would opening the file and read from it, except +from End_of_file (which is caught). The file is always properly +closed. +Every time the sequence is iterated on, the file is opened again, so +different iterations might return different results

  • Parameter mode: default 0o644
  • Parameter flags: default: [Open_rdonly]
val chunks_of : ?⁠mode:int ‑> ?⁠flags:Pervasives.open_flag list ‑> ?⁠size:int ‑> string ‑> string t

Read chunks of the given size from the file. The last chunk might be +smaller. Behaves like lines_of regarding errors and options. +Every time the sequence is iterated on, the file is opened again, so +different iterations might return different results

val write_to : ?⁠mode:int ‑> ?⁠flags:Pervasives.open_flag list ‑> string ‑> string t ‑> unit

write_to filename seq writes all strings from seq into the given +file. It takes care of opening and closing the file.

  • Parameter mode: default 0o644
  • Parameter flags: used by open_out_gen. Default: [Open_creat;Open_wronly].
val write_bytes_to : ?⁠mode:int ‑> ?⁠flags:Pervasives.open_flag list ‑> string ‑> Bytes.t t ‑> unit
  • Since: 0.5.4
val write_lines : ?⁠mode:int ‑> ?⁠flags:Pervasives.open_flag list ‑> string ‑> string t ‑> unit

Same as write_to, but intercales '\n' between each string

val write_bytes_lines : ?⁠mode:int ‑> ?⁠flags:Pervasives.open_flag list ‑> string ‑> Bytes.t t ‑> unit
  • Since: 0.5.4
\ No newline at end of file diff --git a/sequence/SequenceLabels/Infix/index.html b/sequence/SequenceLabels/Infix/index.html new file mode 100644 index 0000000..2998217 --- /dev/null +++ b/sequence/SequenceLabels/Infix/index.html @@ -0,0 +1,5 @@ + +Infix (sequence.SequenceLabels.Infix)

Module SequenceLabels.Infix

val (--) : int ‑> int ‑> int 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 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 t ‑> ('a ‑> 'b t) ‑> 'b t

Monadic bind (infix version of flat_map

  • Since: 0.5
val (>|=) : 'a t ‑> ('a ‑> 'b) ‑> 'b t

Infix version of map

  • Since: 0.5
val (<*>) : ('a ‑> 'b) t ‑> 'a t ‑> 'b t

Applicative operator (product+application)

  • Since: 0.5
val (<+>) : 'a t ‑> 'a t ‑> 'a t

Concatenation of sequences

  • Since: 0.5
\ No newline at end of file diff --git a/sequence/SequenceLabels/Map/index.html b/sequence/SequenceLabels/Map/index.html new file mode 100644 index 0000000..faeec97 --- /dev/null +++ b/sequence/SequenceLabels/Map/index.html @@ -0,0 +1,2 @@ + +Map (sequence.SequenceLabels.Map)

Module SequenceLabels.Map

module type S : sig ... end
module Adapt : functor (M : Map.S) -> S with type Adapt.key = M.key and type 'a Adapt.t = 'a M.t

Adapt a pre-existing Map module to make it sequence-aware

module Make : functor (V : Map.OrderedType) -> S with type Make.key = V.t

Create an enriched Map module, with sequence-aware functions

\ No newline at end of file diff --git a/sequence/SequenceLabels/Map/module-type-S/index.html b/sequence/SequenceLabels/Map/module-type-S/index.html new file mode 100644 index 0000000..4b73bb1 --- /dev/null +++ b/sequence/SequenceLabels/Map/module-type-S/index.html @@ -0,0 +1,2 @@ + +S (sequence.SequenceLabels.Map.S)

Module type SequenceLabels.Map.S

include Map.S
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 min_binding_opt : 'a t ‑> (key * 'a) option
val max_binding : 'a t ‑> key * 'a
val max_binding_opt : 'a t ‑> (key * 'a) option
val choose : 'a t ‑> key * 'a
val choose_opt : 'a t ‑> (key * 'a) option
val split : key ‑> 'a t ‑> 'a t * 'a option * 'a t
val find : key ‑> 'a t ‑> 'a
val find_opt : key ‑> 'a t ‑> 'a option
val find_first : (key ‑> bool) ‑> 'a t ‑> key * 'a
val find_first_opt : (key ‑> bool) ‑> 'a t ‑> (key * 'a) option
val find_last : (key ‑> bool) ‑> 'a t ‑> key * 'a
val find_last_opt : (key ‑> bool) ‑> 'a t ‑> (key * 'a) option
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
\ No newline at end of file diff --git a/sequence/SequenceLabels/Set/index.html b/sequence/SequenceLabels/Set/index.html new file mode 100644 index 0000000..5837a2e --- /dev/null +++ b/sequence/SequenceLabels/Set/index.html @@ -0,0 +1,2 @@ + +Set (sequence.SequenceLabels.Set)

Module SequenceLabels.Set

module type S : sig ... end
module Adapt : functor (X : Set.S) -> S with type Adapt.elt = X.elt and type Adapt.t = X.t

Create an enriched Set module from the given one

module Make : functor (X : Set.OrderedType) -> S with type Make.elt = X.t

Functor to build an extended Set module from an ordered type

\ No newline at end of file diff --git a/sequence/SequenceLabels/Set/module-type-S/index.html b/sequence/SequenceLabels/Set/module-type-S/index.html new file mode 100644 index 0000000..1145ef1 --- /dev/null +++ b/sequence/SequenceLabels/Set/module-type-S/index.html @@ -0,0 +1,2 @@ + +S (sequence.SequenceLabels.Set.S)

Module type SequenceLabels.Set.S

include Set.S
type elt
type t
val empty : t
val is_empty : t ‑> bool
val mem : elt ‑> t ‑> bool
val add : elt ‑> t ‑> t
val singleton : elt ‑> t
val remove : elt ‑> t ‑> t
val union : t ‑> t ‑> t
val inter : t ‑> t ‑> t
val diff : t ‑> t ‑> t
val compare : t ‑> t ‑> int
val equal : t ‑> t ‑> bool
val subset : t ‑> t ‑> bool
val iter : (elt ‑> unit) ‑> t ‑> unit
val map : (elt ‑> elt) ‑> t ‑> t
val fold : (elt ‑> 'a ‑> 'a) ‑> t ‑> 'a ‑> 'a
val for_all : (elt ‑> bool) ‑> t ‑> bool
val exists : (elt ‑> bool) ‑> t ‑> bool
val filter : (elt ‑> bool) ‑> t ‑> t
val partition : (elt ‑> bool) ‑> t ‑> t * t
val cardinal : t ‑> int
val elements : t ‑> elt list
val min_elt : t ‑> elt
val min_elt_opt : t ‑> elt option
val max_elt : t ‑> elt
val max_elt_opt : t ‑> elt option
val choose : t ‑> elt
val choose_opt : t ‑> elt option
val split : elt ‑> t ‑> t * bool * t
val find : elt ‑> t ‑> elt
val find_opt : elt ‑> t ‑> elt option
val find_first : (elt ‑> bool) ‑> t ‑> elt
val find_first_opt : (elt ‑> bool) ‑> t ‑> elt option
val find_last : (elt ‑> bool) ‑> t ‑> elt
val find_last_opt : (elt ‑> bool) ‑> t ‑> elt option
val of_list : elt list ‑> t
val of_seq : elt sequence ‑> t
val to_seq : t ‑> elt sequence
val to_list : t ‑> elt list
val of_list : elt list ‑> t
\ No newline at end of file diff --git a/sequence/SequenceLabels/index.html b/sequence/SequenceLabels/index.html new file mode 100644 index 0000000..5e81382 --- /dev/null +++ b/sequence/SequenceLabels/index.html @@ -0,0 +1,103 @@ + +SequenceLabels (sequence.SequenceLabels)

Module SequenceLabels

Simple and Efficient Iterators

Version of Sequence with labels

type +'a t = ('a ‑> unit) ‑> unit

A sequence of values of type 'a. If you give it a function 'a -> unit +it will be applied to every element of the sequence successively.

type +'a sequence = 'a t

NOTE Type ('a, 'b) t2 = ('a -> 'b -> unit) -> unit +has been removed and subsumed by ('a * 'b) t

type 'a equal = 'a ‑> 'a ‑> bool
type 'a hash = 'a ‑> int

Build a sequence

val from_iter : (('a ‑> unit) ‑> unit) ‑> 'a t

Build a sequence from a iter function

val from_fun : (unit ‑> 'a option) ‑> 'a t

Call the function repeatedly until it returns None. This +sequence is transient, use persistent if needed!

val empty : 'a t

Empty sequence. It contains no element.

val singleton : 'a ‑> 'a t

Singleton sequence, with exactly one element.

val doubleton : 'a ‑> 'a ‑> 'a t

Sequence with exactly two elements

val init : f:(int ‑> 'a) ‑> 'a t

init f is the infinite sequence f 0; f 1; f 2; ….

  • Since: 0.9
val cons : 'a ‑> 'a t ‑> 'a t

cons x l yields x, then yields from l. +Same as append (singleton x) l

val snoc : 'a t ‑> 'a ‑> 'a t

Same as cons but yields the element after iterating on l

val return : 'a ‑> 'a t

Synonym to singleton

val pure : 'a ‑> 'a t

Synonym to singleton

val repeat : 'a ‑> 'a t

Infinite sequence of the same element. You may want to look +at 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 take and 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 take not to loop +forever.

Consume a sequence

val iter : f:('a ‑> unit) ‑> 'a t ‑> unit

Consume the sequence, passing all its arguments to the function. +Basically iter f seq is just seq f.

val iteri : f:(int ‑> 'a ‑> unit) ‑> 'a t ‑> unit

Iterate on elements and their index in the sequence

val fold : f:('a ‑> 'b ‑> 'a) ‑> init:'a ‑> 'b t ‑> 'a

Fold over elements of the sequence, consuming it

val foldi : f:('a ‑> int ‑> 'b ‑> 'a) ‑> init:'a ‑> 'b t ‑> 'a

Fold over elements of the sequence and their index, consuming it

val fold_map : f:('acc ‑> 'a ‑> 'acc * 'b) ‑> init:'acc ‑> 'a t ‑> 'b t

fold_map f acc l is like map, but it carries some state as in +fold. The state is not returned, it is just used to thread some +information to the map function.

  • Since: 0.9
val fold_filter_map : f:('acc ‑> 'a ‑> 'acc * 'b option) ‑> init:'acc ‑> 'a t ‑> 'b t

fold_filter_map f acc l is a fold_map-like function, but the +function can choose to skip an element by retuning None.

  • Since: 0.9
val map : f:('a ‑> 'b) ‑> 'a t ‑> 'b t

Map objects of the sequence into other elements, lazily

val mapi : f:(int ‑> 'a ‑> 'b) ‑> 'a t ‑> 'b t

Map objects, along with their index in the sequence

val map_by_2 : f:('a ‑> 'a ‑> 'a) ‑> 'a t ‑> 'a t

Map objects two by two. lazily. +The last element is kept in the sequence if the count is odd.

  • Since: 0.7
val for_all : f:('a ‑> bool) ‑> 'a t ‑> bool

Do all elements satisfy the predicate?

val exists : f:('a ‑> bool) ‑> 'a t ‑> bool

Exists there some element satisfying the predicate?

val mem : ?⁠eq:('a ‑> 'a ‑> bool) ‑> x:'a ‑> 'a t ‑> bool

Is the value a member of the sequence?

  • Parameter eq: the equality predicate to use (default (=))
  • Since: 0.5
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 find_map : f:('a ‑> 'b option) ‑> 'a t ‑> 'b option

Alias to find

  • Since: 0.10
val findi : f:(int ‑> 'a ‑> 'b option) ‑> 'a t ‑> 'b option

Indexed version of find

  • Since: 0.9
val find_mapi : f:(int ‑> 'a ‑> 'b option) ‑> 'a t ‑> 'b option

Alias to findi

  • Since: 0.10
val find_pred : f:('a ‑> bool) ‑> 'a t ‑> 'a option

find_pred p l finds the first element of l that satisfies p, +or returns None if no element satisfies p

  • Since: 0.9
val find_pred_exn : f:('a ‑> bool) ‑> 'a t ‑> 'a

Unsafe version of find_pred

  • Raises Not_found: if no such element is found
  • Since: 0.9
val length : 'a t ‑> int

How long is the sequence? Forces the sequence.

val is_empty : 'a t ‑> bool

Is the sequence empty? Forces the sequence.

Transform a sequence

val filter : f:('a ‑> bool) ‑> 'a t ‑> 'a t

Filter on elements of the sequence

val append : 'a t ‑> 'a t ‑> 'a t

Append two sequences. Iterating on the result is like iterating +on the first, then on the second.

val append_l : 'a t list ‑> 'a t

Append sequences. Iterating on the result is like iterating +on the each sequence of the list in order.

  • Since: 0.11
val concat : 'a t t ‑> 'a t

Concatenate a sequence of sequences into one sequence.

val flatten : 'a t t ‑> 'a t

Alias for concat

val flat_map : f:('a ‑> 'b t) ‑> 'a t ‑> 'b t

Alias to flatMap with a more explicit name

val flat_map_l : f:('a ‑> 'b list) ‑> 'a t ‑> 'b t

Convenience function combining flat_map and of_list

  • Since: 0.9
val filter_map : f:('a ‑> 'b option) ‑> 'a t ‑> 'b t

Alias to fmap with a more explicit name

val filter_mapi : f:(int ‑> 'a ‑> 'b option) ‑> 'a t ‑> 'b t

Map with indices, and only keep non-None elements

  • Since: 0.11
val seq_list : 'a t list ‑> 'a list t

seq_list l returns all the ways to pick one element in each sub-sequence +in l. Assumes the sub-sequences can be iterated on several times.

  • Since: 0.11
val seq_list_map : f:('a ‑> 'b t) ‑> 'a list ‑> 'b list t

seq_list_map f l maps f over every element of l, +then calls seq_list

  • Since: 0.11
val filter_count : f:('a ‑> bool) ‑> 'a t ‑> int

Count how many elements satisfy the given predicate

  • Since: 1.0
val intersperse : x:'a ‑> 'a t ‑> 'a t

Insert the single element between every element of the sequence

val keep_some : 'a option t ‑> 'a t

filter_some l retains only elements of the form Some x. +Same as filter_map (fun x->x)

  • Since: 1.0
val keep_ok : ('a, _) Result.result t ‑> 'a t

keep_ok l retains only elements of the form Ok x.

  • Since: 1.0
val keep_error : (_, 'e) Result.result t ‑> 'e t

keep_error l retains only elements of the form Error x.

  • Since: 1.0

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 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 (take, etc.) then s' will not be +memorized, and the next call to s' will traverse s again.

Misc

val sort : ?⁠cmp:('a ‑> 'a ‑> int) ‑> 'a t ‑> 'a t

Sort the sequence. Eager, O(n) ram and O(n ln(n)) time. +It iterates on elements of the argument sequence immediately, +before it sorts them.

val sort_uniq : ?⁠cmp:('a ‑> 'a ‑> int) ‑> 'a t ‑> 'a t

Sort the sequence and remove duplicates. Eager, same as sort

val sorted : ?⁠cmp:('a ‑> 'a ‑> int) ‑> 'a t ‑> bool

Checks whether the sequence is sorted. Eager, same as sort.

  • Since: 0.9
val group_succ_by : ?⁠eq:('a ‑> 'a ‑> bool) ‑> 'a t ‑> 'a list t

Group equal consecutive elements. +Formerly synonym to group.

  • Since: 0.6
val group_by : ?⁠hash:('a ‑> int) ‑> ?⁠eq:('a ‑> 'a ‑> bool) ‑> 'a t ‑> 'a list t

Group equal elements, disregarding their order of appearance. +The result sequence is traversable as many times as required. +precondition: for any x and y, if eq x y then hash x=hash y must hold.

  • Since: 0.6
val count : ?⁠hash:('a ‑> int) ‑> ?⁠eq:('a ‑> 'a ‑> bool) ‑> 'a t ‑> ('a * int) t

Map each distinct element to its number of occurrences in the whole seq. +Similar to group_by seq |> map (fun l->List.hd l, List.length l)

  • Since: 0.10
val uniq : ?⁠eq:('a ‑> 'a ‑> bool) ‑> 'a t ‑> 'a t

Remove consecutive duplicate elements. Basically this is +like fun seq -> map List.hd (group seq).

val product : 'a t ‑> 'b t ‑> ('a * 'b) t

Cartesian product of the sequences. When calling product a b, +the caller MUST ensure that b can be traversed as many times +as required (several times), possibly by calling persistent on it +beforehand.

val diagonal_l : 'a list ‑> ('a * 'a) t

All pairs of distinct positions of the list. diagonal l will +return the sequence of all List.nth i l, List.nth j l if i < j.

  • Since: 0.9
val diagonal : 'a t ‑> ('a * 'a) t

All pairs of distinct positions of the sequence. +Iterates only once on the sequence, which must be finite.

  • Since: 0.9
val join : join_row:('a ‑> 'b ‑> 'c option) ‑> 'a t ‑> 'b t ‑> 'c t

join ~join_row a b combines every element of a with every +element of b using join_row. If join_row returns None, then +the two elements do not combine. Assume that b allows for multiple +iterations.

val join_by : ?⁠eq:'key equal ‑> ?⁠hash:'key hash ‑> ('a ‑> 'key) ‑> ('b ‑> 'key) ‑> merge:('key ‑> 'a ‑> 'b ‑> 'c option) ‑> 'a t ‑> 'b t ‑> 'c t

join key1 key2 ~merge is a binary operation +that takes two sequences a and b, projects their +elements resp. with key1 and key2, and combine +values (x,y) from (a,b) with the same key +using merge. If merge returns None, the combination +of values is discarded. +precondition: for any x and y, if eq x y then hash x=hash y must hold.

  • Since: 0.10
val join_all_by : ?⁠eq:'key equal ‑> ?⁠hash:'key hash ‑> ('a ‑> 'key) ‑> ('b ‑> 'key) ‑> merge:('key ‑> 'a list ‑> 'b list ‑> 'c option) ‑> 'a t ‑> 'b t ‑> 'c t

join_all_by key1 key2 ~merge is a binary operation +that takes two sequences a and b, projects their +elements resp. with key1 and key2, and, for each key k +occurring in at least one of them: +

  • compute the list l1 of elements of a that map to k
  • compute the list l2 of elements of b that map to k
  • call merge k l1 l2. If merge returns None, the combination +of values is discarded, otherwise it returns Some c +and c is inserted in the result.
  • Since: 0.10
val group_join_by : ?⁠eq:'a equal ‑> ?⁠hash:'a hash ‑> ('b ‑> 'a) ‑> 'a t ‑> 'b t ‑> ('a * 'b list) t

group_join_by key2 associates to every element x of +the first sequence, all the elements y of the second +sequence such that eq x (key y). Elements of the first +sequences without corresponding values in the second one +are mapped to [] +precondition: for any x and y, if eq x y then hash x=hash y must hold.

  • Since: 0.10
val inter : ?⁠eq:'a equal ‑> ?⁠hash:'a hash ‑> 'a t ‑> 'a t ‑> 'a t

Intersection of two collections. Each element will occur at most once +in the result. Eager. +precondition: for any x and y, if eq x y then hash x=hash y must hold.

  • Since: 0.10
val union : ?⁠eq:'a equal ‑> ?⁠hash:'a hash ‑> 'a t ‑> 'a t ‑> 'a t

Union of two collections. Each element will occur at most once +in the result. Eager. +precondition: for any x and y, if eq x y then hash x=hash y must hold.

  • Since: 0.10
val diff : ?⁠eq:'a equal ‑> ?⁠hash:'a hash ‑> 'a t ‑> 'a t ‑> 'a t

Set difference. Eager.

  • Since: 0.10
val subset : ?⁠eq:'a equal ‑> ?⁠hash:'a hash ‑> 'a t ‑> 'a t ‑> bool

subset a b returns true if all elements of a belong to b. Eager. +precondition: for any x and y, if eq x y then hash x=hash y must hold.

  • Since: 0.10
val unfoldr : ('b ‑> ('a * 'b) option) ‑> 'b ‑> 'a t

unfoldr f b will apply f to b. If it +yields Some (x,b') then x is returned +and unfoldr recurses with b'.

val scan : ('b ‑> 'a ‑> 'b) ‑> 'b ‑> 'a t ‑> 'b t

Sequence of intermediate results

val max : ?⁠lt:('a ‑> 'a ‑> bool) ‑> 'a t ‑> 'a option

Max element of the sequence, using the given comparison function.

  • Returns None if the sequence is empty, Some m where m is the maximal +element otherwise
val max_exn : ?⁠lt:('a ‑> 'a ‑> bool) ‑> 'a t ‑> 'a

Unsafe version of max

  • Raises Not_found: if the sequence is empty
  • Since: 0.10
val min : ?⁠lt:('a ‑> 'a ‑> bool) ‑> 'a t ‑> 'a option

Min element of the sequence, using the given comparison function. +see max for more details.

val min_exn : ?⁠lt:('a ‑> 'a ‑> bool) ‑> 'a t ‑> 'a

Unsafe version of min

  • Raises Not_found: if the sequence is empty
  • Since: 0.10
val sum : int t ‑> int

Sum of elements

  • Since: 0.11
val sumf : float t ‑> float

Sum of elements, using Kahan summation

  • Since: 0.11
val head : 'a t ‑> 'a option

First element, if any, otherwise None

  • Since: 0.5.1
val head_exn : 'a t ‑> 'a

First element, if any, fails

  • Raises Invalid_argument: if the sequence is empty
  • Since: 0.5.1
val take : int ‑> 'a t ‑> 'a t

Take at most n elements from the sequence. Works on infinite +sequences.

val take_while : f:('a ‑> bool) ‑> 'a t ‑> 'a t

Take elements while they satisfy the predicate, then stops iterating. +Will work on an infinite sequence s if the predicate is false for at +least one element of s.

val fold_while : f:('a ‑> 'b ‑> 'a * [ `Stop | `Continue ]) ‑> init:'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 : f:('a ‑> bool) ‑> 'a t ‑> 'a t

Predicate version of 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.

val zip_i : 'a t ‑> (int * 'a) t
val fold2 : f:('c ‑> 'a ‑> 'b ‑> 'c) ‑> init:'c ‑> ('a * 'b) t ‑> 'c
val iter2 : f:('a ‑> 'b ‑> unit) ‑> ('a * 'b) t ‑> unit
val map2 : f:('a ‑> 'b ‑> 'c) ‑> ('a * 'b) t ‑> 'c t
val map2_2 : f:('a ‑> 'b ‑> 'c) ‑> ('a ‑> 'b ‑> 'd) ‑> ('a * 'b) t ‑> ('c * 'd) t

map2_2 f g seq2 maps each x, y of seq2 into f x y, g x y

Basic data structures converters

val to_list : 'a t ‑> 'a list

Convert the sequence into a list. Preserves order of elements. +This function is tail-recursive, but consumes 2*n memory. +If order doesn't matter to you, consider to_rev_list.

val to_rev_list : 'a t ‑> 'a list

Get the list of the reversed sequence (more efficient than 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 pair_with_idx : 'a t ‑> (int * 'a) t

Similar to zip_i but returns a normal sequence of tuples

  • Since: 0.11
val to_opt : 'a t ‑> 'a option

Alias to head

  • Since: 0.5.1
val to_array : 'a t ‑> 'a array

Convert to an array. Currently not very efficient because +an intermediate list is used.

val of_array : 'a array ‑> 'a t
val of_array_i : 'a array ‑> (int * 'a) t

Elements of the array, with their index

val array_slice : 'a array ‑> int ‑> int ‑> 'a t

array_slice a i j Sequence of elements whose indexes range +from i to j

val of_opt : 'a option ‑> 'a t

Iterate on 0 or 1 values.

  • 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

Convert to a stream. linear in memory and time (a copy is made in memory)

val to_stack : 'a Stack.t ‑> 'a t ‑> unit

Push elements of the sequence on the stack

val of_stack : 'a Stack.t ‑> 'a t

Sequence of elements of the stack (same order as Stack.iter)

val to_queue : 'a Queue.t ‑> 'a t ‑> unit

Push elements of the sequence into the queue

val of_queue : 'a Queue.t ‑> 'a t

Sequence of elements contained in the queue, FIFO order

val hashtbl_add : ('a, 'b) Hashtbl.t ‑> ('a * 'b) t ‑> unit

Add elements of the sequence to the hashtable, with +Hashtbl.add

val hashtbl_replace : ('a, 'b) Hashtbl.t ‑> ('a * 'b) t ‑> unit

Add elements of the sequence to the hashtable, with +Hashtbl.replace (erases conflicting bindings)

val to_hashtbl : ('a * 'b) t ‑> ('a, 'b) Hashtbl.t

Build a hashtable from a sequence of key/value pairs

val of_hashtbl : ('a, 'b) Hashtbl.t ‑> ('a * 'b) t

Sequence of key/value pairs from the hashtable

val hashtbl_keys : ('a, 'b) Hashtbl.t ‑> 'a t
val hashtbl_values : ('a, 'b) Hashtbl.t ‑> 'b t
val of_str : string ‑> char t
val to_str : char t ‑> string
val concat_str : string t ‑> string

Concatenate strings together, eagerly. +Also see 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 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
val int_range_dec : start:int ‑> stop:int ‑> int t
val int_range_by : step:int ‑> start:int ‑> stop:int ‑> int t

int_range_by ~step ~start:i ~stop:j is the range starting at i, including j, +where the difference between successive elements is step. +use a negative step for a decreasing sequence.

  • Since: 0.9
  • Raises Invalid_argument: if step=0
val bools : bool t

Iterates on true and false

  • Since: 0.9
val of_set : (module Set.S with type elt = 'a and type t = 'b) ‑> 'b ‑> 'a t

Convert the given set to a sequence. The set module must be provided.

val to_set : (module Set.S with type elt = 'a and type t = 'b) ‑> 'a t ‑> 'b

Convert the sequence to a set, given the proper set module

type 'a gen = unit ‑> 'a option
type 'a klist = unit ‑> [ `Nil | `Cons of 'a * 'a klist ]
val of_gen : 'a gen ‑> 'a t

Traverse eagerly the generator and build a sequence from it

val to_gen : 'a t ‑> 'a gen

Make the sequence persistent (O(n)) and then iterate on it. Eager.

val of_klist : 'a klist ‑> 'a t

Iterate on the lazy list

val to_klist : 'a t ‑> 'a klist

Make the sequence persistent and then iterate on it. Eager.

Functorial conversions between sets and sequences

module Set : sig ... end

Conversion between maps and sequences.

module Map : sig ... end

Infinite sequences of random values

val random_int : int ‑> int t

Infinite sequence of random integers between 0 and +the given higher bound (see Random.int)

val random_bool : bool t

Infinite sequence of random bool values

val random_float : float ‑> float t
val random_array : 'a array ‑> 'a t

Sequence of choices of an element in the array

val random_list : 'a list ‑> 'a t

Infinite sequence of random elements of the list. Basically the +same as random_array.

val shuffle : 'a t ‑> 'a t

shuffle seq returns a perfect shuffle of seq. +Uses O(length seq) memory and time. Eager.

  • Since: 0.7
val shuffle_buffer : n:int ‑> 'a t ‑> 'a t

shuffle_buffer n seq returns a sequence of element of seq in random +order. The shuffling is not uniform. Uses O(n) memory.

The first n elements of the sequence are consumed immediately. The +rest is consumed lazily.

  • Since: 0.7

Sampling

val sample : n:int ‑> 'a t ‑> 'a array

sample n seq returns k samples of seq, with uniform probability. +It will consume the sequence and use O(n) memory.

It returns an array of size min (length seq) n.

  • Since: 0.7

Infix functions

module Infix : sig ... end
include module type of Infix
val (--) : int ‑> int ‑> int 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 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 t ‑> ('a ‑> 'b t) ‑> 'b t

Monadic bind (infix version of flat_map

  • Since: 0.5
val (>|=) : 'a t ‑> ('a ‑> 'b) ‑> 'b t

Infix version of map

  • Since: 0.5
val (<*>) : ('a ‑> 'b) t ‑> 'a t ‑> 'b t

Applicative operator (product+application)

  • Since: 0.5
val (<+>) : 'a t ‑> 'a t ‑> 'a t

Concatenation of sequences

  • Since: 0.5

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/sequence/index.html b/sequence/index.html new file mode 100644 index 0000000..e429088 --- /dev/null +++ b/sequence/index.html @@ -0,0 +1,3 @@ + +sequence-generated (sequence.sequence-generated)

Library sequence

+This library exposes the following toplevel modules:

Sequence
SequenceLabels

.

\ No newline at end of file diff --git a/stylesheets/pygment_trac.css b/stylesheets/pygment_trac.css deleted file mode 100644 index e65cedf..0000000 --- a/stylesheets/pygment_trac.css +++ /dev/null @@ -1,70 +0,0 @@ -.highlight .hll { background-color: #ffffcc } -.highlight { background: #f0f3f3; } -.highlight .c { color: #0099FF; font-style: italic } /* Comment */ -.highlight .err { color: #AA0000; background-color: #FFAAAA } /* Error */ -.highlight .k { color: #006699; font-weight: bold } /* Keyword */ -.highlight .o { color: #555555 } /* Operator */ -.highlight .cm { color: #0099FF; font-style: italic } /* Comment.Multiline */ -.highlight .cp { color: #009999 } /* Comment.Preproc */ -.highlight .c1 { color: #0099FF; font-style: italic } /* Comment.Single */ -.highlight .cs { color: #0099FF; font-weight: bold; font-style: italic } /* Comment.Special */ -.highlight .gd { background-color: #FFCCCC; border: 1px solid #CC0000 } /* Generic.Deleted */ -.highlight .ge { font-style: italic } /* Generic.Emph */ -.highlight .gr { color: #FF0000 } /* Generic.Error */ -.highlight .gh { color: #003300; font-weight: bold } /* Generic.Heading */ -.highlight .gi { background-color: #CCFFCC; border: 1px solid #00CC00 } /* Generic.Inserted */ -.highlight .go { color: #AAAAAA } /* Generic.Output */ -.highlight .gp { color: #000099; font-weight: bold } /* Generic.Prompt */ -.highlight .gs { font-weight: bold } /* Generic.Strong */ -.highlight .gu { color: #003300; font-weight: bold } /* Generic.Subheading */ -.highlight .gt { color: #99CC66 } /* Generic.Traceback */ -.highlight .kc { color: #006699; font-weight: bold } /* Keyword.Constant */ -.highlight .kd { color: #006699; font-weight: bold } /* Keyword.Declaration */ -.highlight .kn { color: #006699; font-weight: bold } /* Keyword.Namespace */ -.highlight .kp { color: #006699 } /* Keyword.Pseudo */ -.highlight .kr { color: #006699; font-weight: bold } /* Keyword.Reserved */ -.highlight .kt { color: #007788; font-weight: bold } /* Keyword.Type */ -.highlight .m { color: #FF6600 } /* Literal.Number */ -.highlight .s { color: #CC3300 } /* Literal.String */ -.highlight .na { color: #330099 } /* Name.Attribute */ -.highlight .nb { color: #336666 } /* Name.Builtin */ -.highlight .nc { color: #00AA88; font-weight: bold } /* Name.Class */ -.highlight .no { color: #336600 } /* Name.Constant */ -.highlight .nd { color: #9999FF } /* Name.Decorator */ -.highlight .ni { color: #999999; font-weight: bold } /* Name.Entity */ -.highlight .ne { color: #CC0000; font-weight: bold } /* Name.Exception */ -.highlight .nf { color: #CC00FF } /* Name.Function */ -.highlight .nl { color: #9999FF } /* Name.Label */ -.highlight .nn { color: #00CCFF; font-weight: bold } /* Name.Namespace */ -.highlight .nt { color: #330099; font-weight: bold } /* Name.Tag */ -.highlight .nv { color: #003333 } /* Name.Variable */ -.highlight .ow { color: #000000; font-weight: bold } /* Operator.Word */ -.highlight .w { color: #bbbbbb } /* Text.Whitespace */ -.highlight .mf { color: #FF6600 } /* Literal.Number.Float */ -.highlight .mh { color: #FF6600 } /* Literal.Number.Hex */ -.highlight .mi { color: #FF6600 } /* Literal.Number.Integer */ -.highlight .mo { color: #FF6600 } /* Literal.Number.Oct */ -.highlight .sb { color: #CC3300 } /* Literal.String.Backtick */ -.highlight .sc { color: #CC3300 } /* Literal.String.Char */ -.highlight .sd { color: #CC3300; font-style: italic } /* Literal.String.Doc */ -.highlight .s2 { color: #CC3300 } /* Literal.String.Double */ -.highlight .se { color: #CC3300; font-weight: bold } /* Literal.String.Escape */ -.highlight .sh { color: #CC3300 } /* Literal.String.Heredoc */ -.highlight .si { color: #AA0000 } /* Literal.String.Interpol */ -.highlight .sx { color: #CC3300 } /* Literal.String.Other */ -.highlight .sr { color: #33AAAA } /* Literal.String.Regex */ -.highlight .s1 { color: #CC3300 } /* Literal.String.Single */ -.highlight .ss { color: #FFCC33 } /* Literal.String.Symbol */ -.highlight .bp { color: #336666 } /* Name.Builtin.Pseudo */ -.highlight .vc { color: #003333 } /* Name.Variable.Class */ -.highlight .vg { color: #003333 } /* Name.Variable.Global */ -.highlight .vi { color: #003333 } /* Name.Variable.Instance */ -.highlight .il { color: #FF6600 } /* Literal.Number.Integer.Long */ - -.type-csharp .highlight .k { color: #0000FF } -.type-csharp .highlight .kt { color: #0000FF } -.type-csharp .highlight .nf { color: #000000; font-weight: normal } -.type-csharp .highlight .nc { color: #2B91AF } -.type-csharp .highlight .nn { color: #000000 } -.type-csharp .highlight .s { color: #A31515 } -.type-csharp .highlight .sc { color: #A31515 } diff --git a/stylesheets/stylesheet.css b/stylesheets/stylesheet.css deleted file mode 100644 index 2bd468a..0000000 --- a/stylesheets/stylesheet.css +++ /dev/null @@ -1,431 +0,0 @@ -/******************************************************************************* -Slate Theme for GitHub Pages -by Jason Costello, @jsncostello -*******************************************************************************/ - -@import url(pygment_trac.css); - -/******************************************************************************* -MeyerWeb Reset -*******************************************************************************/ - -html, body, div, span, applet, object, iframe, -h1, h2, h3, h4, h5, h6, p, blockquote, pre, -a, abbr, acronym, address, big, cite, code, -del, dfn, em, img, ins, kbd, q, s, samp, -small, strike, strong, sub, sup, tt, var, -b, u, i, center, -dl, dt, dd, ol, ul, li, -fieldset, form, label, legend, -table, caption, tbody, tfoot, thead, tr, th, td, -article, aside, canvas, details, embed, -figure, figcaption, footer, header, hgroup, -menu, nav, output, ruby, section, summary, -time, mark, audio, video { - margin: 0; - padding: 0; - border: 0; - font: inherit; - vertical-align: baseline; -} - -/* HTML5 display-role reset for older browsers */ -article, aside, details, figcaption, figure, -footer, header, hgroup, menu, nav, section { - display: block; -} - -ol, ul { - list-style: none; -} - -blockquote, q { -} - -table { - border-collapse: collapse; - border-spacing: 0; -} - -a:focus { - outline: none; -} - -/******************************************************************************* -Theme Styles -*******************************************************************************/ - -body { - box-sizing: border-box; - color:#373737; - background: #212121; - font-size: 16px; - font-family: 'Myriad Pro', Calibri, Helvetica, Arial, sans-serif; - line-height: 1.5; - -webkit-font-smoothing: antialiased; -} - -h1, h2, h3, h4, h5, h6 { - margin: 10px 0; - font-weight: 700; - color:#222222; - font-family: 'Lucida Grande', 'Calibri', Helvetica, Arial, sans-serif; - letter-spacing: -1px; -} - -h1 { - font-size: 36px; - font-weight: 700; -} - -h2 { - padding-bottom: 10px; - font-size: 32px; - background: url('../images/bg_hr.png') repeat-x bottom; -} - -h3 { - font-size: 24px; -} - -h4 { - font-size: 21px; -} - -h5 { - font-size: 18px; -} - -h6 { - font-size: 16px; -} - -p { - margin: 10px 0 15px 0; -} - -footer p { - color: #f2f2f2; -} - -a { - text-decoration: none; - color: #007edf; - text-shadow: none; - - transition: color 0.5s ease; - transition: text-shadow 0.5s ease; - -webkit-transition: color 0.5s ease; - -webkit-transition: text-shadow 0.5s ease; - -moz-transition: color 0.5s ease; - -moz-transition: text-shadow 0.5s ease; - -o-transition: color 0.5s ease; - -o-transition: text-shadow 0.5s ease; - -ms-transition: color 0.5s ease; - -ms-transition: text-shadow 0.5s ease; -} - -#main_content a:hover { - color: #0069ba; - text-shadow: #0090ff 0px 0px 2px; -} - -footer a:hover { - color: #43adff; - text-shadow: #0090ff 0px 0px 2px; -} - -em { - font-style: italic; -} - -strong { - font-weight: bold; -} - -img { - position: relative; - margin: 0 auto; - max-width: 739px; - padding: 5px; - margin: 10px 0 10px 0; - border: 1px solid #ebebeb; - - box-shadow: 0 0 5px #ebebeb; - -webkit-box-shadow: 0 0 5px #ebebeb; - -moz-box-shadow: 0 0 5px #ebebeb; - -o-box-shadow: 0 0 5px #ebebeb; - -ms-box-shadow: 0 0 5px #ebebeb; -} - -pre, code { - width: 100%; - color: #222; - background-color: #fff; - - font-family: Monaco, "Bitstream Vera Sans Mono", "Lucida Console", Terminal, monospace; - font-size: 14px; - - border-radius: 2px; - -moz-border-radius: 2px; - -webkit-border-radius: 2px; - - - -} - -pre { - width: 100%; - padding: 10px; - box-shadow: 0 0 10px rgba(0,0,0,.1); - overflow: auto; -} - -code { - padding: 3px; - margin: 0 3px; - box-shadow: 0 0 10px rgba(0,0,0,.1); -} - -pre code { - display: block; - box-shadow: none; -} - -blockquote { - color: #666; - margin-bottom: 20px; - padding: 0 0 0 20px; - border-left: 3px solid #bbb; -} - -ul, ol, dl { - margin-bottom: 15px -} - -ul li { - list-style: inside; - padding-left: 20px; -} - -ol li { - list-style: decimal inside; - padding-left: 20px; -} - -dl dt { - font-weight: bold; -} - -dl dd { - padding-left: 20px; - font-style: italic; -} - -dl p { - padding-left: 20px; - font-style: italic; -} - -hr { - height: 1px; - margin-bottom: 5px; - border: none; - background: url('../images/bg_hr.png') repeat-x center; -} - -table { - border: 1px solid #373737; - margin-bottom: 20px; - text-align: left; - } - -th { - font-family: 'Lucida Grande', 'Helvetica Neue', Helvetica, Arial, sans-serif; - padding: 10px; - background: #373737; - color: #fff; - } - -td { - padding: 10px; - border: 1px solid #373737; - } - -form { - background: #f2f2f2; - padding: 20px; -} - -img { - width: 100%; - max-width: 100%; -} - -/******************************************************************************* -Full-Width Styles -*******************************************************************************/ - -.outer { - width: 100%; -} - -.inner { - position: relative; - max-width: 640px; - padding: 20px 10px; - margin: 0 auto; -} - -#forkme_banner { - display: block; - position: absolute; - top:0; - right: 10px; - z-index: 10; - padding: 10px 50px 10px 10px; - color: #fff; - background: url('../images/blacktocat.png') #0090ff no-repeat 95% 50%; - font-weight: 700; - box-shadow: 0 0 10px rgba(0,0,0,.5); - border-bottom-left-radius: 2px; - border-bottom-right-radius: 2px; -} - -#header_wrap { - background: #212121; - background: -moz-linear-gradient(top, #373737, #212121); - background: -webkit-linear-gradient(top, #373737, #212121); - background: -ms-linear-gradient(top, #373737, #212121); - background: -o-linear-gradient(top, #373737, #212121); - background: linear-gradient(top, #373737, #212121); -} - -#header_wrap .inner { - padding: 50px 10px 30px 10px; -} - -#project_title { - margin: 0; - color: #fff; - font-size: 42px; - font-weight: 700; - text-shadow: #111 0px 0px 10px; -} - -#project_tagline { - color: #fff; - font-size: 24px; - font-weight: 300; - background: none; - text-shadow: #111 0px 0px 10px; -} - -#downloads { - position: absolute; - width: 210px; - z-index: 10; - bottom: -40px; - right: 0; - height: 70px; - background: url('../images/icon_download.png') no-repeat 0% 90%; -} - -.zip_download_link { - display: block; - float: right; - width: 90px; - height:70px; - text-indent: -5000px; - overflow: hidden; - background: url(../images/sprite_download.png) no-repeat bottom left; -} - -.tar_download_link { - display: block; - float: right; - width: 90px; - height:70px; - text-indent: -5000px; - overflow: hidden; - background: url(../images/sprite_download.png) no-repeat bottom right; - margin-left: 10px; -} - -.zip_download_link:hover { - background: url(../images/sprite_download.png) no-repeat top left; -} - -.tar_download_link:hover { - background: url(../images/sprite_download.png) no-repeat top right; -} - -#main_content_wrap { - background: #f2f2f2; - border-top: 1px solid #111; - border-bottom: 1px solid #111; -} - -#main_content { - padding-top: 40px; -} - -#footer_wrap { - background: #212121; -} - - - -/******************************************************************************* -Small Device Styles -*******************************************************************************/ - -@media screen and (max-width: 480px) { - body { - font-size:14px; - } - - #downloads { - display: none; - } - - .inner { - min-width: 320px; - max-width: 480px; - } - - #project_title { - font-size: 32px; - } - - h1 { - font-size: 28px; - } - - h2 { - font-size: 24px; - } - - h3 { - font-size: 21px; - } - - h4 { - font-size: 18px; - } - - h5 { - font-size: 14px; - } - - h6 { - font-size: 12px; - } - - code, pre { - min-width: 320px; - max-width: 480px; - font-size: 11px; - } - -}