Index accessor

Empty list

Reference version for use in pattern-matching

Empty collection     = null
Singleton collection = A
More                 = (A, Seq<A>)   -- head and tail

Example:

var res = list.Case switch
{

   A value         => ...,
   (var x, var xs) => ...,
   _               => ...
}

Head lens

Head or none lens

Tail lens

Tail or none lens

Number of items in the list

Ctor

Ctor

Item at index lens

Item or none at index lens

Lens map

Safe index accessor

Stream as an enumerable

Find if a value is in the collection

Contains with provided Eq class instance

Add an item to the end of the list

Add a range of items to the end of the list

Clear the list

Get enumerator

Find the index of an item

Insert value at specified index

Insert range of values at specified index

Find the last index of an item in the list

Remove all items that match the value from the list

Remove all items that match the value from the list

Remove all items that match a predicate

Remove item at location

Remove a range of items

Set an item at the specified index

Returns an enumerable range from the collection. This is the fastest way of iterating sub-ranges of the collection.

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, ...]

Reverse the order of the items in the list

Impure iteration of the bound values in the structure

Map

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

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

Filter

Get the hash code Lazily (and once only) calculates the hash from the elements in the list Empty list hash == 0

Choice operator

Choice operator

Accesses the head of an enumerable and yields the remainder without multiple-enumerations

Accesses the head of an enumerable and yields the remainder without multiple-enumerations

Monadic join

Monadic join

Match empty list, or multi-item list

List pattern matching

List pattern matching

Get all items in the list except the last one

Must evaluate the last item to know it's the last, but won't return it

Get the tail of the list (skips the head item)

Inject a value in between each item in the enumerable

Concatenate all strings into one

Reverses the list (Reverse in LINQ)

Applies a function to each element of the collection (from last element to first), threading an accumulator argument through the computation. This function first applies the function to the first two elements of the list. Then, it passes this result into the function along with the third element and so on. Finally, it returns the final result.

Applies a function to each element of the collection, threading an accumulator argument through the computation. This function first applies the function to the first two elements of the list. Then, it passes this result into the function along with the third element and so on. Finally, it returns the final result.

Applies a function to each element of the collection, threading an accumulator argument through the computation. This function takes the state argument, and applies the function to it and the first element of the list. Then, it passes this result into the function along with the second element, and so on. Finally, it returns the list of intermediate results and the final result.

Applies a function to each element of the collection (from last element to first), threading an accumulator argument through the computation. This function takes the state argument, and applies the function to it and the first element of the list. Then, it passes this result into the function along with the second element, and so on. Finally, it returns the list of intermediate results and the final result.

Iterate each item in the enumerable in order (consume items)

Return a new enumerable with all duplicate values removed

The tails function returns all final segments of the argument, longest first. For example, i.e. tails(['a','b','c']) == [['a','b','c'], ['b','c'], ['c'],[]]

Span, applied to a predicate 'pred' and a list, returns a tuple where first element is longest prefix (possibly empty) of elements that satisfy 'pred' and second element is the remainder of the list:

Monadic bind function for IEnumerable

LINQ Select implementation for Lst

Monadic bind function for Lst that returns an IEnumerable

Monadic bind function

Monadic bind function

Returns the number of items in the Lst T

LINQ bind implementation for Lst

Take all but the last item in an enumerable

Take all but the last n items in an enumerable

Convert the enumerable to an Option.

Convert to a queryable

Functor map operation

Unwraps the value within the functor, passes it to the map function f provided, and then takes the mapped value and wraps it back up into a new functor.

Functor map operation

Unwraps the value within the functor, passes it to the map function f provided, and then takes the mapped value and wraps it back up into a new functor.

Applicative action: runs the first applicative, ignores the result, and returns the second applicative

Applicative action: runs the first applicative, ignores the result, and returns the second applicative

Applicative functor apply operation

Unwraps the value within the ma applicative-functor, passes it to the unwrapped function(s) within mf, and then takes the resulting value and wraps it back up into a new applicative-functor.

Applicative functor apply operation

Unwraps the value within the ma applicative-functor, passes it to the unwrapped function(s) within mf, and then takes the resulting value and wraps it back up into a new applicative-functor.

Monadic join

Monadic join

Create an empty IEnumerable T

Create a singleton collection

Create a new empty list

Create a list from a initial set of items

Create a list from an initial set of items

Create a list from an initial set of items

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

Generates an int.MaxValue sequence of T using the provided delegate to initialise each item.

Generates a sequence that contains one repeated value.

Add an item to the list

Add a range of items to the list

Remove an item from the list

Remove an item at a specified index in the list

Get the item at the head (first) of the list

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

Get the item at the head (first) of the list or Left if the list is empty

Get the item at the head (first) of the list or fail if the list is empty

Get the item at the head (first) of the list or fail if the list is empty

Get the last item of the list

Get the last item of the list

Get the last item of the list

Get the last item of the list

Get the last item of the list

Get all items in the list except the last one

Must evaluate the last item to know it's the last, but won't return it

Get the tail of the list (skips the head item)

Projects the values in the enumerable using a map function into a new enumerable (Select in LINQ).

Projects the values in the enumerable into a new enumerable using a map function, which is also given an index value (Select in LINQ - note that the order of the arguments of the map function are the other way around, here the index is the first argument).

Removes items from the list that do not match the given predicate (Where in LINQ)

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

Applies the given function 'selector' to each element of the list. Returns the list comprised of the results for each element where the function returns Some(f(x)). An index value is passed through to the selector function also.

For each element of the list, applies the given function. Concatenates all the results and returns the combined list.

Returns the sum total of all the items in the list (Sum in LINQ)

Returns the sum total of all the items in the list (Sum in LINQ)

Returns the sum total of all the items in the list (Sum in LINQ)

Returns the sum total of all the items in the list (Sum in LINQ)

Reverses the enumerable (Reverse in LINQ)

Reverses the list (Reverse in LINQ)

Concatenate two enumerables (Concat in LINQ)

Concatenate an enumerable and an enumerable of enumerables

Concatenate N enumerables

Applies a function 'folder' to each element of the collection, threading an accumulator argument through the computation. The fold function takes the state argument, and applies the function 'folder' to it and the first element of the list. Then, it feeds this result into the function 'folder' along with the second element, and so on. It returns the final result. (Aggregate in LINQ)

Applies a function 'folder' to each element of the collection (from last element to first), threading an aggregate state through the computation. The fold function takes the state argument, and applies the function 'folder' to it and the first element of the list. Then, it feeds this result into the function 'folder' along with the second element, and so on. It returns the final result.

Applies a function 'folder' to each element of the collection whilst the predicate function returns True for the item being processed, threading an aggregate state through the computation. The fold function takes the state argument, and applies the function 'folder' to it and the first element of the list. Then, it feeds this result into the function 'folder' along with the second element, and so on. It returns the final result.

Applies a function 'folder' to each element of the collection, threading an accumulator argument through the computation (and whilst the predicate function returns True when passed the aggregate state). The fold function takes the state argument, and applies the function 'folder' to it and the first element of the list. Then, it feeds this result into the function 'folder' along with the second element, and so on. It returns the final result.

Applies a function 'folder' to each element of the collection (from last element to first) whilst the predicate function returns True for the item being processed, threading an aggregate state through the computation. The fold function takes the state argument, and applies the function 'folder' to it and the first element of the list. Then, it feeds this result into the function 'folder' along with the second element, and so on. It returns the final result.

Applies a function 'folder' to each element of the collection (from last element to first), threading an accumulator argument through the computation (and whilst the predicate function returns True when passed the aggregate state). The fold function takes the state argument, and applies the function 'folder' to it and the first element of the list. Then, it feeds this result into the function 'folder' along with the second element, and so on. It returns the final result.

Applies a function 'folder' to each element of the collection whilst the predicate function returns False for the item being processed, threading an aggregate state through the computation. The fold function takes the state argument, and applies the function 'folder' to it and the first element of the list. Then, it feeds this result into the function 'folder' along with the second element, and so on. It returns the final result.

Applies a function 'folder' to each element of the collection, threading an accumulator argument through the computation (and whilst the predicate function returns False when passed the aggregate state). The fold function takes the state argument, and applies the function 'folder' to it and the first element of the list. Then, it feeds this result into the function 'folder' along with the second element, and so on. It returns the final result.

Applies a function 'folder' to each element of the collection (from last element to first) whilst the predicate function returns False for the item being processed, threading an aggregate state through the computation. The fold function takes the state argument, and applies the function 'folder' to it and the first element of the list. Then, it feeds this result into the function 'folder' along with the second element, and so on. It returns the final result.

Applies a function 'folder' to each element of the collection (from last element to first), threading an accumulator argument through the computation (and whilst the predicate function returns False when passed the aggregate state). The fold function takes the state argument, and applies the function 'folder' to it and the first element of the list. Then, it feeds this result into the function 'folder' along with the second element, and so on. It returns the final result.

Applies a function to each element of the collection (from first element to last), threading an accumulator argument through the computation. This function first applies the function to the first two elements of the list. Then, it passes this result into the function along with the third element and so on. Finally, it returns the final result.

The enumerable must contain at least one item or an excpetion will be thrown