Aardvark.Base


EnumerableEx

Static members

Static memberDescription
AddFirstToEnd(self)
Signature: self:IEnumerable<'T> -> IEnumerable<'T>
Type parameters: 'T

Moves the first element to the end of the sequence. [A B C].AddFirstToEnd() -> [A B C A]

AllDistinct(elements)
Signature: elements:IEnumerable<'T> -> bool
Type parameters: 'T
AllEqual(elements)
Signature: elements:IEnumerable<'T> -> bool
Type parameters: 'T
Chunk(self, chunkSize)
Signature: (self:IEnumerable<'T> * chunkSize:int64) -> IEnumerable<'T []>
Type parameters: 'T
Chunk(self, chunkSize, selector)
Signature: (self:IEnumerable<'T> * chunkSize:int64 * selector:Func<'T,'Tr>) -> IEnumerable<'Tr []>
Type parameters: 'T, 'Tr
ComparableIndexedValues(self)
Signature: self:IEnumerable<'T> -> IEnumerable<ComparableIndexedValue<'T>>
Type parameters: 'T
Concat(sequence, item)
Signature: (sequence:IEnumerable<'T> * item:'T) -> IEnumerable<'T>
Type parameters: 'T

Concats single item to sequence.

Concat(item, sequence)
Signature: (item:'T * sequence:IEnumerable<'T>) -> IEnumerable<'T>
Type parameters: 'T

Concats sequence to single item.

DistinctUntilChanged(self)
Signature: self:IEnumerable<'T> -> IEnumerable<'T>
Type parameters: 'T

Returns a sequence that contains only distinct contiguous elements.

Do(self, action)
Signature: (self:IEnumerable<'T> * action:Action<'T>) -> IEnumerable<'T>
Type parameters: 'T

Lazily applies action to each element of sequence.

Do(self, action)
Signature: (self:IEnumerable<'T> * action:Action<'T,int64>) -> IEnumerable<'T>
Type parameters: 'T

Lazily applies action to each element of sequence.

Dup(self)
Signature: self:IEnumerable<'T> -> IEnumerable<'T>
Type parameters: 'T

Duplicates each element of the sequence. [A B C].DupElements() -> [A A B B C C]

Dup(self, n)
Signature: (self:IEnumerable<'T> * n:int) -> IEnumerable<'T>
Type parameters: 'T

Duplicates each element of the sequence n times. [A B C].DupElements(4) -> [A A A A B B B B C C C C]

EnumerableEquals(self, other)
Signature: (self:IEnumerable<'T> * other:IEnumerable<'T>) -> bool
Type parameters: 'T

Compares both enumerables using SequenceEqual and additionally checks whether both enumerables are null.

FirstIndexOf(self, where)
Signature: (self:IEnumerable<'T> * where:Func<'T,bool>) -> int
Type parameters: 'T

Returns the index of the first element triggering the condition or -1 as default.

FirstOrDefault(self, defaultValue)
Signature: (self:IEnumerable<'T> * defaultValue:'T) -> 'T
Type parameters: 'T
FirstOrDefault(...)
Signature: (self:IEnumerable<'T> * predicate:Func<'T,bool> * defaultValue:'T) -> 'T
Type parameters: 'T
FlatGroupByMany(...)
Signature: (elements:IEnumerable<'TElement> * groupSelectorFuncs:Func<'TElement,obj> []) -> IEnumerable<'TElement>
Type parameters: 'TElement

Groups enumeration by an array of keys.

IndexedValues(self)
Signature: self:IEnumerable<'T> -> IEnumerable<IndexedValue<'T>>
Type parameters: 'T
IndexIntoOther(self, other)
Signature: (self:IEnumerable<'T> * other:IList<'T>) -> IEnumerable<IndexedValue<'T>>
Type parameters: 'T

Returns elements with index into 'other'.

IndexOf(list, elementToFind)
Signature: (list:IEnumerable<'T> * elementToFind:'T) -> int
Type parameters: 'T

Returns index of first occurence of elementToFind.

Indices(sequence)
Signature: sequence:IEnumerable<'T> -> IEnumerable<int>
Type parameters: 'T

Returns sequence of indices [0, sequence.Count()-1].

IndicesOf(self, predicate)
Signature: (self:IEnumerable<'T> * predicate:Func<'T,bool>) -> IEnumerable<int>
Type parameters: 'T
Integrated(counts, sum)
Signature: (counts:IEnumerable<int> * sum:int) -> IEnumerable<int>

Converts a sequence that contains numbers of elements into a sequence that represents the indices of the first element if the elements are stored in consecutive order and is closed by the total count elemtns. The length of the integrated sequence is +1 of the input.

Integrated(values, sum)
Signature: (values:IEnumerable<float> * sum:float) -> IEnumerable<float>

Integrates a sequence of values. Returns a sequence of N+1 values where the last is the sum off all value.

Interleave(self, separator)
Signature: (self:IEnumerable<'T> * separator:'T) -> IEnumerable<'T>
Type parameters: 'T

Interleaves given IEnumerable with specified element. E.g. { 'A', 'B', 'C' }.Interleave('X') -> { 'A', 'X', 'B', 'X', 'C' }.

IsEmpty(self)
Signature: self:IEnumerable<'T> -> bool
Type parameters: 'T

Determines whether a sequence contains no elements.

IsEmptyOrNull(elements)
Signature: elements:IEnumerable<'T> -> bool
Type parameters: 'T

Implemented in System.Interactive.dll. Returns true if elements contains no items or if elements is null, false otherwise.

Max(seq, greaterThan)
Signature: (seq:IEnumerable<'T> * greaterThan:Func<'T,'T,bool>) -> 'T
Type parameters: 'T
Max(seq, greaterThan, minValue)
Signature: (seq:IEnumerable<'T> * greaterThan:Func<'T,'T,bool> * minValue:'T) -> 'T
Type parameters: 'T

Aardvark.Runtime.IEnumerableExtensions: No-Throw version. Finds the largest element in seq according to greaterThan, that is greater than minValue, or the first such element if there are equally large elements, or minValue if no element is greater. For normal operation set minValue = -Inf or the minimum of T.

MaxElement(...)
Signature: (source:IEnumerable<'TSrc> * selector:Func<'TSrc,'TDst> * greaterThan:Func<'TDst,'TDst,bool> * minVal:'TDst * defaultRv:'TSrc * rv_maxVal:byref<'TDst>) -> 'TSrc
Type parameters: 'TSrc, 'TDst

Aardvark.Runtime.IEnumerableExtensions: Invokes a transform function on each element of a sequence and returns the element that yielded the maximum value (and the maximum value in rv_maxVal). Only elements that yield larger values than minVal are considered. If multiple elements yield the maximum value, the first in the sequence is chosen.

MaxIndex(self, greaterThan, maxValue)
Signature: (self:IEnumerable<'T> * greaterThan:Func<'T,'T,bool> * maxValue:byref<'T>) -> int
Type parameters: 'T
MaxIndex(self, minValue)
Signature: (self:IEnumerable<'T> * minValue:byref<'T>) -> int
Type parameters: 'T
MaxIndex(self)
Signature: self:IEnumerable<'T> -> int
Type parameters: 'T
MaxIndex(self, greaterThan, maxValue)
Signature: (self:'T [] * greaterThan:Func<'T,'T,bool> * maxValue:byref<'T>) -> int
Type parameters: 'T
MaxIndex(self, maxValue)
Signature: (self:'T [] * maxValue:byref<'T>) -> int
Type parameters: 'T
MaxIndex(self)
Signature: (self:'T []) -> int
Type parameters: 'T
MaxIndex(self, greaterThan, maxValue)
Signature: (self:List<'T> * greaterThan:Func<'T,'T,bool> * maxValue:byref<'T>) -> int
Type parameters: 'T
MaxIndex(self, maxValue)
Signature: (self:List<'T> * maxValue:byref<'T>) -> int
Type parameters: 'T
MaxIndex(self)
Signature: self:List<'T> -> int
Type parameters: 'T
MaxIndex(self)
Signature: (self:byte []) -> int
MaxIndex(self)
Signature: (self:sbyte []) -> int
MaxIndex(self)
Signature: (self:int16 []) -> int
MaxIndex(self)
Signature: (self:uint16 []) -> int
MaxIndex(self)
Signature: (self:int []) -> int
MaxIndex(self)
Signature: (self:uint32 []) -> int
MaxIndex(self)
Signature: (self:int64 []) -> int
MaxIndex(self)
Signature: (self:uint64 []) -> int
MaxIndex(self)
Signature: (self:float32 []) -> int
MaxIndex(self)
Signature: (self:float []) -> int
MaxIndex(self)
Signature: (self:decimal []) -> int
MaxIndex(self)
Signature: self:List<byte> -> int
MaxIndex(self)
Signature: self:List<sbyte> -> int
MaxIndex(self)
Signature: self:List<int16> -> int
MaxIndex(self)
Signature: self:List<uint16> -> int
MaxIndex(self)
Signature: self:List<int> -> int
MaxIndex(self)
Signature: self:List<uint32> -> int
MaxIndex(self)
Signature: self:List<int64> -> int
MaxIndex(self)
Signature: self:List<uint64> -> int
MaxIndex(self)
Signature: self:List<float32> -> int
MaxIndex(self)
Signature: self:List<float> -> int
MaxIndex(self)
Signature: self:List<decimal> -> int
Median(self, cmp)
Signature: (self:IEnumerable<'T> * cmp:Func<'T,'T,int>) -> 'T
Type parameters: 'T

Searches for the median-element in the Enumerable (according to cmp) and returns its value. Runtime is in O(N) and Memory in O(N) For partitioning use QuickMedian

Median(self)
Signature: self:IEnumerable<'T> -> 'T
Type parameters: 'T

Searches for the median-element in the Enumerable and returns its value. Runtime is in O(N) and Memory in O(N) For partitioning use QuickMedian

Median(self, cmp)
Signature: (self:'T [] * cmp:Func<'T,'T,int>) -> 'T
Type parameters: 'T

Searches for the median-element in the Array (according to cmp) and returns its value. Does not change the given Array Runtime is in O(N) and Memory in O(N) For partitioning use QuickMedian

Median(self)
Signature: (self:'T []) -> 'T
Type parameters: 'T

Searches for the median-element in the Array and returns its value. Does not change the given Array Runtime is in O(N) and Memory in O(N) For partitioning use QuickMedian

Median(self, cmp)
Signature: (self:List<'T> * cmp:Func<'T,'T,int>) -> 'T
Type parameters: 'T

Searches for the median-element in the List (according to cmp) and returns its value. Does not change the given List Runtime is in O(N) and Memory in O(N) For partitioning use QuickMedian

Median(self)
Signature: self:List<'T> -> 'T
Type parameters: 'T

Searches for the median-element in the List and returns its value. Does not change the given List Runtime is in O(N) and Memory in O(N) For partitioning use QuickMedian

Min(seq, lessThan)
Signature: (seq:IEnumerable<'T> * lessThan:Func<'T,'T,bool>) -> 'T
Type parameters: 'T
Min(seq, lessThan, maxValue)
Signature: (seq:IEnumerable<'T> * lessThan:Func<'T,'T,bool> * maxValue:'T) -> 'T
Type parameters: 'T

Aardvark.Runtime.IEnumerableExtensions: No-Throw version. Finds the smallest element in seq according to lessThan, that is smaller than maxValue, or the first such element if there are equally small elements, or maxValue if no element is smaller. For normal operation set maxValue = +Inf or the maximum of T.

MinElement(...)
Signature: (source:IEnumerable<'TSrc> * selector:Func<'TSrc,'TDst> * smallerThan:Func<'TDst,'TDst,bool> * maxVal:'TDst * defaultRv:'TSrc * rv_minVal:byref<'TDst>) -> 'TSrc
Type parameters: 'TSrc, 'TDst

Aardvark.Runtime.IEnumerableExtensions: Invokes a transform function on each element of a sequence and returns the element that yielded the minimum value (and the minimum value in rv_minVal). Only elements that yield smaller values than maxVal are considered. If multiple elements yield the minimum value, the first in the sequence is chosen.

MinIndex(self, lessThan, minValue)
Signature: (self:IEnumerable<'T> * lessThan:Func<'T,'T,bool> * minValue:byref<'T>) -> int
Type parameters: 'T
MinIndex(self, minValue)
Signature: (self:IEnumerable<'T> * minValue:byref<'T>) -> int
Type parameters: 'T
MinIndex(self)
Signature: self:IEnumerable<'T> -> int
Type parameters: 'T
MinIndex(self, lessThan, minValue)
Signature: (self:'T [] * lessThan:Func<'T,'T,bool> * minValue:byref<'T>) -> int
Type parameters: 'T
MinIndex(self, minValue)
Signature: (self:'T [] * minValue:byref<'T>) -> int
Type parameters: 'T
MinIndex(self)
Signature: (self:'T []) -> int
Type parameters: 'T
MinIndex(self, lessThan, minValue)
Signature: (self:List<'T> * lessThan:Func<'T,'T,bool> * minValue:byref<'T>) -> int
Type parameters: 'T
MinIndex(self, minValue)
Signature: (self:List<'T> * minValue:byref<'T>) -> int
Type parameters: 'T
MinIndex(self)
Signature: self:List<'T> -> int
Type parameters: 'T
MinIndex(self)
Signature: (self:byte []) -> int
MinIndex(self)
Signature: (self:sbyte []) -> int
MinIndex(self)
Signature: (self:int16 []) -> int
MinIndex(self)
Signature: (self:uint16 []) -> int
MinIndex(self)
Signature: (self:int []) -> int
MinIndex(self)
Signature: (self:uint32 []) -> int
MinIndex(self)
Signature: (self:int64 []) -> int
MinIndex(self)
Signature: (self:uint64 []) -> int
MinIndex(self)
Signature: (self:float32 []) -> int
MinIndex(self)
Signature: (self:float []) -> int
MinIndex(self)
Signature: (self:decimal []) -> int
MinIndex(self)
Signature: self:List<byte> -> int
MinIndex(self)
Signature: self:List<sbyte> -> int
MinIndex(self)
Signature: self:List<int16> -> int
MinIndex(self)
Signature: self:List<uint16> -> int
MinIndex(self)
Signature: self:List<int> -> int
MinIndex(self)
Signature: self:List<uint32> -> int
MinIndex(self)
Signature: self:List<int64> -> int
MinIndex(self)
Signature: self:List<uint64> -> int
MinIndex(self)
Signature: self:List<float32> -> int
MinIndex(self)
Signature: self:List<float> -> int
MinIndex(self)
Signature: self:List<decimal> -> int
Most(self, predicate)
Signature: (self:IEnumerable<'T> * predicate:Func<'T,bool>) -> bool
Type parameters: 'T

Returns true if more elements than not satisfy the given predicate.

NonNull(elements)
Signature: elements:IEnumerable<'T> -> IEnumerable<'T>
Type parameters: 'T
PairChain(self, wrap)
Signature: (self:IEnumerable<'T> * wrap:bool) -> IEnumerable<Pair<'T>>
Type parameters: 'T

wrap = false: A B C D ... -> (A, B) (B, C) (C, D) ... wrap = true: A B C D -> (A, B) (B, C) (C, D) (D, A)

PairChainIndexed(self, wrap)
Signature: (self:IEnumerable<'T> * wrap:bool) -> IEnumerable<Pair<int>>
Type parameters: 'T

wrap = false: A B C D ... -> (0, 1) (1, 2) (2, 3) ... wrap = true: A B C D -> (0, 1) (1, 2) (2, 3) (3, 0)

PairChainWrap(self)
Signature: self:IEnumerable<'T> -> IEnumerable<Pair<'T>>
Type parameters: 'T

A B C D -> (A, B) (B, C) (C, D) (D, A)

PairChainWrapIndexed(self)
Signature: self:IEnumerable<'T> -> IEnumerable<Pair<int>>
Type parameters: 'T

A B C -> (0, 1) (1, 2) (2, 0)

Pairs(self)
Signature: self:IEnumerable<'T> -> IEnumerable<Pair<'T>>
Type parameters: 'T

A B C -> (A, A) (A, B) (A, C) (B, A) (B, B) (B, C) (C, A) (C, B) (C, C)

Pairs(...)
Signature: (self:IEnumerable<'T> * excludeIdenticalPairs:bool * excludeReversePairs:bool) -> IEnumerable<Pair<'T>>
Type parameters: 'T

A B C -> (A, A) (A, B) (A, C) (B, A) (B, B) (B, C) (C, A) (C, B) (C, C) excludeIdenticalPairs: A B C -> (A, B) (A, C) (B, A) (B, C) (C, A) (C, B) excludeReversePairs: A B C -> (A, A) (A, B) (A, C) (B, B) (B, C) (C, C) both: A B C -> (A, B) (A, C) (B, C)

Pairs(self, other)
Signature: (self:IEnumerable<'T> * other:IEnumerable<'T>) -> IEnumerable<Pair<'T>>
Type parameters: 'T

[A B C].Pair([x y z]) -> (A, x) (A, y) (A, z) (B, x) (B, y) (B, z) (C, x) (C, y) (C, z)

PairsCount(...)
Signature: (self:IEnumerable<'T> * excludeIdenticalPairs:bool * excludeReversePairs:bool) -> int
Type parameters: 'T

Computes how many pairs method Pairs() will generate. Is efficient on ILists(of T), but will fully enumerate other IEnumerables.

PairSequence(self)
Signature: self:IEnumerable<'T> -> IEnumerable<Pair<'T>>
Type parameters: 'T

A B C D ... -> (A, B) (C, D) ... If sequence does not have even elements the last element is not selected.

Repeat(self)
Signature: self:'T -> IEnumerable<'T>
Type parameters: 'T

Returns an enumeration which will infinitely yield copies of 'self'. A.Repeat -> [A A A A ...]

Repeat(self, count)
Signature: (self:'T * count:int64) -> IEnumerable<'T>
Type parameters: 'T

Returns an enumeration which will yield 'count' copies of 'self'. A.Repeat(3) -> [A A A]

Return(item)
Signature: item:'T -> IEnumerable<'T>
Type parameters: 'T

Creates sequence containing the given item.

SelectNotNull(self, selector)
Signature: (self:IEnumerable<'T> * selector:Func<'T,'TResult>) -> IEnumerable<'TResult>
Type parameters: 'T, 'TResult
SelectToArray(self, selector)
Signature: (self:'T [] * selector:Func<'T,'R>) -> 'R []
Type parameters: 'T, 'R

Maps the elements of an array to a result array.

SelectToArray(self, selector)
Signature: (self:List<'T> * selector:Func<'T,'R>) -> 'R []
Type parameters: 'T, 'R

Maps the elements of a list to a result array.

SelectToList(self, selector)
Signature: (self:'T [] * selector:Func<'T,'R>) -> List<'R>
Type parameters: 'T, 'R

Maps the elements of an array to a result list.

SelectToList(self, selector)
Signature: (self:List<'T> * selector:Func<'T,'R>) -> List<'R>
Type parameters: 'T, 'R

Maps the elements of a list to a result list.

SetEquals(self, other)
Signature: (self:IEnumerable<'T> * other:IEnumerable<'T>) -> bool
Type parameters: 'T
SortedByDenseIndex(indexedValues)
Signature: indexedValues:IEnumerable<IndexedValue<'T>> -> 'T []
Type parameters: 'T

If you have a sequence of indexed values, where all indexes starting from 0 up to some maximal value are present and unique, sorting can be performed this simple array based reshuffling operation with O(n) cost.

TakePeriodic(self, stride)
Signature: (self:IEnumerable<'T> * stride:int) -> IEnumerable<'T>
Type parameters: 'T

Yields every stride-th element.

TakeToArray(self, count)
Signature: (self:IEnumerable<'T> * count:int) -> 'T []
Type parameters: 'T

Take the first count items of a sequence and put them into an array. If the sequence is shorter than the specified count, an Argument exception is thrown.

TakeToArrayDefault(self, count)
Signature: (self:IEnumerable<'T> * count:int) -> 'T []
Type parameters: 'T

Take the first count items of a sequence and put them into an array. If the sequence is shorter than the specified count, the array is filled up with default values.

TakeToList(self, count)
Signature: (self:IEnumerable<'T> * count:int) -> List<'T>
Type parameters: 'T

Take the first count items of a sequence and put them into a list. If the supplied sequence has less than count elements the resulting list is shorter than count items.

ToArray(source, count)
Signature: (source:IEnumerable<'TElement> * count:int) -> 'TElement []
Type parameters: 'TElement

This is a more efficient version of System.Linq.Enumerable.ToArray() when the number of elements of cannot be efficiently determined but is known. Creates an array from a .

ToArrayDebug(self)
Signature: self:IEnumerable<'T> -> 'T []
Type parameters: 'T
ToDictionaryDistinct(...)
Signature: (source:IEnumerable<'TSource> * keySelector:Func<'TSource,'TKey> * elementSelector:Func<'TSource,'TElement> * duplicateValue:'TElement) -> Dictionary<'TKey,'TElement>
Type parameters: 'TSource, 'TKey, 'TElement

Creates a Dictionary(of TKey,TValue) from an IEnumerable(of TSource) according to specified key selector and element selector functions.

ToDictionaryDistinct(...)
Signature: (source:IEnumerable<'TSource> * keySelector:Func<'TSource,'TKey> * elementSelector:Func<'TSource,'TElement> * duplicateKeyKeepElement:Func<'TElement,'TElement,bool>) -> Dictionary<'TKey,'TElement>
Type parameters: 'TSource, 'TKey, 'TElement

Creates a Dictionary(of TKey,TValue) from an IEnumerable(of TSource) containing all Key Value pairs with distinct keys. For duplicate keys, the returned value of is inserted instead.

ToDictionaryDistinct(...)
Signature: (source:IEnumerable<'TSource> * keySelector:Func<'TSource,'TKey> * elementSelector:Func<'TSource,'TElement> * duplicateKeyElementSelector:Func<'TElement,'TElement,'TElement>) -> Dictionary<'TKey,'TElement>
Type parameters: 'TSource, 'TKey, 'TElement

Creates a Dictionary(of TKey,TValue) from an IEnumerable(of TSource) containing all Key Value pairs with distinct keys. For duplicate keys, the returned value of is inserted instead.

ToString(...)
Signature: (self:IEnumerable<'T> * format:Func<'T,string> * begin:string * between:string * end:string) -> string
Type parameters: 'T

Outputs the enumeration in the form "(begin)element0(between)element1...". Each element is formatted by the delegate format. You may set any parameter to null, in which case the default values (v => v.ToString(), "", ", ", "") are used.

TripleChain(self, wrap)
Signature: (self:IEnumerable<'T> * wrap:bool) -> IEnumerable<Triple<'T>>
Type parameters: 'T

wrap = false: A B C D ... -> (A, B, C) (B, C, D) (C, D, E) ... wrap = true: A B C D -> (A, B, C) (B, C, D) (C, D, A) (D, A, B)

TripleChainWrap(self)
Signature: self:IEnumerable<'T> -> IEnumerable<Triple<'T>>
Type parameters: 'T

A B C D -> (A, B, C) (B, C, D) (C, D, A) (D, A, B)

Triples(self)
Signature: self:IEnumerable<'T> -> IEnumerable<Triple<'T>>
Type parameters: 'T

A B C -> AAA, AAB, AAC, ABA, ABB, ABC, ACA, ACB, ACC, BAA, BAB, BAC, BBA, BBB, BBC, BCA, BCB, BCC, CAA, CAB, CAC, CBA, CBB, CBC, CCA, CCB, CCC

Triples(...)
Signature: (self:IEnumerable<'T> * excludeIdenticalPairs:bool * excludeReversePairs:bool) -> IEnumerable<Triple<'T>>
Type parameters: 'T

A B C -> AAA, AAB, AAC, ABA, ABB, ABC, ACA, ACB, ACC, BAA, BAB, BAC, BBA, BBB, BBC, BCA, BCB, BCC, CAA, CAB, CAC, CBA, CBB, CBC, CCA, CCB, CCC excludeIdenticalPairs: A B C -> ABC, CBA excludeReversePairs: A B C -> AAA, AAB, AAC, ABA, ABB, ABC, ACA, ACB, ACC, BAB, BAC, BBB, BBC, BCB, BCC, CAC, CBC, CCC both: A B C -> ABC

Triples(self, other1, other2)
Signature: (self:IEnumerable<'T> * other1:IEnumerable<'T> * other2:IEnumerable<'T>) -> IEnumerable<Triple<'T>>
Type parameters: 'T

[A B].Triple([x y], [X Y]) -> (A, x, X) (A, x, Y) (A, y, X) (A, y, Y) (B, x, X) (B, x, Y) (B, y, X) (B, y, Y) (C, x, X) (C, x, Y) (C, y, X) (C, y, Y)

TripleSequence(self)
Signature: self:IEnumerable<'T> -> IEnumerable<Triple<'T>>
Type parameters: 'T

A B C D ... -> (A, B, C) (D, E, F) ... If sequence does not have even elements the last element is not selected.

TrueForAll(sequence, predicate)
Signature: (sequence:IEnumerable<'T> * predicate:Func<'T,bool>) -> bool
Type parameters: 'T
TrueForAny(sequence, predicate)
Signature: (sequence:IEnumerable<'T> * predicate:Func<'T,bool>) -> bool
Type parameters: 'T
WhereNotNull(self)
Signature: self:IEnumerable<'T> -> IEnumerable<'T>
Type parameters: 'T
WithFirstMovedToEnd(self)
Signature: self:IEnumerable<'T> -> IEnumerable<'T>
Type parameters: 'T

Moves the first element to the end of the sequence. [A B C D E].MoveFirstToEnd() -> [B C D E A]

WithRepeatedLast(self)
Signature: self:IEnumerable<'T> -> IEnumerable<'T>
Type parameters: 'T

Appends an infinite number of copies of the sequence's last element. [A B C].WithRepeatedLast() -> [A B C C C C C ...] Does nothing for an empty sequence. Throws an exception for a null sequence.

Zip(self, other)
Signature: (self:IEnumerable<'T> * other:IEnumerable<'T>) -> IEnumerable<'T>
Type parameters: 'T

Interleave this' elements with other's elements resulting in a sequence of length min(this.Length, other.Length).

Zip(self, other1, other2)
Signature: (self:IEnumerable<'T> * other1:IEnumerable<'T> * other2:IEnumerable<'T>) -> IEnumerable<'T>
Type parameters: 'T
ZipAll(self, other)
Signature: (self:IEnumerable<'T> * other:IEnumerable<'T>) -> IEnumerable<'T>
Type parameters: 'T
ZipAll(self, other1, other2)
Signature: (self:IEnumerable<'T> * other1:IEnumerable<'T> * other2:IEnumerable<'T>) -> IEnumerable<'T>
Type parameters: 'T
ZipPairs(self, other)
Signature: (self:IEnumerable<'T> * other:IEnumerable<'T>) -> IEnumerable<Pair<'T>>
Type parameters: 'T
ZipTriples(self, other1, other2)
Signature: (self:IEnumerable<'T> * other1:IEnumerable<'T> * other2:IEnumerable<'T>) -> IEnumerable<Triple<'T>>
Type parameters: 'T
ZipTuples(self, other)
Signature: (self:IEnumerable<'T0> * other:IEnumerable<'T1>) -> IEnumerable<Tup<'T0,'T1>>
Type parameters: 'T0, 'T1
ZipTuples(self, other1, other2)
Signature: (self:IEnumerable<'T0> * other1:IEnumerable<'T1> * other2:IEnumerable<'T2>) -> IEnumerable<Tup<'T0,'T1,'T2>>
Type parameters: 'T0, 'T1, 'T2
Fork me on GitHub