Sub modules

Tail of the iterable

Empty sequence

Get the additive-identity, i.e. the monoid-zero. Which is the empty sequence/

Create an iterable from a span

Number of items in the sequence.

NOTE: This will force evaluation of the sequence

Number of items in the sequence.

Stream as an enumerable

Stream as an enumerable

Stream as an enumerable

Stream as an enumerable

Reverse the sequence

Add an item to the end of the sequence

This does not force evaluation of the whole lazy sequence, nor does it cause exponential iteration issues when repeated adds occur.

Add an item to the beginning of the sequence

This does not force evaluation of the whole lazy sequence, nor does it cause exponential iteration issues when repeated cons occur.

Impure iteration of the bound values in the structure

Pure iteration of the bound values in the structure

Impure iteration of the bound values in the structure

Pure iteration of the bound values in the structure

Map the sequence using the function provided

Map the sequence using the function provided

Filter the items in the sequence

Equality test

Equality test

Equality test

Equality test

Semigroup combine two iterables (concatenate)

Add a range of items to the end of the sequence

Add a range of items to the end of the sequence

Add a range of items to the end of the sequence

Return a new sequence with all duplicate values removed

Return a new sequence with all duplicate values removed

Map each element of a structure to an action, evaluate these actions from left to right, and collect the results.

NOTE: This method will eagerly evaluate the iterable. If you're working with an asynchronous sequence, then it is advised to use TraverseIO.

Map each element of a structure to an action, evaluate these actions from left to right, and collect the results.

NOTE: This method will eagerly evaluate the iterable. If you're working with an asynchronous sequence, then it is advised to use TraverseIO.

Map each element of a structure to an action, evaluate these actions from left to right, and collect the results.

Monadic bind (flatmap) of the sequence

Monadic bind (flatmap) of the sequence

Fold over the sequence from the left, accumulating state in f

Fold over the sequence from the left, accumulating state in f

Fold over the sequence from the left, accumulating state in f

Fold over the sequence from the left, accumulating state in f

Fold over the sequence from the left, accumulating state in f

Fold over the sequence from the left, accumulating state in f

Fold over the sequence from the left, accumulating state in f

Fold over the sequence from the left, accumulating state in f

Fold until the Option returns None

Fold until the Option returns None

Fold until the Option returns None

Fold until the Option returns None

Same behaviour as Fold but the fold operation returns a monadic type and allows early exit of the operation once the predicate function becomes false for the state/value pair

Same behaviour as Fold but the fold operation returns a monadic type and allows early exit of the operation once the predicate function becomes false for the state/value pair

Same behaviour as Fold but the fold operation returns a monadic type and allows early exit of the operation once the predicate function becomes false for the state/value pair

Same behaviour as Fold but the fold operation returns a monadic type and allows early exit of the operation once the predicate function becomes false for the state/value pair

Right-associative fold of a structure, lazy in the accumulator.

In the case of lists, 'Fold', when applied to a binary operator, a starting value (typically the right-identity of the operator), and a list, reduces the list using the binary operator, from right to left.

Right-associative fold of a structure, lazy in the accumulator.

In the case of lists, 'Fold', when applied to a binary operator, a starting value (typically the right-identity of the operator), and a list, reduces the list using the binary operator, from right to left.

Right-associative fold of a structure, lazy in the accumulator.

In the case of lists, 'Fold', when applied to a binary operator, a starting value (typically the right-identity of the operator), and a list, reduces the list using the binary operator, from right to left.

Right-associative fold of a structure, lazy in the accumulator.

In the case of lists, 'Fold', when applied to a binary operator, a starting value (typically the right-identity of the operator), and a list, reduces the list using the binary operator, from right to left.

Right-associative fold of a structure, lazy in the accumulator.

In the case of lists, 'Fold', when applied to a binary operator, a starting value (typically the right-identity of the operator), and a list, reduces the list using the binary operator, from right to left.

Right-associative fold of a structure, lazy in the accumulator.

In the case of lists, 'Fold', when applied to a binary operator, a starting value (typically the right-identity of the operator), and a list, reduces the list using the binary operator, from right to left.

Map each element of the structure into a monoid, and combine the results with Append. This fold is right-associative and lazy in the accumulator. For strict left-associative folds consider FoldMapBack instead.

Map each element of the structure into a monoid, and combine the results with Append. This fold is right-associative and lazy in the accumulator. For strict left-associative folds consider FoldMapBack instead.

Map each element of the structure into a monoid, and combine the results with Append. This fold is right-associative and lazy in the accumulator. For strict left-associative folds consider FoldMapBack instead.

Map each element of the structure into a monoid, and combine the results with Append. This fold is right-associative and lazy in the accumulator. For strict left-associative folds consider FoldMapBack instead.

Map each element of the structure into a monoid, and combine the results with Append. This fold is right-associative and lazy in the accumulator. For strict left-associative folds consider FoldMapBack instead.

Map each element of the structure into a monoid, and combine the results with Append. This fold is right-associative and lazy in the accumulator. For strict left-associative folds consider FoldMapBack instead.

Returns true if the sequence has items in it

Inject a value in between each item in the sequence

Compare to another sequence

Compare to another sequence

Format the collection as [a, b, c, ...] The ellipsis is used for collections over 50 items To get a formatted string with all the items, use ToFullString or ToFullArrayString.

Format the collection as [a, b, c, ...] The ellipsis is used for collections over 50 items To get a formatted string with all the items, use ToFullString or ToFullArrayString.

Format the collection as a, b, c, ...

Format the collection as a, b, c, ...

Format the collection as [a, b, c, ...]

Format the collection as [a, b, c, ...]

Skip count items

Take count items

Iterate the sequence, yielding items if they match the predicate provided, and stopping as soon as one doesn't

Iterate the sequence, yielding items if they match the predicate provided; and stopping as soon as one doesn't. An index value is also provided to the predicate function.

Partition a list into two based on a predicate

Partition a list into two based on a predicate

Cast items to another type

Any item in the sequence that can't be cast to a B will be dropped from the result

Zip two iterables into pairs

Zip two iterables into pairs

If this sequence is empty, return the other sequence, otherwise return this sequence.

If this sequence is empty, return the other sequence, otherwise return this sequence.

Map the sequence using the function provided

Map the sequence using the function provided

Filter the items in the sequence

Monadic bind (flatmap) of the sequence

Monadic bind (flatmap) of the sequence

Monadic bind (flatmap) of the sequence

Monadic bind (flatmap) of the sequence

Get the hash code for all the items in the sequence, or 0 if empty

Append operator

Append operator

Append operator

Choice operator

Choice operator

Choice operator

Ordering operator

Ordering operator

Ordering operator

Ordering operator

Monadic join

Create an empty sequence

Create an empty sequence

Create a new empty sequence

Create a sequence from an initial set of items

Create a sequence from an initial set of items

Create a sequence from an initial set of items

Create a sequence from an initial set of items

Create a sequence from an initial set of items

Generates a sequence of A using the provided delegate to initialise each item.

Generates a sequence that contains one repeated value.

Get the item at the head (first) of the sequence or None if the sequence is empty

Applies the given function 'selector' to each element of the sequence. Returns the sequence of results for each element where the function returns Some(f(x)).

Reverses the sequence (Reverse in LINQ)

Joins two sequences together either into a single sequence using the join function provided

Joins two sequences together either into an sequence of tuples

Return a new sequence with all duplicate values removed

Return a new sequence with all duplicate values removed

Returns a new sequence with the first 'count' items from the sequence provided

Iterate the sequence, yielding items if they match the predicate provided, and stopping as soon as one doesn't

Iterate the sequence, yielding items if they match the predicate provided, and stopping as soon as one doesn't. An index value is also provided to the predicate function.