| (--) [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.
|
| 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 [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.
|
| cycle [SequenceLabels] |
Cycle forever through the given sequence.
|
| cycle [Sequence] |
Cycle forever through the given sequence.
|
D | |
| doubleton [SequenceLabels] |
Sequence with exactly two elements
|
| doubleton [Sequence] |
Sequence with exactly two elements
|
| drop [SequenceLabels] |
Drop the
n first elements of the sequence.
|
| drop [Sequence] |
Drop the
n first elements of the sequence.
|
| drop_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
|
| find [SequenceLabels] |
Find the first element on which the function doesn't return
None
|
| find [Sequence] |
Find the first element on which the function doesn't return
None
|
| flat_map [SequenceLabels] |
Alias to
flatMap with a more explicit name
|
| flat_map [Sequence] |
Monadic bind.
|
| flat_map_l [SequenceLabels] |
Convenience function combining
SequenceLabels.flat_map and SequenceLabels.of_list
|
| flat_map_l [Sequence] |
Convenience function combining
Sequence.flat_map and Sequence.of_list
|
| flatten [SequenceLabels] |
Alias for
SequenceLabels.concat
|
| flatten [Sequence] |
Alias for
Sequence.concat
|
| fold [SequenceLabels] |
Fold over elements of the sequence, consuming it
|
| fold [Sequence] |
Fold over elements of the sequence, consuming it
|
| fold2 [SequenceLabels] | |
| fold2 [Sequence] | |
| fold_while [SequenceLabels] |
Folds over elements of the sequence, stopping early if the accumulator
returns
('a, `Stop)
|
| fold_while [Sequence] |
Folds over elements of the sequence, stopping early if the accumulator
returns
('a, `Stop)
|
| foldi [SequenceLabels] |
Fold over elements of the sequence and their index, consuming it
|
| foldi [Sequence] |
Fold over elements of the sequence and their index, consuming it
|
| for_all [SequenceLabels] |
Do all elements satisfy the predicate?
|
| for_all [Sequence] |
Do all elements satisfy the predicate?
|
| forever [SequenceLabels] |
Sequence that calls the given function to produce elements.
|
| forever [Sequence] |
Sequence that calls the given function to produce elements.
|
| 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_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 | |
| 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.
|
| 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.
|
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.
|
| 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.
|
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 | |
| 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
|
| 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.
|
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.
|
| 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
|