| 
                all
                 | 
                
 Determines whether all elements of a sequence satisfy a condition.
 
 | 
            
            
                
                     
                     
                     
                 | 
                any
                 | 
                
 Determines whether any element of a sequence satisfies a condition.
 
 | 
            
            
                
                     
                     
                     
                 | 
                concat
                 | 
                
 Concatenates two sequences.
 
 | 
            
            
                
                     
                     
                     
                 | 
                contains
                 | 
                
 Determines whether a sequence contains a specified element by using a specified equality comparer.
 
 | 
            
            
                
                     
                     
                     
                 | 
                count
                 | 
                
 Returns the number of elements in a sequence.  If "predicate" is provided,
 returns a number that represents how many elements in the specified sequence
 satisfy a condition.
 
 | 
            
            
                
                     
                     
                     
                 | 
                defaultIfEmpty
                 | 
                
 Returns the elements of the specified sequence or the specified value in a singleton collection if the sequence is empty.
 
 | 
            
            
                
                     
                     
                     
                 | 
                distinct
                 | 
                
 Returns distinct elements from a sequence by using the equality comparer to compare values.
 
 | 
            
            
                
                     
                     
                     
                 | 
                empty
                 | 
                
 Returns an enumerable with no elements.
 
 | 
            
            
                
                     
                     
                     
                 | 
                except
                 | 
                
 Produces the set difference of two sequences, optionally using the specified equality comparer
 to compare values.
 
 | 
            
            
                
                     
                     
                     
                 | 
                first
                 | 
                
 Returns the first element of the sequence.  If "predicate" is provided,
 returns the first element that satisfies that condition.
 
 | 
            
            
                
                     
                     
                     
                 | 
                forEach
                 | 
                
 Applies a function to every element in the sequence.
 
 | 
            
            
                
                     
                     
                     
                 | 
                groupBy
                 | 
                
 Groups elements of a sequence according to a specified key selector function.
 
 | 
            
            
                
                     
                     
                     
                 | 
                indexOf
                 | 
                
 Returns the index where the element equal to value first appears in the sequence, optionally
 using an equality comparer to compare the value to elements in the sequence.
 
 | 
            
            
                
                     
                     
                     
                 | 
                intersect
                 | 
                
 Produces the set intersection of two sequences optionally using an equality comparer
 to compare values.
 
 | 
            
            
                
                     
                     
                     
                 | 
                join
                 | 
                
 Correlates the elements of two sequences based on matching keys.  If "equalityComparer"
 is not provided, the default comparer is used to compare keys.
 
 | 
            
            
                
                     
                     
                     
                 | 
                last
                 | 
                
 Returns the last element of the sequence.  If "predicate" is provided,
 returns the last element that satisfies that condition.
 
 | 
            
            
                
                     
                     
                     
                 | 
                max
                 | 
                
 Returns the maximum value in a sequence of (possibly null) values.
 
 | 
            
            
                
                     
                     
                     
                 | 
                maxBy
                 | 
                
 Returns the first element which contains the maximum value in a sequence of (possibly null) values.
 
 | 
            
            
                
                     
                     
                     
                 | 
                min
                 | 
                
 Returns the minimum value in a sequence of (possibly null) values.
 
 | 
            
            
                
                     
                     
                     
                 | 
                minBy
                 | 
                
 Returns the first element which contains the minimum value in a sequence of (possibly null) values.
 
 | 
            
            
                
                     
                     
                     
                 | 
                orderBy
                 | 
                
 Sorts the elements of a sequence in ascending order according to a key.
 
 | 
            
            
                
                     
                     
                     
                 | 
                range
                 | 
                
 Generates a sequence of integral numbers within a specified range.
 
 | 
            
            
                
                     
                     
                     
                 | 
                repeat
                 | 
                
 Generates a sequence that contains one repeated value.
 
 | 
            
            
                
                     
                     
                     
                 | 
                select
                 | 
                
 Projects each element of a sequence into a new form.  The element's index is provided
 for the transformation.
 
 | 
            
            
                
                     
                     
                     
                 | 
                selectMany
                 | 
                
 Projects each element of a sequence to an enumerable, flattens the resulting sequences
 into one sequence, and invokes a result selector function on each element therein.  The
 index of each source element is used in the intermediate projected form of that element.
 
 | 
            
            
                
                     
                     
                     
                 | 
                sequenceEqual
                 | 
                
 Determines whether two sequences are equal.
 
 | 
            
            
                
                     
                     
                     
                 | 
                sum
                 | 
                
 Computes the sum of the sequence of values that are obtained by invoking a transform
 function on each element of the input sequence.
 
 | 
            
            
                
                     
                     
                     
                 | 
                take
                 | 
                
 Returns the specified number of contiguous elements from the start of a sequence.
 
 | 
            
            
                
                     
                     
                     
                 | 
                takeWhile
                 | 
                
 Returns elements from a sequence as long as a specified condition is true.
 
 | 
            
            
                
                     
                     
                     
                 | 
                toArray
                 | 
                
 Creates an array from an enumerable.
 
 | 
            
            
                
                     
                     
                     
                 | 
                union
                 | 
                
 Produces the set union of two sequences optionally using an equality comparer to compare values.
 
 | 
            
            
                
                     
                     
                     
                 | 
                where
                 | 
                
 Filters a sequence of values based on a predicate. Each element's index is
 used in the logic of the predicate function.
 
 |