diff --git a/api/Sequence.Map.Adapt.html b/api/Sequence.Map.Adapt.html new file mode 100644 index 0000000..07d6fd9 --- /dev/null +++ b/api/Sequence.Map.Adapt.html @@ -0,0 +1,41 @@ + + + + + + + + + + + + +Sequence.Map.Adapt + + +
 Up + Next +
+

Functor Sequence.Map.Adapt

+
module Adapt: 
functor (M : Map.S) -> S  with type key = M.key and type 'a map = 'a M.t
+Adapt a pre-existing Map module to make it sequence-aware
+
+ + + + + +
Parameters: + + + + +
+M:Map.S +
+
+
+
type +'a map
+ +
include Map.S
+
val to_seq : 'a map -> (key * 'a) Sequence.t
val of_seq : (key * 'a) Sequence.t -> 'a map
val keys : 'a map -> key Sequence.t
val values : 'a map -> 'a Sequence.t
\ No newline at end of file diff --git a/api/Sequence.Map.Make.html b/api/Sequence.Map.Make.html new file mode 100644 index 0000000..cc1bcf8 --- /dev/null +++ b/api/Sequence.Map.Make.html @@ -0,0 +1,41 @@ + + + + + + + + + + + + +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 +
+
+
+
type +'a map
+ +
include Map.S
+
val to_seq : 'a map -> (key * 'a) Sequence.t
val of_seq : (key * 'a) Sequence.t -> 'a map
val keys : 'a map -> key Sequence.t
val values : 'a map -> 'a Sequence.t
\ No newline at end of file diff --git a/api/Sequence.Map.S.html b/api/Sequence.Map.S.html new file mode 100644 index 0000000..6f4811d --- /dev/null +++ b/api/Sequence.Map.S.html @@ -0,0 +1,22 @@ + + + + + + + + + + + +Sequence.Map.S + + +
 Up + 
+

Module type Sequence.Map.S

+
module type S = sig .. end
+
type +'a map
+ +
include Map.S
+
val to_seq : 'a map -> (key * 'a) Sequence.t
val of_seq : (key * 'a) Sequence.t -> 'a map
val keys : 'a map -> key Sequence.t
val values : 'a map -> 'a Sequence.t
\ No newline at end of file diff --git a/api/Sequence.Map.html b/api/Sequence.Map.html new file mode 100644 index 0000000..3ff1f7b --- /dev/null +++ b/api/Sequence.Map.html @@ -0,0 +1,29 @@ + + + + + + + + + + + + + +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 map = '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 new file mode 100644 index 0000000..8284b03 --- /dev/null +++ b/api/Sequence.Set.Adapt.html @@ -0,0 +1,41 @@ + + + + + + + + + + + + +Sequence.Set.Adapt + + +
 Up + Next +
+

Functor Sequence.Set.Adapt

+
module Adapt: 
functor (X : Set.S) -> S  with type elt = X.elt and type set = X.t
+Create an enriched Set module from the given one
+
+ + + + + +
Parameters: + + + + +
+X:Set.S +
+
+
+
type set
+ +
include Set.S
+
val of_seq : elt Sequence.t -> set
val to_seq : set -> elt Sequence.t
\ No newline at end of file diff --git a/api/Sequence.Set.Make.html b/api/Sequence.Set.Make.html new file mode 100644 index 0000000..4564c3d --- /dev/null +++ b/api/Sequence.Set.Make.html @@ -0,0 +1,41 @@ + + + + + + + + + + + + +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 +
+
+
+
type set
+ +
include Set.S
+
val of_seq : elt Sequence.t -> set
val to_seq : set -> elt Sequence.t
\ No newline at end of file diff --git a/api/Sequence.Set.S.html b/api/Sequence.Set.S.html new file mode 100644 index 0000000..026fbc1 --- /dev/null +++ b/api/Sequence.Set.S.html @@ -0,0 +1,22 @@ + + + + + + + + + + + +Sequence.Set.S + + +
 Up + 
+

Module type Sequence.Set.S

+
module type S = sig .. end
+
type set
+ +
include Set.S
+
val of_seq : elt Sequence.t -> set
val to_seq : set -> elt Sequence.t
\ No newline at end of file diff --git a/api/Sequence.Set.html b/api/Sequence.Set.html new file mode 100644 index 0000000..5275185 --- /dev/null +++ b/api/Sequence.Set.html @@ -0,0 +1,27 @@ + + + + + + + + + + + + +Sequence.Set + + +
 Up + Next +
+

Module Sequence.Set

+
module Set: sig .. end
+
module type S = sig .. end
module Adapt: 
functor (X : Set.S) -> S  with type elt = X.elt and type set = X.t
+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 new file mode 100644 index 0000000..d0bc842 --- /dev/null +++ b/api/Sequence.TypeClass.html @@ -0,0 +1,79 @@ + + + + + + + + + + + + + + +Sequence.TypeClass + + +
Previous + Up + 
+

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 new file mode 100644 index 0000000..3454c9c --- /dev/null +++ b/api/Sequence.html @@ -0,0 +1,217 @@ + + + + + + + + + + + + + + + + + + + + +Sequence + + +
 Up + 
+

Module Sequence

+
module Sequence: sig .. end
+Transient iterators, that abstract on a finite sequence of elements. They + are designed to allow easy transfer (mappings) between data structures, + without defining n^2 conversions between the n types.
+
+
+
type +'a t
+
+Sequence abstract iterator type, representing a finite sequence of + values of type 'a.
+
+ +
+

Build a sequence


+
val from_iter : (('a -> unit) -> unit) -> 'a t
+Build a sequence from a iter function
+
+
val empty : 'a t
+Empty sequence
+
+
val singleton : 'a -> 'a t
+Singleton sequence
+
+
val repeat : 'a -> 'a t
+Infinite sequence of the same element
+
+
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
+
+
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).
+
+
+

Consume a sequence


+
val iter : ('a -> unit) -> 'a t -> unit
+Consume the sequence, passing all its arguments to the function
+
+
val iteri : (int -> 'a -> unit) -> 'a t -> unit
+Iterate on elements and their index in the sequence
+
+
val fold : ('b -> 'a -> 'b) -> 'b -> 'a t -> 'b
+Fold over elements of the sequence, consuming it
+
+
val foldi : ('b -> int -> 'a -> 'b) -> 'b -> 'a t -> 'b
+Fold over elements of the sequence and their index, consuming it
+
+
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 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 length : 'a t -> int
+How long is the sequence?
+
+
val is_empty : 'a t -> bool
+Is the sequence empty?
+
+
+

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
+
+
val concat : 'a t t -> 'a t
+Concatenate a sequence of sequences into one sequence
+
+
val flatMap : ('a -> 'b t) -> 'a t -> 'b t
+Monadic bind. It applies the function to every element of the + initial sequence, and calls concat.
+
+
val intersperse : 'a t -> 'a -> 'a t
+Insert the second element between every element of the sequence
+
+
val persistent : 'a t -> 'a t
+Iterate on the sequence, storing elements in a data structure. + The resulting sequence can be iterated on as many times as needed.
+
+
val product : 'a t -> 'b t -> ('a * 'b) t
+Cartesian product of the sequences. The first one is transformed + by calling persistent on it, so that it can be traversed + several times (outer loop of the product)
+
+
val 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 max : ?lt:('a -> 'a -> bool) -> 'a t -> 'a -> 'a
+Max element of the sequence, using the given comparison + function. A default element has to be provided.
+
+
val min : ?lt:('a -> 'a -> bool) -> 'a t -> 'a -> 'a
+Min element of the sequence, using the given comparison function
+
+
val take : int -> 'a t -> 'a t
+Take at most n elements from the sequence
+
+
val drop : int -> 'a t -> 'a t
+Drop the n first elements of the sequence
+
+
val rev : 'a t -> 'a t
+Reverse the sequence. O(n) memory and time.
+
+
+

Basic data structures converters


+
val to_list : 'a t -> 'a list
val to_rev_list : 'a t -> 'a list
+Get the list of the reversed sequence (more efficient)
+
+
val of_list : 'a list -> 'a t
val to_array : 'a t -> 'a array
+Convert to an array. Currently not very efficient because + and 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_stream : 'a Stream.t -> 'a t
+Sequence of elements of a stream
+
+
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 of_in_channel : Pervasives.in_channel -> char t
val to_buffer : char t -> Buffer.t -> unit
+Copy content of the sequence into the buffer
+
+
val int_range : start:int -> stop:int -> int t
+Iterator on integers in start...stop by steps 1
+
+
val 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
+
+
+

Functorial conversions between sets and sequences


+
module Set: sig .. end

+

Conversion between maps and sequences.


+
module Map: sig .. end

+

Infinite sequences of random values


+
val random_int : int -> int t
val random_bool : bool t
val random_float : float -> float t
val random_array : 'a array -> 'a t
+Sequence of choices of an element in the array
+
+
val random_list : 'a list -> 'a t

+

Type-classes


+
module TypeClass: sig .. end

+

Pretty printing of sequences


+
val pp_seq : ?sep:string ->
       (Format.formatter -> 'a -> unit) -> Format.formatter -> 'a t -> unit
+Pretty print a sequence of 'a, using the given pretty printer + to print each elements. An optional separator string can be provided.
+
+ \ No newline at end of file diff --git a/api/html.stamp b/api/html.stamp new file mode 100644 index 0000000..60d715c --- /dev/null +++ b/api/html.stamp @@ -0,0 +1 @@ +262ceaccb53cec41f6a06ae2253f2193 \ No newline at end of file diff --git a/api/index.html b/api/index.html new file mode 100644 index 0000000..db1821e --- /dev/null +++ b/api/index.html @@ -0,0 +1,29 @@ + + + + + + + + + + + + + +

+ +

+ + +
Sequence
+Transient iterators, that abstract on a finite sequence of elements. +
+
+ + \ No newline at end of file diff --git a/api/index_attributes.html b/api/index_attributes.html new file mode 100644 index 0000000..5f68e9c --- /dev/null +++ b/api/index_attributes.html @@ -0,0 +1,19 @@ + + + + + + + + + +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 new file mode 100644 index 0000000..dc35f10 --- /dev/null +++ b/api/index_class_types.html @@ -0,0 +1,19 @@ + + + + + + + + + +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 new file mode 100644 index 0000000..ba10ab9 --- /dev/null +++ b/api/index_classes.html @@ -0,0 +1,19 @@ + + + + + + + + + +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 new file mode 100644 index 0000000..2ea47cc --- /dev/null +++ b/api/index_exceptions.html @@ -0,0 +1,19 @@ + + + + + + + + + +Index of exceptions + + +
 Up + 
+

Index of exceptions

+ +
+ + \ No newline at end of file diff --git a/api/index_methods.html b/api/index_methods.html new file mode 100644 index 0000000..d1b975e --- /dev/null +++ b/api/index_methods.html @@ -0,0 +1,19 @@ + + + + + + + + + +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 new file mode 100644 index 0000000..5697df3 --- /dev/null +++ b/api/index_module_types.html @@ -0,0 +1,24 @@ + + + + + + + + + +Index of module types + + +
 Up + 
+

Index of module types

+ + + + + + +

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

Index of modules

+ + + + + + + + + + + + + + + + + + + + + +

A
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 +
+

M
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 [Sequence]

S
Sequence
+Transient iterators, that abstract on a finite sequence of elements. +
+
Set [Sequence]

T
TypeClass [Sequence]
+ + \ No newline at end of file diff --git a/api/index_types.html b/api/index_types.html new file mode 100644 index 0000000..b198ee1 --- /dev/null +++ b/api/index_types.html @@ -0,0 +1,45 @@ + + + + + + + + + +Index of types + + +
 Up + 
+

Index of types

+ + + + + + + + + + + + + + + + + + + + +

A
addable [Sequence.TypeClass]

I
iterable [Sequence.TypeClass]

M
map [Sequence.Map.S]
monoid [Sequence.TypeClass]

S
sequenceable [Sequence.TypeClass]
+Classes +
+
set [Sequence.Set.S]

T
t [Sequence]
+Sequence abstract iterator type, representing a finite sequence of + values of type 'a. +
+
+ + \ No newline at end of file diff --git a/api/index_values.html b/api/index_values.html new file mode 100644 index 0000000..935d067 --- /dev/null +++ b/api/index_values.html @@ -0,0 +1,332 @@ + + + + + + + + + +Index of values + + +
 Up + 
+

Index of values

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

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

C
concat [Sequence]
+Concatenate a sequence of sequences into one sequence +
+
cycle [Sequence]
+Cycle forever through the given sequence. +
+

D
drop [Sequence]
+Drop the n first elements of the sequence +
+

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

F
filter [Sequence]
+Filter on elements of the sequence +
+
flatMap [Sequence]
+Monadic bind. +
+
fold [Sequence]
+Fold over elements of the sequence, consuming it +
+
foldi [Sequence]
+Fold over elements of the sequence and their index, consuming it +
+
for_all [Sequence]
+Do all elements satisfy the predicate? +
+
forever [Sequence]
+Sequence that calls the given function to produce elements +
+
from_iter [Sequence]
+Build a sequence from a iter function +
+

H
hashtbl_add [Sequence]
+Add elements of the sequence to the hashtable, with + Hashtbl.add +
+
hashtbl_keys [Sequence]
hashtbl_replace [Sequence]
+Add elements of the sequence to the hashtable, with + Hashtbl.replace (erases conflicting bindings) +
+
hashtbl_values [Sequence]

I
int_range [Sequence]
+Iterator on integers in start...stop by steps 1 +
+
intersperse [Sequence]
+Insert the second element between every element of the sequence +
+
is_empty [Sequence]
+Is the sequence empty? +
+
iter [Sequence]
+Consume the sequence, passing all its arguments to the function +
+
iterable [Sequence.TypeClass]
iterate [Sequence]
+iterate f x is the infinite sequence (x, f(x), f(f(x)), ...) +
+
iteri [Sequence]
+Iterate on elements and their index in the sequence +
+

K
keys [Sequence.Map.S]

L
length [Sequence]
+How long is the sequence? +
+

M
map [Sequence]
+Map objects of the sequence into other elements, lazily +
+
mapi [Sequence]
+Map objects, along with their index in the sequence +
+
max [Sequence]
+Max element of the sequence, using the given comparison + function. +
+
min [Sequence]
+Min element of the sequence, using the given comparison function +
+
monoid [Sequence.TypeClass]

O
of_array [Sequence]
of_array_i [Sequence]
+Elements of the array, with their index +
+
of_hashtbl [Sequence]
+Sequence of key/value pairs from the hashtable +
+
of_in_channel [Sequence]
of_iterable [Sequence.TypeClass]
of_list [Sequence]
of_queue [Sequence]
+Sequence of elements contained in the queue, FIFO order +
+
of_seq [Sequence.Map.S]
of_seq [Sequence.Set.S]
of_set [Sequence]
+Convert the given set to a sequence. +
+
of_stack [Sequence]
+Sequence of elements of the stack (same order as Stack.iter) +
+
of_str [Sequence]
of_stream [Sequence]
+Sequence of elements of a stream +
+

P
persistent [Sequence]
+Iterate on the sequence, storing elements in a data structure. +
+
pp_seq [Sequence]
+Pretty print a sequence of 'a, using the given pretty printer + to print each elements. +
+
product [Sequence]
+Cartesian product of the sequences. +
+

R
random_array [Sequence]
+Sequence of choices of an element in the array +
+
random_bool [Sequence]
random_float [Sequence]
random_int [Sequence]
random_list [Sequence]
repeat [Sequence]
+Infinite sequence of the same element +
+
rev [Sequence]
+Reverse the sequence. +
+

S
sequenceable [Sequence.TypeClass]
singleton [Sequence]
+Singleton sequence +
+

T
take [Sequence]
+Take at most n elements from the sequence +
+
to_addable [Sequence.TypeClass]
to_array [Sequence]
+Convert to an array. +
+
to_buffer [Sequence]
+Copy content of the sequence into the buffer +
+
to_hashtbl [Sequence]
+Build a hashtable from a sequence of key/value pairs +
+
to_list [Sequence]
to_queue [Sequence]
+Push elements of the sequence into the queue +
+
to_rev_list [Sequence]
+Get the list of the reversed sequence (more efficient) +
+
to_seq [Sequence.Map.S]
to_seq [Sequence.Set.S]
to_set [Sequence]
+Convert the sequence to a set, given the proper set module +
+
to_stack [Sequence]
+Push elements of the sequence on the stack +
+
to_str [Sequence]

U
unfoldr [Sequence]
+unfoldr f b will apply f to b. +
+

V
values [Sequence.Map.S]
+ + \ No newline at end of file diff --git a/api/style.css b/api/style.css new file mode 100644 index 0000000..993fd5c --- /dev/null +++ b/api/style.css @@ -0,0 +1,41 @@ +.keyword { font-weight : bold ; color : Red } +.keywordsign { color : #C04600 } +.superscript { font-size : 4 } +.subscript { font-size : 4 } +.comment { color : Green } +.constructor { color : Blue } +.type { color : #5C6585 } +.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.Map.Adapt.html b/api/type_Sequence.Map.Adapt.html new file mode 100644 index 0000000..cc3c1df --- /dev/null +++ b/api/type_Sequence.Map.Adapt.html @@ -0,0 +1,46 @@ + + + + + + + + +Sequence.Map.Adapt + + +functor (M : Map.S) ->
+  sig
+    type 'a map = 'a M.t
+    type key = M.key
+    val empty : 'a map
+    val is_empty : 'a map -> bool
+    val mem : key -> 'a map -> bool
+    val add : key -> 'a -> 'a map -> 'a map
+    val singleton : key -> 'a -> 'a map
+    val remove : key -> 'a map -> 'a map
+    val merge :
+      (key -> 'a option -> 'b option -> 'c option) ->
+      'a map -> 'b map -> 'c map
+    val compare : ('a -> 'a -> int) -> 'a map -> 'a map -> int
+    val equal : ('a -> 'a -> bool) -> 'a map -> 'a map -> bool
+    val iter : (key -> 'a -> unit) -> 'a map -> unit
+    val fold : (key -> 'a -> 'b -> 'b) -> 'a map -> 'b -> 'b
+    val for_all : (key -> 'a -> bool) -> 'a map -> bool
+    val exists : (key -> 'a -> bool) -> 'a map -> bool
+    val filter : (key -> 'a -> bool) -> 'a map -> 'a map
+    val partition : (key -> 'a -> bool) -> 'a map -> 'a map * 'a map
+    val cardinal : 'a map -> int
+    val bindings : 'a map -> (key * 'a) list
+    val min_binding : 'a map -> key * 'a
+    val max_binding : 'a map -> key * 'a
+    val choose : 'a map -> key * 'a
+    val split : key -> 'a map -> 'a map * 'a option * 'a map
+    val find : key -> 'a map -> 'a
+    val map : ('a -> 'b) -> 'a map -> 'b map
+    val mapi : (key -> 'a -> 'b) -> 'a map -> 'b map
+    val to_seq : 'a map -> (key * 'a) t
+    val of_seq : (key * 'a) t -> 'a map
+    val keys : 'a map -> key t
+    val values : 'a map -> 'a t
+  end \ No newline at end of file diff --git a/api/type_Sequence.Map.Make.html b/api/type_Sequence.Map.Make.html new file mode 100644 index 0000000..34b67f0 --- /dev/null +++ b/api/type_Sequence.Map.Make.html @@ -0,0 +1,46 @@ + + + + + + + + +Sequence.Map.Make + + +functor (V : Map.OrderedType) ->
+  sig
+    type +'a map
+    type key = V.t
+    val empty : 'a map
+    val is_empty : 'a map -> bool
+    val mem : key -> 'a map -> bool
+    val add : key -> 'a -> 'a map -> 'a map
+    val singleton : key -> 'a -> 'a map
+    val remove : key -> 'a map -> 'a map
+    val merge :
+      (key -> 'a option -> 'b option -> 'c option) ->
+      'a map -> 'b map -> 'c map
+    val compare : ('a -> 'a -> int) -> 'a map -> 'a map -> int
+    val equal : ('a -> 'a -> bool) -> 'a map -> 'a map -> bool
+    val iter : (key -> 'a -> unit) -> 'a map -> unit
+    val fold : (key -> 'a -> 'b -> 'b) -> 'a map -> 'b -> 'b
+    val for_all : (key -> 'a -> bool) -> 'a map -> bool
+    val exists : (key -> 'a -> bool) -> 'a map -> bool
+    val filter : (key -> 'a -> bool) -> 'a map -> 'a map
+    val partition : (key -> 'a -> bool) -> 'a map -> 'a map * 'a map
+    val cardinal : 'a map -> int
+    val bindings : 'a map -> (key * 'a) list
+    val min_binding : 'a map -> key * 'a
+    val max_binding : 'a map -> key * 'a
+    val choose : 'a map -> key * 'a
+    val split : key -> 'a map -> 'a map * 'a option * 'a map
+    val find : key -> 'a map -> 'a
+    val map : ('a -> 'b) -> 'a map -> 'b map
+    val mapi : (key -> 'a -> 'b) -> 'a map -> 'b map
+    val to_seq : 'a map -> (key * 'a) t
+    val of_seq : (key * 'a) t -> 'a map
+    val keys : 'a map -> key t
+    val values : 'a map -> 'a t
+  end \ No newline at end of file diff --git a/api/type_Sequence.Map.S.html b/api/type_Sequence.Map.S.html new file mode 100644 index 0000000..e52c7f4 --- /dev/null +++ b/api/type_Sequence.Map.S.html @@ -0,0 +1,45 @@ + + + + + + + + +Sequence.Map.S + + +sig
+  type +'a map
+  type key
+  val empty : 'a map
+  val is_empty : 'a map -> bool
+  val mem : key -> 'a map -> bool
+  val add : key -> 'a -> 'a map -> 'a map
+  val singleton : key -> 'a -> 'a map
+  val remove : key -> 'a map -> 'a map
+  val merge :
+    (key -> 'a option -> 'b option -> 'c option) ->
+    'a map -> 'b map -> 'c map
+  val compare : ('a -> 'a -> int) -> 'a map -> 'a map -> int
+  val equal : ('a -> 'a -> bool) -> 'a map -> 'a map -> bool
+  val iter : (key -> 'a -> unit) -> 'a map -> unit
+  val fold : (key -> 'a -> 'b -> 'b) -> 'a map -> 'b -> 'b
+  val for_all : (key -> 'a -> bool) -> 'a map -> bool
+  val exists : (key -> 'a -> bool) -> 'a map -> bool
+  val filter : (key -> 'a -> bool) -> 'a map -> 'a map
+  val partition : (key -> 'a -> bool) -> 'a map -> 'a map * 'a map
+  val cardinal : 'a map -> int
+  val bindings : 'a map -> (key * 'a) list
+  val min_binding : 'a map -> key * 'a
+  val max_binding : 'a map -> key * 'a
+  val choose : 'a map -> key * 'a
+  val split : key -> 'a map -> 'a map * 'a option * 'a map
+  val find : key -> 'a map -> 'a
+  val map : ('a -> 'b) -> 'a map -> 'b map
+  val mapi : (key -> 'a -> 'b) -> 'a map -> 'b map
+  val to_seq : 'a Sequence.Map.S.map -> (key * 'a) Sequence.t
+  val of_seq : (key * 'a) Sequence.t -> 'a Sequence.Map.S.map
+  val keys : 'a Sequence.Map.S.map -> key Sequence.t
+  val values : 'a Sequence.Map.S.map -> 'a Sequence.t
+end \ No newline at end of file diff --git a/api/type_Sequence.Map.html b/api/type_Sequence.Map.html new file mode 100644 index 0000000..e3ab51e --- /dev/null +++ b/api/type_Sequence.Map.html @@ -0,0 +1,120 @@ + + + + + + + + +Sequence.Map + + +sig
+  module type S =
+    sig
+      type +'a map
+      type key
+      val empty : 'a map
+      val is_empty : 'a map -> bool
+      val mem : key -> 'a map -> bool
+      val add : key -> 'a -> 'a map -> 'a map
+      val singleton : key -> 'a -> 'a map
+      val remove : key -> 'a map -> 'a map
+      val merge :
+        (key -> 'a option -> 'b option -> 'c option) ->
+        'a map -> 'b map -> 'c map
+      val compare : ('a -> 'a -> int) -> 'a map -> 'a map -> int
+      val equal : ('a -> 'a -> bool) -> 'a map -> 'a map -> bool
+      val iter : (key -> 'a -> unit) -> 'a map -> unit
+      val fold : (key -> 'a -> 'b -> 'b) -> 'a map -> 'b -> 'b
+      val for_all : (key -> 'a -> bool) -> 'a map -> bool
+      val exists : (key -> 'a -> bool) -> 'a map -> bool
+      val filter : (key -> 'a -> bool) -> 'a map -> 'a map
+      val partition : (key -> 'a -> bool) -> 'a map -> 'a map * 'a map
+      val cardinal : 'a map -> int
+      val bindings : 'a map -> (key * 'a) list
+      val min_binding : 'a map -> key * 'a
+      val max_binding : 'a map -> key * 'a
+      val choose : 'a map -> key * 'a
+      val split : key -> 'a map -> 'a map * 'a option * 'a map
+      val find : key -> 'a map -> 'a
+      val map : ('a -> 'b) -> 'a map -> 'b map
+      val mapi : (key -> 'a -> 'b) -> 'a map -> 'b map
+      val to_seq : 'a Sequence.Map.S.map -> (key * 'a) Sequence.t
+      val of_seq : (key * 'a) Sequence.t -> 'a Sequence.Map.S.map
+      val keys : 'a Sequence.Map.S.map -> key Sequence.t
+      val values : 'a Sequence.Map.S.map -> 'a Sequence.t
+    end
+  module Adapt :
+    functor (M : Map.S) ->
+      sig
+        type 'a map = 'a M.t
+        type key = M.key
+        val empty : 'a map
+        val is_empty : 'a map -> bool
+        val mem : key -> 'a map -> bool
+        val add : key -> 'a -> 'a map -> 'a map
+        val singleton : key -> 'a -> 'a map
+        val remove : key -> 'a map -> 'a map
+        val merge :
+          (key -> 'a option -> 'b option -> 'c option) ->
+          'a map -> 'b map -> 'c map
+        val compare : ('a -> 'a -> int) -> 'a map -> 'a map -> int
+        val equal : ('a -> 'a -> bool) -> 'a map -> 'a map -> bool
+        val iter : (key -> 'a -> unit) -> 'a map -> unit
+        val fold : (key -> 'a -> 'b -> 'b) -> 'a map -> 'b -> 'b
+        val for_all : (key -> 'a -> bool) -> 'a map -> bool
+        val exists : (key -> 'a -> bool) -> 'a map -> bool
+        val filter : (key -> 'a -> bool) -> 'a map -> 'a map
+        val partition : (key -> 'a -> bool) -> 'a map -> 'a map * 'a map
+        val cardinal : 'a map -> int
+        val bindings : 'a map -> (key * 'a) list
+        val min_binding : 'a map -> key * 'a
+        val max_binding : 'a map -> key * 'a
+        val choose : 'a map -> key * 'a
+        val split : key -> 'a map -> 'a map * 'a option * 'a map
+        val find : key -> 'a map -> 'a
+        val map : ('a -> 'b) -> 'a map -> 'b map
+        val mapi : (key -> 'a -> 'b) -> 'a map -> 'b map
+        val to_seq : 'a map -> (key * 'a) t
+        val of_seq : (key * 'a) t -> 'a map
+        val keys : 'a map -> key t
+        val values : 'a map -> 'a t
+      end
+  module Make :
+    functor (V : Map.OrderedType) ->
+      sig
+        type +'a map
+        type key = V.t
+        val empty : 'a map
+        val is_empty : 'a map -> bool
+        val mem : key -> 'a map -> bool
+        val add : key -> 'a -> 'a map -> 'a map
+        val singleton : key -> 'a -> 'a map
+        val remove : key -> 'a map -> 'a map
+        val merge :
+          (key -> 'a option -> 'b option -> 'c option) ->
+          'a map -> 'b map -> 'c map
+        val compare : ('a -> 'a -> int) -> 'a map -> 'a map -> int
+        val equal : ('a -> 'a -> bool) -> 'a map -> 'a map -> bool
+        val iter : (key -> 'a -> unit) -> 'a map -> unit
+        val fold : (key -> 'a -> 'b -> 'b) -> 'a map -> 'b -> 'b
+        val for_all : (key -> 'a -> bool) -> 'a map -> bool
+        val exists : (key -> 'a -> bool) -> 'a map -> bool
+        val filter : (key -> 'a -> bool) -> 'a map -> 'a map
+        val partition : (key -> 'a -> bool) -> 'a map -> 'a map * 'a map
+        val cardinal : 'a map -> int
+        val bindings : 'a map -> (key * 'a) list
+        val min_binding : 'a map -> key * 'a
+        val max_binding : 'a map -> key * 'a
+        val choose : 'a map -> key * 'a
+        val split : key -> 'a map -> 'a map * 'a option * 'a map
+        val find : key -> 'a map -> 'a
+        val map : ('a -> 'b) -> 'a map -> 'b map
+        val mapi : (key -> 'a -> 'b) -> 'a map -> 'b map
+        val to_seq : 'a map -> (key * 'a) t
+        val of_seq : (key * 'a) t -> 'a map
+        val keys : 'a map -> key t
+        val values : 'a map -> 'a t
+      end
+end \ No newline at end of file diff --git a/api/type_Sequence.Set.Adapt.html b/api/type_Sequence.Set.Adapt.html new file mode 100644 index 0000000..ac941bb --- /dev/null +++ b/api/type_Sequence.Set.Adapt.html @@ -0,0 +1,42 @@ + + + + + + + + +Sequence.Set.Adapt + + +functor (X : Set.S) ->
+  sig
+    type set = X.t
+    type elt = X.elt
+    val empty : set
+    val is_empty : set -> bool
+    val mem : elt -> set -> bool
+    val add : elt -> set -> set
+    val singleton : elt -> set
+    val remove : elt -> set -> set
+    val union : set -> set -> set
+    val inter : set -> set -> set
+    val diff : set -> set -> set
+    val compare : set -> set -> int
+    val equal : set -> set -> bool
+    val subset : set -> set -> bool
+    val iter : (elt -> unit) -> set -> unit
+    val fold : (elt -> 'a -> 'a) -> set -> 'a -> 'a
+    val for_all : (elt -> bool) -> set -> bool
+    val exists : (elt -> bool) -> set -> bool
+    val filter : (elt -> bool) -> set -> set
+    val partition : (elt -> bool) -> set -> set * set
+    val cardinal : set -> int
+    val elements : set -> elt list
+    val min_elt : set -> elt
+    val max_elt : set -> elt
+    val choose : set -> elt
+    val split : elt -> set -> set * bool * set
+    val of_seq : elt t -> set
+    val to_seq : set -> elt t
+  end \ No newline at end of file diff --git a/api/type_Sequence.Set.Make.html b/api/type_Sequence.Set.Make.html new file mode 100644 index 0000000..5882212 --- /dev/null +++ b/api/type_Sequence.Set.Make.html @@ -0,0 +1,42 @@ + + + + + + + + +Sequence.Set.Make + + +functor (X : Set.OrderedType) ->
+  sig
+    type set
+    type elt = X.t
+    val empty : set
+    val is_empty : set -> bool
+    val mem : elt -> set -> bool
+    val add : elt -> set -> set
+    val singleton : elt -> set
+    val remove : elt -> set -> set
+    val union : set -> set -> set
+    val inter : set -> set -> set
+    val diff : set -> set -> set
+    val compare : set -> set -> int
+    val equal : set -> set -> bool
+    val subset : set -> set -> bool
+    val iter : (elt -> unit) -> set -> unit
+    val fold : (elt -> 'a -> 'a) -> set -> 'a -> 'a
+    val for_all : (elt -> bool) -> set -> bool
+    val exists : (elt -> bool) -> set -> bool
+    val filter : (elt -> bool) -> set -> set
+    val partition : (elt -> bool) -> set -> set * set
+    val cardinal : set -> int
+    val elements : set -> elt list
+    val min_elt : set -> elt
+    val max_elt : set -> elt
+    val choose : set -> elt
+    val split : elt -> set -> set * bool * set
+    val of_seq : elt t -> set
+    val to_seq : set -> elt t
+  end \ No newline at end of file diff --git a/api/type_Sequence.Set.S.html b/api/type_Sequence.Set.S.html new file mode 100644 index 0000000..7ac2b38 --- /dev/null +++ b/api/type_Sequence.Set.S.html @@ -0,0 +1,41 @@ + + + + + + + + +Sequence.Set.S + + +sig
+  type set
+  type elt
+  val empty : set
+  val is_empty : set -> bool
+  val mem : elt -> set -> bool
+  val add : elt -> set -> set
+  val singleton : elt -> set
+  val remove : elt -> set -> set
+  val union : set -> set -> set
+  val inter : set -> set -> set
+  val diff : set -> set -> set
+  val compare : set -> set -> int
+  val equal : set -> set -> bool
+  val subset : set -> set -> bool
+  val iter : (elt -> unit) -> set -> unit
+  val fold : (elt -> 'a -> 'a) -> set -> 'a -> 'a
+  val for_all : (elt -> bool) -> set -> bool
+  val exists : (elt -> bool) -> set -> bool
+  val filter : (elt -> bool) -> set -> set
+  val partition : (elt -> bool) -> set -> set * set
+  val cardinal : set -> int
+  val elements : set -> elt list
+  val min_elt : set -> elt
+  val max_elt : set -> elt
+  val choose : set -> elt
+  val split : elt -> set -> set * bool * set
+  val of_seq : elt Sequence.t -> Sequence.Set.S.set
+  val to_seq : Sequence.Set.S.set -> elt Sequence.t
+end \ No newline at end of file diff --git a/api/type_Sequence.Set.html b/api/type_Sequence.Set.html new file mode 100644 index 0000000..b6d35fc --- /dev/null +++ b/api/type_Sequence.Set.html @@ -0,0 +1,108 @@ + + + + + + + + +Sequence.Set + + +sig
+  module type S =
+    sig
+      type set
+      type elt
+      val empty : set
+      val is_empty : set -> bool
+      val mem : elt -> set -> bool
+      val add : elt -> set -> set
+      val singleton : elt -> set
+      val remove : elt -> set -> set
+      val union : set -> set -> set
+      val inter : set -> set -> set
+      val diff : set -> set -> set
+      val compare : set -> set -> int
+      val equal : set -> set -> bool
+      val subset : set -> set -> bool
+      val iter : (elt -> unit) -> set -> unit
+      val fold : (elt -> 'a -> 'a) -> set -> 'a -> 'a
+      val for_all : (elt -> bool) -> set -> bool
+      val exists : (elt -> bool) -> set -> bool
+      val filter : (elt -> bool) -> set -> set
+      val partition : (elt -> bool) -> set -> set * set
+      val cardinal : set -> int
+      val elements : set -> elt list
+      val min_elt : set -> elt
+      val max_elt : set -> elt
+      val choose : set -> elt
+      val split : elt -> set -> set * bool * set
+      val of_seq : elt Sequence.t -> Sequence.Set.S.set
+      val to_seq : Sequence.Set.S.set -> elt Sequence.t
+    end
+  module Adapt :
+    functor (X : Set.S) ->
+      sig
+        type set = X.t
+        type elt = X.elt
+        val empty : set
+        val is_empty : set -> bool
+        val mem : elt -> set -> bool
+        val add : elt -> set -> set
+        val singleton : elt -> set
+        val remove : elt -> set -> set
+        val union : set -> set -> set
+        val inter : set -> set -> set
+        val diff : set -> set -> set
+        val compare : set -> set -> int
+        val equal : set -> set -> bool
+        val subset : set -> set -> bool
+        val iter : (elt -> unit) -> set -> unit
+        val fold : (elt -> 'a -> 'a) -> set -> 'a -> 'a
+        val for_all : (elt -> bool) -> set -> bool
+        val exists : (elt -> bool) -> set -> bool
+        val filter : (elt -> bool) -> set -> set
+        val partition : (elt -> bool) -> set -> set * set
+        val cardinal : set -> int
+        val elements : set -> elt list
+        val min_elt : set -> elt
+        val max_elt : set -> elt
+        val choose : set -> elt
+        val split : elt -> set -> set * bool * set
+        val of_seq : elt t -> set
+        val to_seq : set -> elt t
+      end
+  module Make :
+    functor (X : Set.OrderedType) ->
+      sig
+        type set
+        type elt = X.t
+        val empty : set
+        val is_empty : set -> bool
+        val mem : elt -> set -> bool
+        val add : elt -> set -> set
+        val singleton : elt -> set
+        val remove : elt -> set -> set
+        val union : set -> set -> set
+        val inter : set -> set -> set
+        val diff : set -> set -> set
+        val compare : set -> set -> int
+        val equal : set -> set -> bool
+        val subset : set -> set -> bool
+        val iter : (elt -> unit) -> set -> unit
+        val fold : (elt -> 'a -> 'a) -> set -> 'a -> 'a
+        val for_all : (elt -> bool) -> set -> bool
+        val exists : (elt -> bool) -> set -> bool
+        val filter : (elt -> bool) -> set -> set
+        val partition : (elt -> bool) -> set -> set * set
+        val cardinal : set -> int
+        val elements : set -> elt list
+        val min_elt : set -> elt
+        val max_elt : set -> elt
+        val choose : set -> elt
+        val split : elt -> set -> set * bool * set
+        val of_seq : elt t -> set
+        val to_seq : set -> elt t
+      end
+end \ No newline at end of file diff --git a/api/type_Sequence.TypeClass.html b/api/type_Sequence.TypeClass.html new file mode 100644 index 0000000..93c139f --- /dev/null +++ b/api/type_Sequence.TypeClass.html @@ -0,0 +1,26 @@ + + + + + + + + +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 new file mode 100644 index 0000000..36346a6 --- /dev/null +++ b/api/type_Sequence.html @@ -0,0 +1,305 @@ + + + + + + + + +Sequence + + +sig
+  type +'a t
+  val from_iter : (('a -> unit) -> unit) -> 'a Sequence.t
+  val empty : 'a Sequence.t
+  val singleton : 'a -> 'a Sequence.t
+  val repeat : 'a -> 'a Sequence.t
+  val iterate : ('a -> 'a) -> 'a -> 'a Sequence.t
+  val forever : (unit -> 'b) -> 'b Sequence.t
+  val cycle : 'a Sequence.t -> 'a Sequence.t
+  val iter : ('a -> unit) -> 'a Sequence.t -> unit
+  val iteri : (int -> 'a -> unit) -> 'a Sequence.t -> unit
+  val fold : ('b -> 'a -> 'b) -> 'b -> 'a Sequence.t -> 'b
+  val foldi : ('b -> int -> 'a -> 'b) -> 'b -> 'a Sequence.t -> 'b
+  val map : ('a -> 'b) -> 'a Sequence.t -> 'b Sequence.t
+  val mapi : (int -> 'a -> 'b) -> 'a Sequence.t -> 'b Sequence.t
+  val for_all : ('a -> bool) -> 'a Sequence.t -> bool
+  val exists : ('a -> bool) -> 'a Sequence.t -> bool
+  val length : 'a Sequence.t -> int
+  val is_empty : 'a Sequence.t -> bool
+  val filter : ('a -> bool) -> 'a Sequence.t -> 'a Sequence.t
+  val append : 'a Sequence.t -> 'a Sequence.t -> 'a Sequence.t
+  val concat : 'a Sequence.t Sequence.t -> 'a Sequence.t
+  val flatMap : ('a -> 'b Sequence.t) -> 'a Sequence.t -> 'b Sequence.t
+  val intersperse : 'a Sequence.t -> 'a -> 'a Sequence.t
+  val persistent : 'a Sequence.t -> 'a Sequence.t
+  val product : 'a Sequence.t -> 'b Sequence.t -> ('a * 'b) Sequence.t
+  val unfoldr : ('b -> ('a * 'b) option) -> 'b -> 'a Sequence.t
+  val max : ?lt:('a -> 'a -> bool) -> 'a Sequence.t -> 'a -> 'a
+  val min : ?lt:('a -> 'a -> bool) -> 'a Sequence.t -> 'a -> 'a
+  val take : int -> 'a Sequence.t -> 'a Sequence.t
+  val drop : int -> 'a Sequence.t -> 'a Sequence.t
+  val rev : 'a Sequence.t -> 'a Sequence.t
+  val to_list : 'a Sequence.t -> 'a list
+  val to_rev_list : 'a Sequence.t -> 'a list
+  val of_list : 'a list -> 'a Sequence.t
+  val to_array : 'a Sequence.t -> 'a array
+  val of_array : 'a array -> 'a Sequence.t
+  val of_array_i : 'a array -> (int * 'a) Sequence.t
+  val array_slice : 'a array -> int -> int -> 'a Sequence.t
+  val of_stream : 'a Stream.t -> 'a Sequence.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 of_hashtbl : ('a, 'b) Hashtbl.t -> ('a * 'b) Sequence.t
+  val hashtbl_keys : ('a, 'b) Hashtbl.t -> 'a Sequence.t
+  val hashtbl_values : ('a, 'b) Hashtbl.t -> 'b Sequence.t
+  val of_str : string -> char Sequence.t
+  val to_str : char Sequence.t -> string
+  val of_in_channel : Pervasives.in_channel -> char Sequence.t
+  val to_buffer : char Sequence.t -> Buffer.t -> unit
+  val int_range : start:int -> stop:int -> int Sequence.t
+  val of_set :
+    (module Set.S with type elt = 'a and type t = 'b) -> 'b -> 'a Sequence.t
+  val to_set :
+    (module Set.S with type elt = 'a and type t = 'b) -> 'a Sequence.t -> 'b
+  module Set :
+    sig
+      module type S =
+        sig
+          type set
+          type elt
+          val empty : set
+          val is_empty : set -> bool
+          val mem : elt -> set -> bool
+          val add : elt -> set -> set
+          val singleton : elt -> set
+          val remove : elt -> set -> set
+          val union : set -> set -> set
+          val inter : set -> set -> set
+          val diff : set -> set -> set
+          val compare : set -> set -> int
+          val equal : set -> set -> bool
+          val subset : set -> set -> bool
+          val iter : (elt -> unit) -> set -> unit
+          val fold : (elt -> 'a -> 'a) -> set -> 'a -> 'a
+          val for_all : (elt -> bool) -> set -> bool
+          val exists : (elt -> bool) -> set -> bool
+          val filter : (elt -> bool) -> set -> set
+          val partition : (elt -> bool) -> set -> set * set
+          val cardinal : set -> int
+          val elements : set -> elt list
+          val min_elt : set -> elt
+          val max_elt : set -> elt
+          val choose : set -> elt
+          val split : elt -> set -> set * bool * set
+          val of_seq : elt Sequence.t -> Sequence.Set.S.set
+          val to_seq : Sequence.Set.S.set -> elt Sequence.t
+        end
+      module Adapt :
+        functor (X : Set.S) ->
+          sig
+            type set = X.t
+            type elt = X.elt
+            val empty : set
+            val is_empty : set -> bool
+            val mem : elt -> set -> bool
+            val add : elt -> set -> set
+            val singleton : elt -> set
+            val remove : elt -> set -> set
+            val union : set -> set -> set
+            val inter : set -> set -> set
+            val diff : set -> set -> set
+            val compare : set -> set -> int
+            val equal : set -> set -> bool
+            val subset : set -> set -> bool
+            val iter : (elt -> unit) -> set -> unit
+            val fold : (elt -> 'a -> 'a) -> set -> 'a -> 'a
+            val for_all : (elt -> bool) -> set -> bool
+            val exists : (elt -> bool) -> set -> bool
+            val filter : (elt -> bool) -> set -> set
+            val partition : (elt -> bool) -> set -> set * set
+            val cardinal : set -> int
+            val elements : set -> elt list
+            val min_elt : set -> elt
+            val max_elt : set -> elt
+            val choose : set -> elt
+            val split : elt -> set -> set * bool * set
+            val of_seq : elt t -> set
+            val to_seq : set -> elt t
+          end
+      module Make :
+        functor (X : Set.OrderedType) ->
+          sig
+            type set
+            type elt = X.t
+            val empty : set
+            val is_empty : set -> bool
+            val mem : elt -> set -> bool
+            val add : elt -> set -> set
+            val singleton : elt -> set
+            val remove : elt -> set -> set
+            val union : set -> set -> set
+            val inter : set -> set -> set
+            val diff : set -> set -> set
+            val compare : set -> set -> int
+            val equal : set -> set -> bool
+            val subset : set -> set -> bool
+            val iter : (elt -> unit) -> set -> unit
+            val fold : (elt -> 'a -> 'a) -> set -> 'a -> 'a
+            val for_all : (elt -> bool) -> set -> bool
+            val exists : (elt -> bool) -> set -> bool
+            val filter : (elt -> bool) -> set -> set
+            val partition : (elt -> bool) -> set -> set * set
+            val cardinal : set -> int
+            val elements : set -> elt list
+            val min_elt : set -> elt
+            val max_elt : set -> elt
+            val choose : set -> elt
+            val split : elt -> set -> set * bool * set
+            val of_seq : elt t -> set
+            val to_seq : set -> elt t
+          end
+    end
+  module Map :
+    sig
+      module type S =
+        sig
+          type +'a map
+          type key
+          val empty : 'a map
+          val is_empty : 'a map -> bool
+          val mem : key -> 'a map -> bool
+          val add : key -> 'a -> 'a map -> 'a map
+          val singleton : key -> 'a -> 'a map
+          val remove : key -> 'a map -> 'a map
+          val merge :
+            (key -> 'a option -> 'b option -> 'c option) ->
+            'a map -> 'b map -> 'c map
+          val compare : ('a -> 'a -> int) -> 'a map -> 'a map -> int
+          val equal : ('a -> 'a -> bool) -> 'a map -> 'a map -> bool
+          val iter : (key -> 'a -> unit) -> 'a map -> unit
+          val fold : (key -> 'a -> 'b -> 'b) -> 'a map -> 'b -> 'b
+          val for_all : (key -> 'a -> bool) -> 'a map -> bool
+          val exists : (key -> 'a -> bool) -> 'a map -> bool
+          val filter : (key -> 'a -> bool) -> 'a map -> 'a map
+          val partition : (key -> 'a -> bool) -> 'a map -> 'a map * 'a map
+          val cardinal : 'a map -> int
+          val bindings : 'a map -> (key * 'a) list
+          val min_binding : 'a map -> key * 'a
+          val max_binding : 'a map -> key * 'a
+          val choose : 'a map -> key * 'a
+          val split : key -> 'a map -> 'a map * 'a option * 'a map
+          val find : key -> 'a map -> 'a
+          val map : ('a -> 'b) -> 'a map -> 'b map
+          val mapi : (key -> 'a -> 'b) -> 'a map -> 'b map
+          val to_seq : 'a Sequence.Map.S.map -> (key * 'a) Sequence.t
+          val of_seq : (key * 'a) Sequence.t -> 'a Sequence.Map.S.map
+          val keys : 'a Sequence.Map.S.map -> key Sequence.t
+          val values : 'a Sequence.Map.S.map -> 'a Sequence.t
+        end
+      module Adapt :
+        functor (M : Map.S) ->
+          sig
+            type 'a map = 'a M.t
+            type key = M.key
+            val empty : 'a map
+            val is_empty : 'a map -> bool
+            val mem : key -> 'a map -> bool
+            val add : key -> 'a -> 'a map -> 'a map
+            val singleton : key -> 'a -> 'a map
+            val remove : key -> 'a map -> 'a map
+            val merge :
+              (key -> 'a option -> 'b option -> 'c option) ->
+              'a map -> 'b map -> 'c map
+            val compare : ('a -> 'a -> int) -> 'a map -> 'a map -> int
+            val equal : ('a -> 'a -> bool) -> 'a map -> 'a map -> bool
+            val iter : (key -> 'a -> unit) -> 'a map -> unit
+            val fold : (key -> 'a -> 'b -> 'b) -> 'a map -> 'b -> 'b
+            val for_all : (key -> 'a -> bool) -> 'a map -> bool
+            val exists : (key -> 'a -> bool) -> 'a map -> bool
+            val filter : (key -> 'a -> bool) -> 'a map -> 'a map
+            val partition : (key -> 'a -> bool) -> 'a map -> 'a map * 'a map
+            val cardinal : 'a map -> int
+            val bindings : 'a map -> (key * 'a) list
+            val min_binding : 'a map -> key * 'a
+            val max_binding : 'a map -> key * 'a
+            val choose : 'a map -> key * 'a
+            val split : key -> 'a map -> 'a map * 'a option * 'a map
+            val find : key -> 'a map -> 'a
+            val map : ('a -> 'b) -> 'a map -> 'b map
+            val mapi : (key -> 'a -> 'b) -> 'a map -> 'b map
+            val to_seq : 'a map -> (key * 'a) t
+            val of_seq : (key * 'a) t -> 'a map
+            val keys : 'a map -> key t
+            val values : 'a map -> 'a t
+          end
+      module Make :
+        functor (V : Map.OrderedType) ->
+          sig
+            type +'a map
+            type key = V.t
+            val empty : 'a map
+            val is_empty : 'a map -> bool
+            val mem : key -> 'a map -> bool
+            val add : key -> 'a -> 'a map -> 'a map
+            val singleton : key -> 'a -> 'a map
+            val remove : key -> 'a map -> 'a map
+            val merge :
+              (key -> 'a option -> 'b option -> 'c option) ->
+              'a map -> 'b map -> 'c map
+            val compare : ('a -> 'a -> int) -> 'a map -> 'a map -> int
+            val equal : ('a -> 'a -> bool) -> 'a map -> 'a map -> bool
+            val iter : (key -> 'a -> unit) -> 'a map -> unit
+            val fold : (key -> 'a -> 'b -> 'b) -> 'a map -> 'b -> 'b
+            val for_all : (key -> 'a -> bool) -> 'a map -> bool
+            val exists : (key -> 'a -> bool) -> 'a map -> bool
+            val filter : (key -> 'a -> bool) -> 'a map -> 'a map
+            val partition : (key -> 'a -> bool) -> 'a map -> 'a map * 'a map
+            val cardinal : 'a map -> int
+            val bindings : 'a map -> (key * 'a) list
+            val min_binding : 'a map -> key * 'a
+            val max_binding : 'a map -> key * 'a
+            val choose : 'a map -> key * 'a
+            val split : key -> 'a map -> 'a map * 'a option * 'a map
+            val find : key -> 'a map -> 'a
+            val map : ('a -> 'b) -> 'a map -> 'b map
+            val mapi : (key -> 'a -> 'b) -> 'a map -> 'b map
+            val to_seq : 'a map -> (key * 'a) t
+            val of_seq : (key * 'a) t -> 'a map
+            val keys : 'a map -> key t
+            val values : 'a map -> 'a t
+          end
+    end
+  val random_int : int -> int Sequence.t
+  val random_bool : bool Sequence.t
+  val random_float : float -> float Sequence.t
+  val random_array : 'a array -> 'a Sequence.t
+  val random_list : 'a list -> 'a Sequence.t
+  module TypeClass :
+    sig
+      type ('a, 'b) sequenceable = {
+        to_seq : 'b -> 'a Sequence.t;
+        of_seq : 'a Sequence.t -> 'b;
+      }
+      type ('a, 'b) addable = { empty : 'b; add : 'b -> 'a -> 'b; }
+      type 'a monoid = ('a, 'a) Sequence.TypeClass.addable
+      type ('a, 'b) iterable = { iter : ('a -> unit) -> 'b -> unit; }
+      val sequenceable : ('a, 'a Sequence.t) Sequence.TypeClass.sequenceable
+      val iterable : ('a, 'a Sequence.t) Sequence.TypeClass.iterable
+      val monoid : 'a Sequence.t Sequence.TypeClass.monoid
+      val of_iterable :
+        ('a, 'b) Sequence.TypeClass.iterable -> 'b -> 'a Sequence.t
+      val to_addable :
+        ('a, 'b) Sequence.TypeClass.addable -> 'a Sequence.t -> 'b
+    end
+  val pp_seq :
+    ?sep:string ->
+    (Format.formatter -> 'a -> unit) ->
+    Format.formatter -> 'a Sequence.t -> unit
+end \ No newline at end of file diff --git a/index.html b/index.html index 20d3c32..923a0af 100644 --- a/index.html +++ b/index.html @@ -32,6 +32,7 @@

Sequence

+ Here is the documentation generated from the source.