Contains operations for working with values of type seq.
Function or value  Description  




The returned sequence may be passed between threads safely. However, individual IEnumerator values generated from the returned sequence should not be accessed concurrently.


Full Usage:
Seq.average source
Parameters:
seq<^T>

The input sequence.
Returns: ^T
The average.

The elements are averaged using the


Full Usage:
Seq.averageBy projection source
Parameters:
'T > ^U

A function applied to transform each element of the sequence.
source : seq<'T>

The input sequence.
Returns: ^U
The average.

Returns the average of the results generated by applying the function to each element of the sequence.
The elements are averaged using the



The result sequence will have the same elements as the input sequence. The result can be enumerated multiple times. The input sequence will be enumerated at most once and only as far as is necessary. Caching a sequence is typically useful when repeatedly evaluating items in the original sequence is computationally expensive or if iterating the sequence causes sideeffects that the user does not want to be repeated multiple times. Enumeration of the result sequence is thread safe in the sense that multiple independent IEnumerator values may be used simultaneously from different threads (accesses to the internal lookaside table are thread safe). Each individual IEnumerator is not typically thread safe and should not be accessed concurrently. Once enumeration of the input sequence has started, it's enumerator will be kept live by this object until the enumeration has completed. At that point, the enumerator will be disposed. The enumerator may be disposed and underlying cache storage released by converting the returned sequence object to type IDisposable, and calling the Dispose method on this object. The sequence object may then be reenumerated and a fresh enumerator will be used.


Full Usage:
Seq.cast source
Parameters:
IEnumerable

The input sequence.
Returns: seq<'T>
The result sequence.

The use of this function usually requires a type annotation. An incorrect type annotation may result in runtime type errors. Individual IEnumerator values generated from the returned sequence should not be accessed concurrently.



Applies the given function to each element of the list. Return the list comprised of the results "x" for each element where the function returns Some(x). The returned sequence may be passed between threads safely. However, individual IEnumerator values generated from the returned sequence should not be accessed concurrently.






Remember sequence is lazy, effects are delayed until it is enumerated.


Full Usage:
Seq.compareWith comparer source1 source2
Parameters:
'T > 'T > int

A function that takes an element from each sequence and returns an int.
If it evaluates to a nonzero value iteration is stopped and that value is returned.
source1 : seq<'T>

The first input sequence.
source2 : seq<'T>

The second input sequence.
Returns: int
Returns the first nonzero result from the comparison function. If the end of a sequence
is reached it returns a 1 if the first sequence is shorter and a 1 if the second sequence
is shorter.




The returned sequence may be passed between threads safely. However, individual IEnumerator values generated from the returned sequence should not be accessed concurrently.






Applies a keygenerating function to each element of a sequence and returns a sequence yielding unique keys and their number of occurrences in the original sequence. Note that this function returns a sequence that digests the whole initial sequence as soon as that sequence is iterated. As a result this function should not be used with large or infinite sequences. The function makes no assumption on the ordering of the original sequence.



The input function is evaluated each time an IEnumerator for the sequence is requested.



Returns a sequence that contains no duplicate entries according to generic hash and equality comparisons on the entries. If an element occurs multiple times in the sequence then the later occurrences are discarded.



Returns a sequence that contains no duplicate entries according to the generic hash and equality comparisons on the keys returned by the given keygenerating function. If an element occurs multiple times in the sequence then the later occurrences are discarded.




Full Usage:
Seq.exactlyOne source
Parameters:
seq<'T>

The input sequence.
Returns: 'T
The only element of the sequence.



Full Usage:
Seq.except itemsToExclude source
Parameters:
seq<'T>

A sequence whose elements that also occur in the second sequence will cause those elements to be
removed from the returned sequence.
source : seq<'T>

A sequence whose elements that are not also in first will be returned.
Returns: seq<'T>
A sequence that contains the set difference of the elements of two sequences.

Returns a new sequence with the distinct elements of the second sequence which do not appear in the first sequence, using generic hash and equality comparisons to compare values. Note that this function returns a sequence that digests the whole of the first input sequence as soon as the result sequence is iterated. As a result this function should not be used with large or infinite sequences in the first parameter. The function makes no assumption on the ordering of the first input sequence.



The predicate is applied to the elements of the input sequence. If any application returns true then the overall result is true and no further elements are tested. Otherwise, false is returned.


Full Usage:
Seq.exists2 predicate source1 source2
Parameters:
'T1 > 'T2 > bool

A function to test each pair of items from the input sequences.
source1 : seq<'T1>

The first input sequence.
source2 : seq<'T2>

The second input sequence.
Returns: bool
True if any result from the predicate is true; false otherwise.

The predicate is applied to matching elements in the two sequences up to the lesser of the two lengths of the collections. If any application returns true then the overall result is true and no further elements are tested. Otherwise, false is returned. If one sequence is shorter than the other then the remaining elements of the longer sequence are ignored.



Returns a new collection containing only the elements of the collection for which the given predicate returns "true". This is a synonym for Seq.where. The returned sequence may be passed between threads safely. However, individual IEnumerator values generated from the returned sequence should not be accessed concurrently. Remember sequence is lazy, effects are delayed until it is enumerated.






This function digests the whole initial sequence as soon as it is called. As a result this function should not be used with large or infinite sequences.This function consumes the whole input sequence before returning the result.






This function digests the whole initial sequence as soon as it is called. As a result this function should not be used with large or infinite sequences.


Full Usage:
Seq.fold folder state source
Parameters:
'State > 'T > 'State

A function that updates the state with each element from the sequence.
state : 'State

The initial state.
source : seq<'T>

The input sequence.
Returns: 'State
The state object after the folding function is applied to each element of the sequence.

Applies a function to each element of the collection, threading an accumulator argument
through the computation. If the input function is


Full Usage:
Seq.fold2 folder state source1 source2
Parameters:
'State > 'T1 > 'T2 > 'State

The function to update the state given the input elements.
state : 'State

The initial state.
source1 : seq<'T1>

The first input sequence.
source2 : seq<'T2>

The second input sequence.
Returns: 'State
The final state value.

Applies a function to corresponding elements of two collections, threading an accumulator argument through the computation.
The two sequences need not have equal lengths:
when one sequence is exhausted any remaining elements in the other sequence are ignored.
If the input function is


Full Usage:
Seq.foldBack folder source state
Parameters:
'T > 'State > 'State

The function to update the state given the input elements.
source : seq<'T>

The input sequence.
state : 'State

The initial state.
Returns: 'State
The state object after the folding function is applied to each element of the sequence.

Applies a function to each element of the collection, starting from the end, threading an accumulator argument
through the computation. If the input function is This function consumes the whole input sequence before returning the result.


Full Usage:
Seq.foldBack2 folder source1 source2 state
Parameters:
'T1 > 'T2 > 'State > 'State

The function to update the state given the input elements.
source1 : seq<'T1>

The first input sequence.
source2 : seq<'T2>

The second input sequence.
state : 'State

The initial state.
Returns: 'State
The final state value.

Applies a function to corresponding elements of two collections, starting from the end of the shorter collection,
threading an accumulator argument through the computation. The two sequences need not have equal lengths.
If the input function is



The predicate is applied to the elements of the input sequence. If any application returns false then the overall result is false and no further elements are tested. Otherwise, true is returned.


Full Usage:
Seq.forall2 predicate source1 source2
Parameters:
'T1 > 'T2 > bool

A function to test pairs of elements from the input sequences.
source1 : seq<'T1>

The first input sequence.
source2 : seq<'T2>

The second input sequence.
Returns: bool
True if all pairs satisfy the predicate; false otherwise.

Tests the all pairs of elements drawn from the two sequences satisfy the given predicate. If one sequence is shorter than the other then the remaining elements of the longer sequence are ignored.



Applies a keygenerating function to each element of a sequence and yields a sequence of unique keys. Each unique key contains a sequence of all elements that match to this key. This function returns a sequence that digests the whole initial sequence as soon as that sequence is iterated. As a result this function should not be used with large or infinite sequences. The function makes no assumption on the ordering of the original sequence.


Full Usage:
Seq.head source
Parameters:
seq<'T>

The input sequence.
Returns: 'T
The first element of the sequence.




Builds a new collection whose elements are the corresponding elements of the input collection paired with the integer index (from 0) of each element.



Generates a new sequence which, when iterated, will return successive elements by calling the given function, up to the given count. Each element is saved after its initialization. The function is passed the index of the item being generated. The returned sequence may be passed between threads safely. However, individual IEnumerator values generated from the returned sequence should not be accessed concurrently.



Generates a new sequence which, when iterated, will return successive elements by calling the given function. The results of calling the function will not be saved, that is the function will be reapplied as necessary to regenerate the elements. The function is passed the index of the item being generated.
The returned sequence may be passed between threads safely. However,
individual IEnumerator values generated from the returned sequence should not be accessed concurrently.
Iteration can continue up to












Applies the given function to two collections simultaneously. If one sequence is shorter than the other then the remaining elements of the longer sequence are ignored.



Applies the given function to each element of the collection. The integer passed to the function indicates the index of element.



Applies the given function to two collections simultaneously. If one sequence is shorter than the other then the remaining elements of the longer sequence are ignored. The integer passed to the function indicates the index of element.


Full Usage:
Seq.last source
Parameters:
seq<'T>

The input sequence.
Returns: 'T
The last element of the sequence.







Builds a new collection whose elements are the results of applying the given function
to each of the elements of the collection. The given function will be applied
as elements are demanded using the The returned sequence may be passed between threads safely. However, individual IEnumerator values generated from the returned sequence should not be accessed concurrently.



Builds a new collection whose elements are the results of applying the given function to the corresponding pairs of elements from the two sequences. If one input sequence is shorter than the other then the remaining elements of the longer sequence are ignored.


Full Usage:
Seq.map3 mapping source1 source2 source3
Parameters:
'T1 > 'T2 > 'T3 > 'U

The function to transform triples of elements from the input sequences.
source1 : seq<'T1>

The first input sequence.
source2 : seq<'T2>

The second input sequence.
source3 : seq<'T3>

The third input sequence.
Returns: seq<'U>
The result sequence.

Builds a new collection whose elements are the results of applying the given function to the corresponding triples of elements from the three sequences. If one input sequence if shorter than the others then the remaining elements of the longer sequences are ignored.


Full Usage:
Seq.mapFold mapping state source
Parameters:
'State > 'T > 'Result * 'State

The function to transform elements from the input collection and accumulate the final value.
state : 'State

The initial state.
source : seq<'T>

The input collection.
Returns: seq<'Result> * 'State
The collection of transformed elements, and the final accumulated value.

Combines map and fold. Builds a new collection whose elements are the results of applying the given function to each of the elements of the collection. The function is also used to accumulate a final value. This function digests the whole initial sequence as soon as it is called. As a result this function should not be used with large or infinite sequences.


Full Usage:
Seq.mapFoldBack mapping source state
Parameters:
'T > 'State > 'Result * 'State

The function to transform elements from the input collection and accumulate the final value.
source : seq<'T>

The input collection.
state : 'State

The initial state.
Returns: seq<'Result> * 'State
The collection of transformed elements, and the final accumulated value.

Combines map and foldBack. Builds a new collection whose elements are the results of applying the given function to each of the elements of the collection. The function is also used to accumulate a final value. This function digests the whole initial sequence as soon as it is called. As a result this function should not be used with large or infinite sequences.



Builds a new collection whose elements are the results of applying the given function to each of the elements of the collection. The integer index passed to the function indicates the index (from 0) of element being transformed.


Full Usage:
Seq.mapi2 mapping source1 source2
Parameters:
int > 'T1 > 'T2 > 'U

A function to transform pairs of items from the input sequences that also supplies the current index.
source1 : seq<'T1>

The first input sequence.
source2 : seq<'T2>

The second input sequence.
Returns: seq<'U>
The result sequence.

Builds a new collection whose elements are the results of applying the given function to the corresponding pairs of elements from the two sequences. If one input sequence is shorter than the other then the remaining elements of the longer sequence are ignored. The integer index passed to the function indicates the index (from 0) of element being transformed.


Full Usage:
Seq.max source
Parameters:
seq<'T>

The input sequence.
Returns: 'T
The largest element of the sequence.



Full Usage:
Seq.maxBy projection source
Parameters:
'T > 'U

A function to transform items from the input sequence into comparable keys.
source : seq<'T>

The input sequence.
Returns: 'T
The largest element of the sequence.

Returns the greatest of all elements of the sequence, compared via Operators.max on the function result.


Full Usage:
Seq.min source
Parameters:
seq<'T>

The input sequence.
Returns: 'T
The smallest element of the sequence.



Full Usage:
Seq.minBy projection source
Parameters:
'T > 'U

A function to transform items from the input sequence into comparable keys.
source : seq<'T>

The input sequence.
Returns: 'T
The smallest element of the sequence.

Returns the lowest of all elements of the sequence, compared via Operators.min on the function result.


Full Usage:
Seq.ofArray source
Parameters:
'T[]

The input array.
Returns: seq<'T>
The result sequence.







Returns a sequence of each element in the input sequence and its predecessor, with the exception of the first element which is only returned as the predecessor of the second element.



This function consumes the whole input sequence before yielding the first element of the result sequence.



Applies the given function to successive elements, returning the first



Builds a new sequence object that delegates to the given sequence object. This ensures the original sequence cannot be rediscovered and mutated by a type cast. For example, if given an array the returned sequence will return the elements of the array, but you cannot cast the returned sequence object to an array.


Full Usage:
Seq.reduce reduction source
Parameters:
'T > 'T > 'T

A function that takes in the current accumulated result and the next
element of the sequence to produce the next accumulated result.
source : seq<'T>

The input sequence.
Returns: 'T
The final result of the reduction function.

Applies a function to each element of the sequence, threading an accumulator argument through the computation. Begin by applying the function to the first two elements. Then feed this result into the function along with the third element and so on. Return the final result.


Full Usage:
Seq.reduceBack reduction source
Parameters:
'T > 'T > 'T

A function that takes in the nexttolast element of the sequence and the
current accumulated result to produce the next accumulated result.
source : seq<'T>

The input sequence.
Returns: 'T
The final result of the reductions.

Applies a function to each element of the sequence, starting from the end, threading an accumulator argument
through the computation. If the input function is This function consumes the whole input sequence before returning the result.






This function consumes the whole input sequence before yielding the first element of the reversed sequence.





Full Usage:
Seq.scanBack folder source state
Parameters:
'T > 'State > 'State

A function that updates the state with each element from the sequence.
source : seq<'T>

The input sequence.
state : 'State

The initial state.
Returns: seq<'State>
The resulting sequence of computed states.

This function returns a sequence that digests the whole initial sequence as soon as that sequence is iterated. As a result this function should not be used with large or infinite sequences.


Full Usage:
Seq.singleton value
Parameters:
'T

The input item.
Returns: seq<'T>
The result sequence of one item.




Returns a sequence that skips N elements of the underlying sequence and then yields the remaining elements of the sequence.



Returns a sequence that, when iterated, skips elements of the underlying sequence while the given predicate returns True, and then yields the remaining elements of the sequence.



This function returns a sequence that digests the whole initial sequence as soon as that sequence is iterated. As a result this function should not be used with large or infinite sequences. The function makes no assumption on the ordering of the original sequence and uses a stable sort, that is the original order of equal elements is preserved.



Applies a keygenerating function to each element of a sequence and yield a sequence ordered by keys. The keys are compared using generic comparison as implemented by Operators.compare. This function returns a sequence that digests the whole initial sequence as soon as that sequence is iterated. As a result this function should not be used with large or infinite sequences. The function makes no assumption on the ordering of the original sequence and uses a stable sort, that is the original order of equal elements is preserved.



Applies a keygenerating function to each element of a sequence and yield a sequence ordered descending by keys. The keys are compared using generic comparison as implemented by Operators.compare. This function returns a sequence that digests the whole initial sequence as soon as that sequence is iterated. As a result this function should not be used with large or infinite sequences. The function makes no assumption on the ordering of the original sequence. This is a stable sort, that is the original order of equal elements is preserved.



This function returns a sequence that digests the whole initial sequence as soon as that sequence is iterated. As a result this function should not be used with large or infinite sequences. The function makes no assumption on the ordering of the original sequence. This is a stable sort, that is the original order of equal elements is preserved.



This function returns a sequence that digests the whole initial sequence as soon as that sequence is iterated. As a result this function should not be used with large or infinite sequences. The function makes no assumption on the ordering of the original sequence and uses a stable sort, that is the original order of equal elements is preserved.



This function returns a sequence that digests the whole initial sequence as soon as that sequence is iterated. As a result this function should not be used with large or infinite sequences.This function consumes the whole input sequence before yielding the first element of the result sequence.


Full Usage:
Seq.sum source
Parameters:
seq<^T>

The input sequence.
Returns: ^T
The computed sum.

The elements are summed using the


Full Usage:
Seq.sumBy projection source
Parameters:
'T > ^U

A function to transform items from the input sequence into the type that will be summed.
source : seq<'T>

The input sequence.
Returns: ^U
The computed sum.

The generated elements are summed using the



Returns a sequence that skips 1 element of the underlying sequence and then yields the remaining elements of the sequence.



Throws



Returns a sequence that, when iterated, yields elements of the underlying sequence while the given predicate returns True, and then returns no further elements.


Full Usage:
Seq.toArray source
Parameters:
seq<'T>

The input sequence.
Returns: 'T[]
The result array.







This function returns a sequence that digests the whole initial sequence as soon as that sequence is iterated. As a result this function should not be used with large or infinite sequences.






Returns the only element of the sequence or



Returns the first element for which the given function returns True. Return None if no such element exists.



Returns the last element for which the given function returns True. Return None if no such element exists. This function digests the whole initial sequence as soon as it is called. As a result this function should not be used with large or infinite sequences.



Returns the index of the first element in the sequence
that satisfies the given predicate. Return



Returns the index of the last element in the sequence
that satisfies the given predicate. Return This function digests the whole initial sequence as soon as it is called. As a result this function should not be used with large or infinite sequences.






Tries to find the nth element in the sequence.
Returns






Applies the given function to successive elements, returning the first result where the function returns "Some(x)".


Full Usage:
Seq.unfold generator state
Parameters:
'State > ('T * 'State) option

A function that takes in the current state and returns an option tuple of the next
element of the sequence and the next state value.
state : 'State

The initial state value.
Returns: seq<'T>
The result sequence.

Returns a sequence that contains the elements generated by the given computation.
The given initial The stream will be recomputed each time an IEnumerator is requested and iterated for the Seq.



Returns a new collection containing only the elements of the collection for which the given predicate returns "true". The returned sequence may be passed between threads safely. However, individual IEnumerator values generated from the returned sequence should not be accessed concurrently. Remember sequence is lazy, effects are delayed until it is enumerated. A synonym for Seq.filter.



Returns a sequence that yields sliding windows containing elements drawn from the input sequence. Each window is returned as a fresh array.



Combines the two sequences into a list of pairs. The two sequences need not have equal lengths: when one sequence is exhausted any remaining elements in the other sequence are ignored.



Combines the three sequences into a list of triples. The sequences need not have equal lengths: when one sequence is exhausted any remaining elements in the other sequences are ignored.
