() [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 [Sequence]  
fold_while [SequenceLabels] 
Folds over elements of the sequence, stopping early if the accumulator
returns
('a, `Stop)

fold_while [Sequence] 
Folds over elements of the sequence, stopping early if the accumulator
returns
('a, `Stop)

foldi [SequenceLabels] 
Fold over elements of the sequence and their index, consuming it

foldi [Sequence] 
Fold over elements of the sequence and their index, consuming it

for_all [SequenceLabels] 
Do all elements satisfy the predicate?

for_all [Sequence] 
Do all elements satisfy the predicate?

forever [SequenceLabels] 
Sequence that calls the given function to produce elements.

forever [Sequence] 
Sequence that calls the given function to produce elements.

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 subsequence
in l .

seq_list [Sequence]  seq_list l returns all the ways to pick one element in each subsequence
in l .

seq_list_map [SequenceLabels]  
seq_list_map [Sequence]  
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
