| (--) [Sequence.Infix] | |
| (@@) [Sequence.Infix] | |
| (|>) [Sequence.Infix] | |
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
|
| empty2 [Sequence] | |
| exists [Sequence] |
Exists there some element satisfying the predicate?
|
F | |
| filter [Sequence] |
Filter on elements of the sequence
|
| flatMap [Sequence] |
Monadic bind.
|
| flatten [Sequence] |
Alias for
Sequence.concat
|
| fold [Sequence] |
Fold over elements of the sequence, consuming it
|
| fold2 [Sequence] | |
| 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_fun [Sequence] |
Call the function repeatedly until it returns None.
|
| from_iter [Sequence] |
Build a sequence from a iter function
|
G | |
| group [Sequence] |
Group equal consecutive elements.
|
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?
|
| is_empty2 [Sequence] | |
| iter [Sequence] |
Consume the sequence, passing all its arguments to the function
|
| iter2 [Sequence] | |
| 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
|
J | |
| join [Sequence] | join ~join_row a b combines every element of a with every
element of b using join_row.
|
K | |
| keys [Sequence.Map.S] | |
L | |
| length [Sequence] |
How long is the sequence?
|
| length2 [Sequence] | |
M | |
| map [Sequence] |
Map objects of the sequence into other elements, lazily
|
| map2 [Sequence] | |
| map2_2 [Sequence] | map2_2 f g seq2 maps each x, y of seq2 into f x y, g x y
|
| 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_array2 [Sequence] | |
| of_array_i [Sequence] |
Elements of the array, with their index
|
| of_hashtbl [Sequence] |
Sequence of key/value pairs from the hashtable
|
| of_hashtbl2 [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 (usable only once)
|
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 | |
| scan [Sequence] |
Sequence of intermediate results
|
| sequenceable [Sequence.TypeClass] | |
| singleton [Sequence] |
Singleton sequence
|
| sort [Sequence] |
Sort the sequence.
|
| sort_uniq [Sequence] |
Sort the sequence and remove duplicates.
|
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_hashtbl2 [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] | |
| to_stream [Sequence] |
Convert to a stream.
|
U | |
| unfoldr [Sequence] | unfoldr f b will apply f to b.
|
| uniq [Sequence] |
Remove consecutive duplicate elements.
|
| unzip [Sequence] | |
V | |
| values [Sequence.Map.S] | |
Z | |
| zip [Sequence] | |
| zip_i [Sequence] |
Zip elements of the sequence with their index in the sequence
|