Uses of Interface org.apache.calcite.linq4j.Enumerable (Apache Calcite API)

Packages that use Enumerable
Package Description

org.apache.calcite.linq4j
Language-integrated query for Java (linq4j) main package.

Packages that use Enumerable
Package	Description
org.apache.calcite.linq4j	Language-integrated query for Java (linq4j) main package.

Uses of Enumerable in org.apache.calcite.linq4j

Subinterfaces of Enumerable in org.apache.calcite.linq4j
Modifier and Type	Interface	Description
`interface`	`ExtendedOrderedEnumerable<T>`	Extension methods for `OrderedEnumerable`.
`interface`	`ExtendedOrderedQueryable<T>`	Extension methods for `OrderedQueryable`.
`interface`	`Grouping<K,V>`	Represents a collection of objects that have a common key.
`interface`	`Lookup<K,V>`	Represents a collection of keys each mapped to one or more values.
`interface`	`OrderedEnumerable<T>`	Represents the result of applying a sorting operation to an `Enumerable`.
`interface`	`OrderedQueryable<T>`	Represents the result of applying a sorting operation to a `Queryable`.
`interface`	`Queryable<T>`	Provides functionality to evaluate queries against a specific data source wherein the type of the data is known.
`static interface`	`QueryableDefaults.Replayable<T>`	Replayable.
`interface`	`RawQueryable<T>`	Core methods that define a `Queryable`.

Classes in org.apache.calcite.linq4j that implement Enumerable
Modifier and Type	Class	Description
`class`	`AbstractEnumerable<T>`	Abstract implementation of the `Enumerable` interface that implements the extension methods.
`class`	`AbstractEnumerable2<T>`	Abstract implementation of the `Enumerable` interface that implements the extension methods.
`class`	`AbstractQueryable<T>`	Abstract implementation of the `Queryable` interface that implements the extension methods.
`class`	`BaseQueryable<TSource>`	Skeleton implementation of `Queryable`.
`class`	`DefaultEnumerable<T>`	Implementation of the `Enumerable` interface that implements the extension methods by calling into the `Extensions` class.
`(package private) class`	`DefaultQueryable<T>`	Implementation of the `Queryable` interface that implements the extension methods by calling into the `Extensions` class.
`private static class`	`EnumerableDefaults.LookupResultEnumerable<TResult,TKey,TAccumulate>`	Reads a populated map, applying a selector function.
`(package private) class`	`EnumerableOrderedQueryable<T>`	Implementation of `OrderedQueryable` by an `Enumerable`.
`(package private) class`	`EnumerableQueryable<T>`	Implementation of `Queryable` by a `Enumerable`.
`(package private) class`	`GroupingImpl<K,V>`	Implementation of `Grouping`.
`(package private) static class`	`Linq4j.CollectionEnumerable<T>`	Collection enumerable.
`(package private) static class`	`Linq4j.CompositeEnumerable<E>`	Composite enumerable.
`(package private) static class`	`Linq4j.IterableEnumerable<T>`	Iterable enumerable.
`(package private) static class`	`Linq4j.ListEnumerable<T>`	List enumerable.
`(package private) class`	`LookupImpl<K,V>`	Implementation of `Lookup` that uses an underlying map.
`static class`	`QueryableDefaults.NonLeafReplayableQueryable<T>`	Non-leaf replayable queryable.
`static class`	`QueryableDefaults.ReplayableQueryable<T>`	Replayable queryable.
`static class`	`QueryProviderImpl.QueryableImpl<T>`	Binds an expression to this query provider.

Fields in org.apache.calcite.linq4j declared as Enumerable
Modifier and Type	Field	Description
`static Enumerable<?>`	Linq4j.`EMPTY_ENUMERABLE`
`private Enumerable<T>`	EnumerableQueryable.`enumerable`

Fields in org.apache.calcite.linq4j with type parameters of type Enumerable
Modifier and Type	Field	Description
`private Enumerator<Enumerable<E>>`	Linq4j.CompositeEnumerable.`enumerableEnumerator`

Methods in org.apache.calcite.linq4j that return Enumerable
Modifier and Type	Method	Description
`<TResult> Enumerable<TResult>`	Lookup.`applyResultSelector(Function2<K,Enumerable<V>,TResult> resultSelector)`	Applies a transform function to each key and its associated values and returns the results.
`<TResult> Enumerable<TResult>`	LookupImpl.`applyResultSelector(Function2<K,Enumerable<V>,TResult> resultSelector)`
`Enumerable<T>`	DefaultEnumerable.`asEnumerable()`
`Enumerable<T>`	DefaultQueryable.`asEnumerable()`
`static <TSource> Enumerable<TSource>`	EnumerableDefaults.`asEnumerable(Enumerable<TSource> enumerable)`	Returns the input typed as `Enumerable<TSource>`.
`Enumerable<TSource>`	ExtendedEnumerable.`asEnumerable()`	Returns the input typed as `Enumerable<TSource>`.
`static <T> Enumerable<T>`	Linq4j.`asEnumerable(Iterable<T> iterable)`	Adapter that converts an `Iterable` into an `Enumerable`.
`static <T> Enumerable<T>`	Linq4j.`asEnumerable(Collection<T> collection)`	Adapter that converts an `Collection` into an `Enumerable`.
`static <T> Enumerable<T>`	Linq4j.`asEnumerable(List<T> list)`	Adapter that converts an `List` into an `Enumerable`.
`static <T> Enumerable<T>`	Linq4j.`asEnumerable(T[] ts)`	Adapter that converts an array into an enumerable.
`<T2> Enumerable<T2>`	DefaultEnumerable.`cast(Class<T2> clazz)`
`static <TSource,T2> Enumerable<T2>`	EnumerableDefaults.`cast(Enumerable<TSource> source, Class<T2> clazz)`	Analogous to LINQ's Enumerable.Cast extension method.
`<T2> Enumerable<T2>`	ExtendedEnumerable.`cast(Class<T2> clazz)`	Converts the elements of this Enumerable to the specified type.
`static <TSource,TResult> Enumerable<TResult>`	Linq4j.`cast(Iterable<TSource> source, Class<TResult> clazz)`	Converts the elements of a given Iterable to the specified type.
`Enumerable<T>`	DefaultEnumerable.`concat(Enumerable<T> enumerable1)`
`static <TSource> Enumerable<TSource>`	EnumerableDefaults.`concat(Enumerable<TSource> enumerable0, Enumerable<TSource> enumerable1)`	Concatenates two sequences.
`Enumerable<TSource>`	ExtendedEnumerable.`concat(Enumerable<TSource> enumerable1)`	Concatenates two sequences.
`static <E> Enumerable<E>`	Linq4j.`concat(List<Enumerable<E>> enumerableList)`	Concatenates two or more `Enumerable`s to form a composite enumerable that contains the union of their elements.
`<TInner,TResult> Enumerable<TResult>`	DefaultEnumerable.`correlateJoin(CorrelateJoinType joinType, Function1<T,Enumerable<TInner>> inner, Function2<T,TInner,TResult> resultSelector)`
`static <TSource,TInner,TResult> Enumerable<TResult>`	EnumerableDefaults.`correlateJoin(CorrelateJoinType joinType, Enumerable<TSource> outer, Function1<TSource,Enumerable<TInner>> inner, Function2<TSource,TInner,TResult> resultSelector)`	Returns elements of `outer` for which there is a member of `inner` with a matching key.
`<TInner,TResult> Enumerable<TResult>`	ExtendedEnumerable.`correlateJoin(CorrelateJoinType joinType, Function1<TSource,Enumerable<TInner>> inner, Function2<TSource,TInner,TResult> resultSelector)`	For each row of the current enumerable returns the correlated rows from the `inner` enumerable (nested loops join).
`Enumerable<T>`	DefaultEnumerable.`defaultIfEmpty()`
`Enumerable<T>`	DefaultEnumerable.`defaultIfEmpty(T value)`
`static <TSource> Enumerable<TSource>`	EnumerableDefaults.`defaultIfEmpty(Enumerable<TSource> enumerable)`	Returns the elements of the specified sequence or the type parameter's default value in a singleton collection if the sequence is empty.
`static <TSource> Enumerable<TSource>`	EnumerableDefaults.`defaultIfEmpty(Enumerable<TSource> enumerable, TSource value)`	Returns the elements of the specified sequence or the specified value in a singleton collection if the sequence is empty.
`Enumerable<TSource>`	ExtendedEnumerable.`defaultIfEmpty()`	Returns the elements of the specified sequence or the type parameter's default value in a singleton collection if the sequence is empty.
`Enumerable<TSource>`	ExtendedEnumerable.`defaultIfEmpty(TSource value)`	Returns the elements of the specified sequence or the specified value in a singleton collection if the sequence is empty.
`Enumerable<T>`	DefaultEnumerable.`distinct()`
`Enumerable<T>`	DefaultEnumerable.`distinct(EqualityComparer<T> comparer)`
`static <TSource> Enumerable<TSource>`	EnumerableDefaults.`distinct(Enumerable<TSource> enumerable)`	Returns distinct elements from a sequence by using the default `EqualityComparer` to compare values.
`static <TSource> Enumerable<TSource>`	EnumerableDefaults.`distinct(Enumerable<TSource> enumerable, EqualityComparer<TSource> comparer)`	Returns distinct elements from a sequence by using a specified `EqualityComparer` to compare values.
`Enumerable<TSource>`	ExtendedEnumerable.`distinct()`	Returns distinct elements from a sequence by using the default equality comparer to compare values.
`Enumerable<TSource>`	ExtendedEnumerable.`distinct(EqualityComparer<TSource> comparer)`	Returns distinct elements from a sequence by using a specified `EqualityComparer<TSource>` to compare values.
`static <T> Enumerable<T>`	Linq4j.`emptyEnumerable()`	Returns an `Enumerable` that has no elements.
`Enumerable<T>`	DefaultEnumerable.`except(Enumerable<T> enumerable1)`
`Enumerable<T>`	DefaultEnumerable.`except(Enumerable<T> enumerable1, EqualityComparer<T> comparer)`
`static <TSource> Enumerable<TSource>`	EnumerableDefaults.`except(Enumerable<TSource> source0, Enumerable<TSource> source1)`	Produces the set difference of two sequences by using the default equality comparer to compare values.
`static <TSource> Enumerable<TSource>`	EnumerableDefaults.`except(Enumerable<TSource> source0, Enumerable<TSource> source1, EqualityComparer<TSource> comparer)`	Produces the set difference of two sequences by using the specified `EqualityComparer<TSource>` to compare values.
`Enumerable<TSource>`	ExtendedEnumerable.`except(Enumerable<TSource> enumerable1)`	Produces the set difference of two sequences by using the default equality comparer to compare values.
`Enumerable<TSource>`	ExtendedEnumerable.`except(Enumerable<TSource> enumerable1, EqualityComparer<TSource> comparer)`	Produces the set difference of two sequences by using the specified `EqualityComparer<TSource>` to compare values.
`Enumerable<V>`	LookupImpl.`get(Object key)`
`protected Enumerable<T>`	DefaultEnumerable.`getThis()`	Derived classes might wish to override this method to return the "outer" enumerable.
`protected Enumerable<T>`	EnumerableQueryable.`getThis()`
`Enumerable<V>`	GroupingImpl.`getValue()`
`<TKey> Enumerable<Grouping<TKey,T>>`	DefaultEnumerable.`groupBy(Function1<T,TKey> keySelector)`
`<TKey> Enumerable<Grouping<TKey,T>>`	DefaultEnumerable.`groupBy(Function1<T,TKey> keySelector, EqualityComparer<TKey> comparer)`
`<TKey,TAccumulate,TResult> Enumerable<TResult>`	DefaultEnumerable.`groupBy(Function1<T,TKey> keySelector, Function0<TAccumulate> accumulatorInitializer, Function2<TAccumulate,T,TAccumulate> accumulatorAdder, Function2<TKey,TAccumulate,TResult> resultSelector)`
`<TKey,TAccumulate,TResult> Enumerable<TResult>`	DefaultEnumerable.`groupBy(Function1<T,TKey> keySelector, Function0<TAccumulate> accumulatorInitializer, Function2<TAccumulate,T,TAccumulate> accumulatorAdder, Function2<TKey,TAccumulate,TResult> resultSelector, EqualityComparer<TKey> comparer)`
`<TKey,TElement> Enumerable<Grouping<TKey,TElement>>`	DefaultEnumerable.`groupBy(Function1<T,TKey> keySelector, Function1<T,TElement> elementSelector)`
`<TKey,TElement> Enumerable<Grouping<TKey,TElement>>`	DefaultEnumerable.`groupBy(Function1<T,TKey> keySelector, Function1<T,TElement> elementSelector, EqualityComparer<TKey> comparer)`
`<TKey,TElement,TResult> Enumerable<TResult>`	DefaultEnumerable.`groupBy(Function1<T,TKey> keySelector, Function1<T,TElement> elementSelector, Function2<TKey,Enumerable<TElement>,TResult> resultSelector)`
`<TKey,TElement,TResult> Enumerable<TResult>`	DefaultEnumerable.`groupBy(Function1<T,TKey> keySelector, Function1<T,TElement> elementSelector, Function2<TKey,Enumerable<TElement>,TResult> resultSelector, EqualityComparer<TKey> comparer)`
`<TKey,TResult> Enumerable<TResult>`	DefaultEnumerable.`groupBy(Function1<T,TKey> keySelector, Function2<TKey,Enumerable<T>,TResult> resultSelector)`
`<TKey,TResult> Enumerable<TResult>`	DefaultEnumerable.`groupBy(Function1<T,TKey> keySelector, Function2<TKey,Enumerable<T>,TResult> elementSelector, EqualityComparer<TKey> comparer)`
`static <TSource,TKey> Enumerable<Grouping<TKey,TSource>>`	EnumerableDefaults.`groupBy(Enumerable<TSource> enumerable, Function1<TSource,TKey> keySelector)`	Groups the elements of a sequence according to a specified key selector function.
`static <TSource,TKey> Enumerable<Grouping<TKey,TSource>>`	EnumerableDefaults.`groupBy(Enumerable<TSource> enumerable, Function1<TSource,TKey> keySelector, EqualityComparer<TKey> comparer)`	Groups the elements of a sequence according to a specified key selector function and compares the keys by using a specified comparer.
`static <TSource,TKey,TAccumulate,TResult> Enumerable<TResult>`	EnumerableDefaults.`groupBy(Enumerable<TSource> enumerable, Function1<TSource,TKey> keySelector, Function0<TAccumulate> accumulatorInitializer, Function2<TAccumulate,TSource,TAccumulate> accumulatorAdder, Function2<TKey,TAccumulate,TResult> resultSelector)`	Groups the elements of a sequence according to a specified key selector function, initializing an accumulator for each group and adding to it each time an element with the same key is seen.
`static <TSource,TKey,TAccumulate,TResult> Enumerable<TResult>`	EnumerableDefaults.`groupBy(Enumerable<TSource> enumerable, Function1<TSource,TKey> keySelector, Function0<TAccumulate> accumulatorInitializer, Function2<TAccumulate,TSource,TAccumulate> accumulatorAdder, Function2<TKey,TAccumulate,TResult> resultSelector, EqualityComparer<TKey> comparer)`	Groups the elements of a sequence according to a specified key selector function, initializing an accumulator for each group and adding to it each time an element with the same key is seen.
`static <TSource,TKey,TElement> Enumerable<Grouping<TKey,TElement>>`	EnumerableDefaults.`groupBy(Enumerable<TSource> enumerable, Function1<TSource,TKey> keySelector, Function1<TSource,TElement> elementSelector)`	Groups the elements of a sequence according to a specified key selector function and projects the elements for each group by using a specified function.
`static <TSource,TKey,TElement> Enumerable<Grouping<TKey,TElement>>`	EnumerableDefaults.`groupBy(Enumerable<TSource> enumerable, Function1<TSource,TKey> keySelector, Function1<TSource,TElement> elementSelector, EqualityComparer<TKey> comparer)`	Groups the elements of a sequence according to a key selector function.
`static <TSource,TKey,TElement,TResult> Enumerable<TResult>`	EnumerableDefaults.`groupBy(Enumerable<TSource> enumerable, Function1<TSource,TKey> keySelector, Function1<TSource,TElement> elementSelector, Function2<TKey,Enumerable<TElement>,TResult> resultSelector)`	Groups the elements of a sequence according to a specified key selector function and creates a result value from each group and its key.
`static <TSource,TKey,TElement,TResult> Enumerable<TResult>`	EnumerableDefaults.`groupBy(Enumerable<TSource> enumerable, Function1<TSource,TKey> keySelector, Function1<TSource,TElement> elementSelector, Function2<TKey,Enumerable<TElement>,TResult> resultSelector, EqualityComparer<TKey> comparer)`	Groups the elements of a sequence according to a specified key selector function and creates a result value from each group and its key.
`static <TSource,TKey,TResult> Enumerable<TResult>`	EnumerableDefaults.`groupBy(Enumerable<TSource> enumerable, Function1<TSource,TKey> keySelector, Function2<TKey,Enumerable<TSource>,TResult> resultSelector)`	Groups the elements of a sequence according to a specified key selector function and creates a result value from each group and its key.
`static <TSource,TKey,TResult> Enumerable<TResult>`	EnumerableDefaults.`groupBy(Enumerable<TSource> enumerable, Function1<TSource,TKey> keySelector, Function2<TKey,Enumerable<TSource>,TResult> resultSelector, EqualityComparer<TKey> comparer)`	Groups the elements of a sequence according to a specified key selector function and creates a result value from each group and its key.
`<TKey> Enumerable<Grouping<TKey,TSource>>`	ExtendedEnumerable.`groupBy(Function1<TSource,TKey> keySelector)`	Groups the elements of a sequence according to a specified key selector function.
`<TKey> Enumerable<Grouping<TKey,TSource>>`	ExtendedEnumerable.`groupBy(Function1<TSource,TKey> keySelector, EqualityComparer<TKey> comparer)`	Groups the elements of a sequence according to a specified key selector function and compares the keys by using a specified comparer.
`<TKey,TAccumulate,TResult> Enumerable<TResult>`	ExtendedEnumerable.`groupBy(Function1<TSource,TKey> keySelector, Function0<TAccumulate> accumulatorInitializer, Function2<TAccumulate,TSource,TAccumulate> accumulatorAdder, Function2<TKey,TAccumulate,TResult> resultSelector)`	Groups the elements of a sequence according to a specified key selector function, initializing an accumulator for each group and adding to it each time an element with the same key is seen.
`<TKey,TAccumulate,TResult> Enumerable<TResult>`	ExtendedEnumerable.`groupBy(Function1<TSource,TKey> keySelector, Function0<TAccumulate> accumulatorInitializer, Function2<TAccumulate,TSource,TAccumulate> accumulatorAdder, Function2<TKey,TAccumulate,TResult> resultSelector, EqualityComparer<TKey> comparer)`	Groups the elements of a sequence according to a specified key selector function, initializing an accumulator for each group and adding to it each time an element with the same key is seen.
`<TKey,TElement> Enumerable<Grouping<TKey,TElement>>`	ExtendedEnumerable.`groupBy(Function1<TSource,TKey> keySelector, Function1<TSource,TElement> elementSelector)`	Groups the elements of a sequence according to a specified key selector function and projects the elements for each group by using a specified function.
`<TKey,TElement> Enumerable<Grouping<TKey,TElement>>`	ExtendedEnumerable.`groupBy(Function1<TSource,TKey> keySelector, Function1<TSource,TElement> elementSelector, EqualityComparer<TKey> comparer)`	Groups the elements of a sequence according to a key selector function.
`<TKey,TElement,TResult> Enumerable<TResult>`	ExtendedEnumerable.`groupBy(Function1<TSource,TKey> keySelector, Function1<TSource,TElement> elementSelector, Function2<TKey,Enumerable<TElement>,TResult> resultSelector)`	Groups the elements of a sequence according to a specified key selector function and creates a result value from each group and its key.
`<TKey,TElement,TResult> Enumerable<TResult>`	ExtendedEnumerable.`groupBy(Function1<TSource,TKey> keySelector, Function1<TSource,TElement> elementSelector, Function2<TKey,Enumerable<TElement>,TResult> resultSelector, EqualityComparer<TKey> comparer)`	Groups the elements of a sequence according to a specified key selector function and creates a result value from each group and its key.
`<TKey,TResult> Enumerable<TResult>`	ExtendedEnumerable.`groupBy(Function1<TSource,TKey> keySelector, Function2<TKey,Enumerable<TSource>,TResult> resultSelector)`	Groups the elements of a sequence according to a specified key selector function and creates a result value from each group and its key.
`<TKey,TResult> Enumerable<TResult>`	ExtendedEnumerable.`groupBy(Function1<TSource,TKey> keySelector, Function2<TKey,Enumerable<TSource>,TResult> resultSelector, EqualityComparer<TKey> comparer)`	Groups the elements of a sequence according to a specified key selector function and creates a result value from each group and its key.
`private static <TSource,TKey,TAccumulate,TResult> Enumerable<TResult>`	EnumerableDefaults.`groupBy_(Map<TKey,TAccumulate> map, Enumerable<TSource> enumerable, Function1<TSource,TKey> keySelector, Function0<TAccumulate> accumulatorInitializer, Function2<TAccumulate,TSource,TAccumulate> accumulatorAdder, Function2<TKey,TAccumulate,TResult> resultSelector)`
`private static <TSource,TKey,TResult> Enumerable<TResult>`	EnumerableDefaults.`groupBy_(Set<TKey> map, Enumerable<TSource> enumerable, Function1<TSource,TKey> keySelector, Function1<TKey,TResult> resultSelector)`
`static <TSource,TKey,TAccumulate,TResult> Enumerable<TResult>`	EnumerableDefaults.`groupByMultiple(Enumerable<TSource> enumerable, List<Function1<TSource,TKey>> keySelectors, Function0<TAccumulate> accumulatorInitializer, Function2<TAccumulate,TSource,TAccumulate> accumulatorAdder, Function2<TKey,TAccumulate,TResult> resultSelector)`	Groups the elements of a sequence according to a list of specified key selector functions, initializing an accumulator for each group and adding to it each time an element with the same key is seen.
`private static <TSource,TKey,TAccumulate,TResult> Enumerable<TResult>`	EnumerableDefaults.`groupByMultiple_(Map<TKey,TAccumulate> map, Enumerable<TSource> enumerable, List<Function1<TSource,TKey>> keySelectors, Function0<TAccumulate> accumulatorInitializer, Function2<TAccumulate,TSource,TAccumulate> accumulatorAdder, Function2<TKey,TAccumulate,TResult> resultSelector)`
`<TInner,TKey,TResult> Enumerable<TResult>`	DefaultEnumerable.`groupJoin(Enumerable<TInner> inner, Function1<T,TKey> outerKeySelector, Function1<TInner,TKey> innerKeySelector, Function2<T,Enumerable<TInner>,TResult> resultSelector)`
`<TInner,TKey,TResult> Enumerable<TResult>`	DefaultEnumerable.`groupJoin(Enumerable<TInner> inner, Function1<T,TKey> outerKeySelector, Function1<TInner,TKey> innerKeySelector, Function2<T,Enumerable<TInner>,TResult> resultSelector, EqualityComparer<TKey> comparer)`
`static <TSource,TInner,TKey,TResult> Enumerable<TResult>`	EnumerableDefaults.`groupJoin(Enumerable<TSource> outer, Enumerable<TInner> inner, Function1<TSource,TKey> outerKeySelector, Function1<TInner,TKey> innerKeySelector, Function2<TSource,Enumerable<TInner>,TResult> resultSelector)`	Correlates the elements of two sequences based on equality of keys and groups the results.
`static <TSource,TInner,TKey,TResult> Enumerable<TResult>`	EnumerableDefaults.`groupJoin(Enumerable<TSource> outer, Enumerable<TInner> inner, Function1<TSource,TKey> outerKeySelector, Function1<TInner,TKey> innerKeySelector, Function2<TSource,Enumerable<TInner>,TResult> resultSelector, EqualityComparer<TKey> comparer)`	Correlates the elements of two sequences based on key equality and groups the results.
`<TInner,TKey,TResult> Enumerable<TResult>`	ExtendedEnumerable.`groupJoin(Enumerable<TInner> inner, Function1<TSource,TKey> outerKeySelector, Function1<TInner,TKey> innerKeySelector, Function2<TSource,Enumerable<TInner>,TResult> resultSelector)`	Correlates the elements of two sequences based on equality of keys and groups the results.
`<TInner,TKey,TResult> Enumerable<TResult>`	ExtendedEnumerable.`groupJoin(Enumerable<TInner> inner, Function1<TSource,TKey> outerKeySelector, Function1<TInner,TKey> innerKeySelector, Function2<TSource,Enumerable<TInner>,TResult> resultSelector, EqualityComparer<TKey> comparer)`	Correlates the elements of two sequences based on key equality and groups the results.
`static <TOuter,TInner,TKey,TResult> Enumerable<TResult>`	QueryableDefaults.`groupJoin(Queryable<TOuter> outer, Enumerable<TInner> inner, FunctionExpression<Function1<TOuter,TKey>> outerKeySelector, FunctionExpression<Function1<TInner,TKey>> innerKeySelector, FunctionExpression<Function2<TOuter,Enumerable<TInner>,TResult>> resultSelector, EqualityComparer<TKey> comparer)`	Correlates the elements of two sequences based on key equality and groups the results.
`Enumerable<T>`	DefaultEnumerable.`intersect(Enumerable<T> enumerable1)`
`Enumerable<T>`	DefaultEnumerable.`intersect(Enumerable<T> enumerable1, EqualityComparer<T> comparer)`
`static <TSource> Enumerable<TSource>`	EnumerableDefaults.`intersect(Enumerable<TSource> source0, Enumerable<TSource> source1)`	Produces the set intersection of two sequences by using the default equality comparer to compare values.
`static <TSource> Enumerable<TSource>`	EnumerableDefaults.`intersect(Enumerable<TSource> source0, Enumerable<TSource> source1, EqualityComparer<TSource> comparer)`	Produces the set intersection of two sequences by using the specified `EqualityComparer<TSource>` to compare values.
`Enumerable<TSource>`	ExtendedEnumerable.`intersect(Enumerable<TSource> enumerable1)`	Produces the set intersection of two sequences by using the default equality comparer to compare values.
`Enumerable<TSource>`	ExtendedEnumerable.`intersect(Enumerable<TSource> enumerable1, EqualityComparer<TSource> comparer)`	Produces the set intersection of two sequences by using the specified `EqualityComparer<TSource>` to compare values.
`<TInner,TKey,TResult> Enumerable<TResult>`	DefaultEnumerable.`join(Enumerable<TInner> inner, Function1<T,TKey> outerKeySelector, Function1<TInner,TKey> innerKeySelector, Function2<T,TInner,TResult> resultSelector)`
`<TInner,TKey,TResult> Enumerable<TResult>`	DefaultEnumerable.`join(Enumerable<TInner> inner, Function1<T,TKey> outerKeySelector, Function1<TInner,TKey> innerKeySelector, Function2<T,TInner,TResult> resultSelector, EqualityComparer<TKey> comparer)`
`<TInner,TKey,TResult> Enumerable<TResult>`	DefaultEnumerable.`join(Enumerable<TInner> inner, Function1<T,TKey> outerKeySelector, Function1<TInner,TKey> innerKeySelector, Function2<T,TInner,TResult> resultSelector, EqualityComparer<TKey> comparer, boolean generateNullsOnLeft, boolean generateNullsOnRight)`
`static <TSource,TInner,TKey,TResult> Enumerable<TResult>`	EnumerableDefaults.`join(Enumerable<TSource> outer, Enumerable<TInner> inner, Function1<TSource,TKey> outerKeySelector, Function1<TInner,TKey> innerKeySelector, Function2<TSource,TInner,TResult> resultSelector)`	Correlates the elements of two sequences based on matching keys.
`static <TSource,TInner,TKey,TResult> Enumerable<TResult>`	EnumerableDefaults.`join(Enumerable<TSource> outer, Enumerable<TInner> inner, Function1<TSource,TKey> outerKeySelector, Function1<TInner,TKey> innerKeySelector, Function2<TSource,TInner,TResult> resultSelector, EqualityComparer<TKey> comparer)`	Correlates the elements of two sequences based on matching keys.
`static <TSource,TInner,TKey,TResult> Enumerable<TResult>`	EnumerableDefaults.`join(Enumerable<TSource> outer, Enumerable<TInner> inner, Function1<TSource,TKey> outerKeySelector, Function1<TInner,TKey> innerKeySelector, Function2<TSource,TInner,TResult> resultSelector, EqualityComparer<TKey> comparer, boolean generateNullsOnLeft, boolean generateNullsOnRight)`	Correlates the elements of two sequences based on matching keys.
`<TInner,TKey,TResult> Enumerable<TResult>`	ExtendedEnumerable.`join(Enumerable<TInner> inner, Function1<TSource,TKey> outerKeySelector, Function1<TInner,TKey> innerKeySelector, Function2<TSource,TInner,TResult> resultSelector)`	Correlates the elements of two sequences based on matching keys.
`<TInner,TKey,TResult> Enumerable<TResult>`	ExtendedEnumerable.`join(Enumerable<TInner> inner, Function1<TSource,TKey> outerKeySelector, Function1<TInner,TKey> innerKeySelector, Function2<TSource,TInner,TResult> resultSelector, EqualityComparer<TKey> comparer)`	Correlates the elements of two sequences based on matching keys.
`<TInner,TKey,TResult> Enumerable<TResult>`	ExtendedEnumerable.`join(Enumerable<TInner> inner, Function1<TSource,TKey> outerKeySelector, Function1<TInner,TKey> innerKeySelector, Function2<TSource,TInner,TResult> resultSelector, EqualityComparer<TKey> comparer, boolean generateNullsOnLeft, boolean generateNullsOnRight)`	Correlates the elements of two sequences based on matching keys, with optional outer join semantics.
`private static <TSource,TInner,TKey,TResult> Enumerable<TResult>`	EnumerableDefaults.`join_(Enumerable<TSource> outer, Enumerable<TInner> inner, Function1<TSource,TKey> outerKeySelector, Function1<TInner,TKey> innerKeySelector, Function2<TSource,TInner,TResult> resultSelector, EqualityComparer<TKey> comparer, boolean generateNullsOnLeft, boolean generateNullsOnRight)`	Implementation of join that builds the right input and probes with the left.
`static <TSource,TInner,TKey extends Comparable<TKey>,TResult> Enumerable<TResult>`	EnumerableDefaults.`mergeJoin(Enumerable<TSource> outer, Enumerable<TInner> inner, Function1<TSource,TKey> outerKeySelector, Function1<TInner,TKey> innerKeySelector, Function2<TSource,TInner,TResult> resultSelector, boolean generateNullsOnLeft, boolean generateNullsOnRight)`	Joins two inputs that are sorted on the key.
`<TResult> Enumerable<TResult>`	DefaultEnumerable.`ofType(Class<TResult> clazz)`
`static <TSource,TResult> Enumerable<TResult>`	EnumerableDefaults.`ofType(Enumerable<TSource> enumerable, Class<TResult> clazz)`	Filters the elements of an Enumerable based on a specified type.
`<TResult> Enumerable<TResult>`	ExtendedEnumerable.`ofType(Class<TResult> clazz)`	Filters the elements of an Enumerable based on a specified type.
`static <TSource,TResult> Enumerable<TResult>`	Linq4j.`ofType(Iterable<TSource> source, Class<TResult> clazz)`	Returns elements of a given `Iterable` that are of the specified type.
`<TKey extends Comparable> Enumerable<T>`	DefaultEnumerable.`orderBy(Function1<T,TKey> keySelector)`
`<TKey> Enumerable<T>`	DefaultEnumerable.`orderBy(Function1<T,TKey> keySelector, Comparator<TKey> comparator)`
`static <TSource,TKey extends Comparable> Enumerable<TSource>`	EnumerableDefaults.`orderBy(Enumerable<TSource> source, Function1<TSource,TKey> keySelector)`	Sorts the elements of a sequence in ascending order according to a key.
`static <TSource,TKey> Enumerable<TSource>`	EnumerableDefaults.`orderBy(Enumerable<TSource> source, Function1<TSource,TKey> keySelector, Comparator<TKey> comparator)`	Sorts the elements of a sequence in ascending order by using a specified comparer.
`<TKey extends Comparable> Enumerable<TSource>`	ExtendedEnumerable.`orderBy(Function1<TSource,TKey> keySelector)`	Sorts the elements of a sequence in ascending order according to a key.
`<TKey> Enumerable<TSource>`	ExtendedEnumerable.`orderBy(Function1<TSource,TKey> keySelector, Comparator<TKey> comparator)`	Sorts the elements of a sequence in ascending order by using a specified comparer.
`<TKey extends Comparable> Enumerable<T>`	DefaultEnumerable.`orderByDescending(Function1<T,TKey> keySelector)`
`<TKey> Enumerable<T>`	DefaultEnumerable.`orderByDescending(Function1<T,TKey> keySelector, Comparator<TKey> comparator)`
`static <TSource,TKey extends Comparable> Enumerable<TSource>`	EnumerableDefaults.`orderByDescending(Enumerable<TSource> source, Function1<TSource,TKey> keySelector)`	Sorts the elements of a sequence in descending order according to a key.
`static <TSource,TKey> Enumerable<TSource>`	EnumerableDefaults.`orderByDescending(Enumerable<TSource> source, Function1<TSource,TKey> keySelector, Comparator<TKey> comparator)`	Sorts the elements of a sequence in descending order by using a specified comparer.
`<TKey extends Comparable> Enumerable<TSource>`	ExtendedEnumerable.`orderByDescending(Function1<TSource,TKey> keySelector)`	Sorts the elements of a sequence in descending order according to a key.
`<TKey> Enumerable<TSource>`	ExtendedEnumerable.`orderByDescending(Function1<TSource,TKey> keySelector, Comparator<TKey> comparator)`	Sorts the elements of a sequence in descending order by using a specified comparer.
`Enumerable<V>`	LookupImpl.`put(K key, Enumerable<V> value)`
`Enumerable<V>`	LookupImpl.`remove(Object key)`
`Enumerable<T>`	DefaultEnumerable.`reverse()`
`static <TSource> Enumerable<TSource>`	EnumerableDefaults.`reverse(Enumerable<TSource> source)`	Inverts the order of the elements in a sequence.
`Enumerable<TSource>`	ExtendedEnumerable.`reverse()`	Inverts the order of the elements in a sequence.
`<TResult> Enumerable<TResult>`	DefaultEnumerable.`select(Function1<T,TResult> selector)`
`<TResult> Enumerable<TResult>`	DefaultEnumerable.`select(Function2<T,Integer,TResult> selector)`
`static <TSource,TResult> Enumerable<TResult>`	EnumerableDefaults.`select(Enumerable<TSource> source, Function1<TSource,TResult> selector)`	Projects each element of a sequence into a new form.
`static <TSource,TResult> Enumerable<TResult>`	EnumerableDefaults.`select(Enumerable<TSource> source, Function2<TSource,Integer,TResult> selector)`	Projects each element of a sequence into a new form by incorporating the element's index.
`<TResult> Enumerable<TResult>`	ExtendedEnumerable.`select(Function1<TSource,TResult> selector)`	Projects each element of a sequence into a new form.
`<TResult> Enumerable<TResult>`	ExtendedEnumerable.`select(Function2<TSource,Integer,TResult> selector)`	Projects each element of a sequence into a new form by incorporating the element's index.
`<TCollection,TResult> Enumerable<TResult>`	DefaultEnumerable.`selectMany(Function1<T,Enumerable<TCollection>> collectionSelector, Function2<T,TCollection,TResult> resultSelector)`
`<TResult> Enumerable<TResult>`	DefaultEnumerable.`selectMany(Function1<T,Enumerable<TResult>> selector)`
`<TCollection,TResult> Enumerable<TResult>`	DefaultEnumerable.`selectMany(Function2<T,Integer,Enumerable<TCollection>> collectionSelector, Function2<T,TCollection,TResult> resultSelector)`
`<TResult> Enumerable<TResult>`	DefaultEnumerable.`selectMany(Function2<T,Integer,Enumerable<TResult>> selector)`
`static <TSource,TCollection,TResult> Enumerable<TResult>`	EnumerableDefaults.`selectMany(Enumerable<TSource> source, Function1<TSource,Enumerable<TCollection>> collectionSelector, Function2<TSource,TCollection,TResult> resultSelector)`	Projects each element of a sequence to an `Enumerable<TSource>`, flattens the resulting sequences into one sequence, and invokes a result selector function on each element therein.
`static <TSource,TResult> Enumerable<TResult>`	EnumerableDefaults.`selectMany(Enumerable<TSource> source, Function1<TSource,Enumerable<TResult>> selector)`	Projects each element of a sequence to an `Enumerable<TSource>` and flattens the resulting sequences into one sequence.
`static <TSource,TCollection,TResult> Enumerable<TResult>`	EnumerableDefaults.`selectMany(Enumerable<TSource> source, Function2<TSource,Integer,Enumerable<TCollection>> collectionSelector, Function2<TSource,TCollection,TResult> resultSelector)`	Projects each element of a sequence to an `Enumerable<TSource>`, flattens the resulting sequences into one sequence, and invokes a result selector function on each element therein.
`static <TSource,TResult> Enumerable<TResult>`	EnumerableDefaults.`selectMany(Enumerable<TSource> source, Function2<TSource,Integer,Enumerable<TResult>> selector)`	Projects each element of a sequence to an `Enumerable<TSource>`, and flattens the resulting sequences into one sequence.
`<TCollection,TResult> Enumerable<TResult>`	ExtendedEnumerable.`selectMany(Function1<TSource,Enumerable<TCollection>> collectionSelector, Function2<TSource,TCollection,TResult> resultSelector)`	Projects each element of a sequence to an `Enumerable<TSource>`, flattens the resulting sequences into one sequence, and invokes a result selector function on each element therein.
`<TResult> Enumerable<TResult>`	ExtendedEnumerable.`selectMany(Function1<TSource,Enumerable<TResult>> selector)`	Projects each element of a sequence to an `Enumerable<TSource>` and flattens the resulting sequences into one sequence.
`<TCollection,TResult> Enumerable<TResult>`	ExtendedEnumerable.`selectMany(Function2<TSource,Integer,Enumerable<TCollection>> collectionSelector, Function2<TSource,TCollection,TResult> resultSelector)`	Projects each element of a sequence to an `Enumerable<TSource>`, flattens the resulting sequences into one sequence, and invokes a result selector function on each element therein.
`<TResult> Enumerable<TResult>`	ExtendedEnumerable.`selectMany(Function2<TSource,Integer,Enumerable<TResult>> selector)`	Projects each element of a sequence to an `Enumerable<TSource>`, and flattens the resulting sequences into one sequence.
`static <TSource,TInner,TKey> Enumerable<TSource>`	EnumerableDefaults.`semiJoin(Enumerable<TSource> outer, Enumerable<TInner> inner, Function1<TSource,TKey> outerKeySelector, Function1<TInner,TKey> innerKeySelector)`	Returns elements of `outer` for which there is a member of `inner` with a matching key.
`static <TSource,TInner,TKey> Enumerable<TSource>`	EnumerableDefaults.`semiJoin(Enumerable<TSource> outer, Enumerable<TInner> inner, Function1<TSource,TKey> outerKeySelector, Function1<TInner,TKey> innerKeySelector, EqualityComparer<TKey> comparer)`	Returns elements of `outer` for which there is a member of `inner` with a matching key.
`Enumerable<V>`	GroupingImpl.`setValue(Enumerable<V> value)`
`static <T> Enumerable<T>`	Linq4j.`singletonEnumerable(T element)`	Returns an `Enumerable` that has one element.
`Enumerable<T>`	DefaultEnumerable.`skip(int count)`
`static <TSource> Enumerable<TSource>`	EnumerableDefaults.`skip(Enumerable<TSource> source, int count)`	Bypasses a specified number of elements in a sequence and then returns the remaining elements.
`Enumerable<TSource>`	ExtendedEnumerable.`skip(int count)`	Bypasses a specified number of elements in a sequence and then returns the remaining elements.
`Enumerable<T>`	Linq4j.ListEnumerable.`skip(int count)`
`Enumerable<T>`	DefaultEnumerable.`skipWhile(Predicate1<T> predicate)`
`Enumerable<T>`	DefaultEnumerable.`skipWhile(Predicate2<T,Integer> predicate)`
`static <TSource> Enumerable<TSource>`	EnumerableDefaults.`skipWhile(Enumerable<TSource> source, Predicate1<TSource> predicate)`	Bypasses elements in a sequence as long as a specified condition is true and then returns the remaining elements.
`static <TSource> Enumerable<TSource>`	EnumerableDefaults.`skipWhile(Enumerable<TSource> source, Predicate2<TSource,Integer> predicate)`	Bypasses elements in a sequence as long as a specified condition is true and then returns the remaining elements.
`Enumerable<TSource>`	ExtendedEnumerable.`skipWhile(Predicate1<TSource> predicate)`	Bypasses elements in a sequence as long as a specified condition is true and then returns the remaining elements.
`Enumerable<TSource>`	ExtendedEnumerable.`skipWhile(Predicate2<TSource,Integer> predicate)`	Bypasses elements in a sequence as long as a specified condition is true and then returns the remaining elements.
`Enumerable<T>`	DefaultEnumerable.`take(int count)`
`static <TSource> Enumerable<TSource>`	EnumerableDefaults.`take(Enumerable<TSource> source, int count)`	Returns a specified number of contiguous elements from the start of a sequence.
`static <TSource> Enumerable<TSource>`	EnumerableDefaults.`take(Enumerable<TSource> source, long count)`	Returns a specified number of contiguous elements from the start of a sequence.
`Enumerable<TSource>`	ExtendedEnumerable.`take(int count)`	Returns a specified number of contiguous elements from the start of a sequence.
`Enumerable<T>`	Linq4j.ListEnumerable.`take(int count)`
`Enumerable<T>`	DefaultEnumerable.`takeWhile(Predicate1<T> predicate)`
`Enumerable<T>`	DefaultEnumerable.`takeWhile(Predicate2<T,Integer> predicate)`
`static <TSource> Enumerable<TSource>`	EnumerableDefaults.`takeWhile(Enumerable<TSource> source, Predicate1<TSource> predicate)`	Returns elements from a sequence as long as a specified condition is true.
`static <TSource> Enumerable<TSource>`	EnumerableDefaults.`takeWhile(Enumerable<TSource> source, Predicate2<TSource,Integer> predicate)`	Returns elements from a sequence as long as a specified condition is true.
`Enumerable<TSource>`	ExtendedEnumerable.`takeWhile(Predicate1<TSource> predicate)`	Returns elements from a sequence as long as a specified condition is true.
`Enumerable<TSource>`	ExtendedEnumerable.`takeWhile(Predicate2<TSource,Integer> predicate)`	Returns elements from a sequence as long as a specified condition is true.
`static <TSource> Enumerable<TSource>`	EnumerableDefaults.`takeWhileLong(Enumerable<TSource> source, Predicate2<TSource,Long> predicate)`	Returns elements from a sequence as long as a specified condition is true.
`static <TSource,TInner,TResult> Enumerable<TResult>`	EnumerableDefaults.`thetaJoin(Enumerable<TSource> outer, Enumerable<TInner> inner, Predicate2<TSource,TInner> predicate, Function2<TSource,TInner,TResult> resultSelector, boolean generateNullsOnLeft, boolean generateNullsOnRight)`	Correlates the elements of two sequences based on a predicate.
`Enumerable<T>`	DefaultEnumerable.`union(Enumerable<T> source1)`
`Enumerable<T>`	DefaultEnumerable.`union(Enumerable<T> source1, EqualityComparer<T> comparer)`
`static <TSource> Enumerable<TSource>`	EnumerableDefaults.`union(Enumerable<TSource> source0, Enumerable<TSource> source1)`	Produces the set union of two sequences by using the default equality comparer.
`static <TSource> Enumerable<TSource>`	EnumerableDefaults.`union(Enumerable<TSource> source0, Enumerable<TSource> source1, EqualityComparer<TSource> comparer)`	Produces the set union of two sequences by using a specified EqualityComparer<TSource>.
`Enumerable<TSource>`	ExtendedEnumerable.`union(Enumerable<TSource> source1)`	Produces the set union of two sequences by using the default equality comparer.
`Enumerable<TSource>`	ExtendedEnumerable.`union(Enumerable<TSource> source1, EqualityComparer<TSource> comparer)`	Produces the set union of two sequences by using a specified `EqualityComparer<TSource>`.
`Enumerable<V>`	LookupImpl.`valuesEnumerable()`	Returns an enumerable over the values in this lookup, in map order.
`Enumerable<T>`	DefaultEnumerable.`where(Predicate1<T> predicate)`
`Enumerable<T>`	DefaultEnumerable.`where(Predicate2<T,Integer> predicate)`
`static <TSource> Enumerable<TSource>`	EnumerableDefaults.`where(Enumerable<TSource> source, Predicate1<TSource> predicate)`	Filters a sequence of values based on a predicate.
`static <TSource> Enumerable<TSource>`	EnumerableDefaults.`where(Enumerable<TSource> source, Predicate2<TSource,Integer> predicate)`	Filters a sequence of values based on a predicate.
`Enumerable<TSource>`	ExtendedEnumerable.`where(Predicate1<TSource> predicate)`	Filters a sequence of values based on a predicate.
`Enumerable<TSource>`	ExtendedEnumerable.`where(Predicate2<TSource,Integer> predicate)`	Filters a sequence of values based on a predicate.
`<T1,TResult> Enumerable<TResult>`	DefaultEnumerable.`zip(Enumerable<T1> source1, Function2<T,T1,TResult> resultSelector)`
`static <T0,T1,TResult> Enumerable<TResult>`	EnumerableDefaults.`zip(Enumerable<T0> first, Enumerable<T1> second, Function2<T0,T1,TResult> resultSelector)`	Applies a specified function to the corresponding elements of two sequences, producing a sequence of the results.
`<T1,TResult> Enumerable<TResult>`	ExtendedEnumerable.`zip(Enumerable<T1> source1, Function2<TSource,T1,TResult> resultSelector)`	Applies a specified function to the corresponding elements of two sequences, producing a sequence of the results.

Methods in org.apache.calcite.linq4j that return types with arguments of type Enumerable
Modifier and Type	Method	Description
`Set<Map.Entry<K,Enumerable<V>>>`	LookupImpl.`entrySet()`
`Collection<Enumerable<V>>`	LookupImpl.`values()`

Methods in org.apache.calcite.linq4j with parameters of type Enumerable
Modifier and Type	Method	Description
`static <TSource> TSource`	EnumerableDefaults.`aggregate(Enumerable<TSource> source, Function2<TSource,TSource,TSource> func)`	Applies an accumulator function over a sequence.
`static <TSource,TAccumulate> TAccumulate`	EnumerableDefaults.`aggregate(Enumerable<TSource> source, TAccumulate seed, Function2<TAccumulate,TSource,TAccumulate> func)`	Applies an accumulator function over a sequence.
`static <TSource,TAccumulate,TResult> TResult`	EnumerableDefaults.`aggregate(Enumerable<TSource> source, TAccumulate seed, Function2<TAccumulate,TSource,TAccumulate> func, Function1<TAccumulate,TResult> selector)`	Applies an accumulator function over a sequence.
`static <TSource> boolean`	EnumerableDefaults.`all(Enumerable<TSource> enumerable, Predicate1<TSource> predicate)`	Determines whether all elements of a sequence satisfy a condition.
`static boolean`	EnumerableDefaults.`any(Enumerable enumerable)`	Determines whether a sequence contains any elements.
`static <TSource> boolean`	EnumerableDefaults.`any(Enumerable<TSource> enumerable, Predicate1<TSource> predicate)`	Determines whether any element of a sequence satisfies a condition.
`static <TSource> Enumerable<TSource>`	EnumerableDefaults.`asEnumerable(Enumerable<TSource> enumerable)`	Returns the input typed as `Enumerable<TSource>`.
`static <T> OrderedQueryable<T>`	EnumerableDefaults.`asOrderedQueryable(Enumerable<T> source)`
`static <TSource> Queryable<TSource>`	EnumerableDefaults.`asQueryable(Enumerable<TSource> enumerable)`	Converts an Enumerable to an IQueryable.
`static <TSource> BigDecimal`	EnumerableDefaults.`average(Enumerable<TSource> source, BigDecimalFunction1<TSource> selector)`	Computes the average of a sequence of Decimal values that are obtained by invoking a transform function on each element of the input sequence.
`static <TSource> double`	EnumerableDefaults.`average(Enumerable<TSource> source, DoubleFunction1<TSource> selector)`	Computes the average of a sequence of Double values that are obtained by invoking a transform function on each element of the input sequence.
`static <TSource> float`	EnumerableDefaults.`average(Enumerable<TSource> source, FloatFunction1<TSource> selector)`	Computes the average of a sequence of Float values that are obtained by invoking a transform function on each element of the input sequence.
`static <TSource> int`	EnumerableDefaults.`average(Enumerable<TSource> source, IntegerFunction1<TSource> selector)`	Computes the average of a sequence of int values that are obtained by invoking a transform function on each element of the input sequence.
`static <TSource> long`	EnumerableDefaults.`average(Enumerable<TSource> source, LongFunction1<TSource> selector)`	Computes the average of a sequence of long values that are obtained by invoking a transform function on each element of the input sequence.
`static <TSource> BigDecimal`	EnumerableDefaults.`average(Enumerable<TSource> source, NullableBigDecimalFunction1<TSource> selector)`	Computes the average of a sequence of nullable Decimal values that are obtained by invoking a transform function on each element of the input sequence.
`static <TSource> Double`	EnumerableDefaults.`average(Enumerable<TSource> source, NullableDoubleFunction1<TSource> selector)`	Computes the average of a sequence of nullable Double values that are obtained by invoking a transform function on each element of the input sequence.
`static <TSource> Float`	EnumerableDefaults.`average(Enumerable<TSource> source, NullableFloatFunction1<TSource> selector)`	Computes the average of a sequence of nullable Float values that are obtained by invoking a transform function on each element of the input sequence.
`static <TSource> Integer`	EnumerableDefaults.`average(Enumerable<TSource> source, NullableIntegerFunction1<TSource> selector)`	Computes the average of a sequence of nullable int values that are obtained by invoking a transform function on each element of the input sequence.
`static <TSource> Long`	EnumerableDefaults.`average(Enumerable<TSource> source, NullableLongFunction1<TSource> selector)`	Computes the average of a sequence of nullable long values that are obtained by invoking a transform function on each element of the input sequence.
`static <TSource,T2> Enumerable<T2>`	EnumerableDefaults.`cast(Enumerable<TSource> source, Class<T2> clazz)`	Analogous to LINQ's Enumerable.Cast extension method.
`Enumerable<T>`	DefaultEnumerable.`concat(Enumerable<T> enumerable1)`
`Queryable<T>`	DefaultQueryable.`concat(Enumerable<T> source2)`
`static <TSource> Enumerable<TSource>`	EnumerableDefaults.`concat(Enumerable<TSource> enumerable0, Enumerable<TSource> enumerable1)`	Concatenates two sequences.
`Queryable<T>`	EnumerableQueryable.`concat(Enumerable<T> source2)`
`Enumerable<TSource>`	ExtendedEnumerable.`concat(Enumerable<TSource> enumerable1)`	Concatenates two sequences.
`Queryable<TSource>`	ExtendedQueryable.`concat(Enumerable<TSource> source2)`	Concatenates two sequences.
`static <T> Queryable<T>`	QueryableDefaults.`concat(Queryable<T> queryable0, Enumerable<T> source2)`	Concatenates two sequences.
`Queryable<T>`	QueryableFactory.`concat(Queryable<T> source, Enumerable<T> source2)`	Concatenates two sequences.
`Queryable<T>`	QueryableRecorder.`concat(Queryable<T> source, Enumerable<T> source2)`
`static <TSource> boolean`	EnumerableDefaults.`contains(Enumerable<TSource> enumerable, TSource element)`	Determines whether a sequence contains a specified element by using the default equality comparer.
`static <TSource> boolean`	EnumerableDefaults.`contains(Enumerable<TSource> enumerable, TSource element, EqualityComparer<TSource> comparer)`	Determines whether a sequence contains a specified element by using a specified `EqualityComparer<TSource>`.
`static <TSource,TInner,TResult> Enumerable<TResult>`	EnumerableDefaults.`correlateJoin(CorrelateJoinType joinType, Enumerable<TSource> outer, Function1<TSource,Enumerable<TInner>> inner, Function2<TSource,TInner,TResult> resultSelector)`	Returns elements of `outer` for which there is a member of `inner` with a matching key.
`static <TSource> int`	EnumerableDefaults.`count(Enumerable<TSource> enumerable)`	Returns the number of elements in a sequence.
`static <TSource> int`	EnumerableDefaults.`count(Enumerable<TSource> enumerable, Predicate1<TSource> predicate)`	Returns a number that represents how many elements in the specified sequence satisfy a condition.
`static <TSource> Enumerable<TSource>`	EnumerableDefaults.`defaultIfEmpty(Enumerable<TSource> enumerable)`	Returns the elements of the specified sequence or the type parameter's default value in a singleton collection if the sequence is empty.
`static <TSource> Enumerable<TSource>`	EnumerableDefaults.`defaultIfEmpty(Enumerable<TSource> enumerable, TSource value)`	Returns the elements of the specified sequence or the specified value in a singleton collection if the sequence is empty.
`static <TSource> Enumerable<TSource>`	EnumerableDefaults.`distinct(Enumerable<TSource> enumerable)`	Returns distinct elements from a sequence by using the default `EqualityComparer` to compare values.
`static <TSource> Enumerable<TSource>`	EnumerableDefaults.`distinct(Enumerable<TSource> enumerable, EqualityComparer<TSource> comparer)`	Returns distinct elements from a sequence by using a specified `EqualityComparer` to compare values.
`static <TSource> TSource`	EnumerableDefaults.`elementAt(Enumerable<TSource> enumerable, int index)`	Returns the element at a specified index in a sequence.
`static <TSource> TSource`	EnumerableDefaults.`elementAtOrDefault(Enumerable<TSource> enumerable, int index)`	Returns the element at a specified index in a sequence or a default value if the index is out of range.
`Enumerable<T>`	DefaultEnumerable.`except(Enumerable<T> enumerable1)`
`Enumerable<T>`	DefaultEnumerable.`except(Enumerable<T> enumerable1, EqualityComparer<T> comparer)`
`Queryable<T>`	DefaultQueryable.`except(Enumerable<T> enumerable1)`
`Queryable<T>`	DefaultQueryable.`except(Enumerable<T> enumerable1, EqualityComparer<T> comparer)`
`static <TSource> Enumerable<TSource>`	EnumerableDefaults.`except(Enumerable<TSource> source0, Enumerable<TSource> source1)`	Produces the set difference of two sequences by using the default equality comparer to compare values.
`static <TSource> Enumerable<TSource>`	EnumerableDefaults.`except(Enumerable<TSource> source0, Enumerable<TSource> source1, EqualityComparer<TSource> comparer)`	Produces the set difference of two sequences by using the specified `EqualityComparer<TSource>` to compare values.
`Queryable<T>`	EnumerableQueryable.`except(Enumerable<T> enumerable1)`
`Queryable<T>`	EnumerableQueryable.`except(Enumerable<T> enumerable1, EqualityComparer<T> comparer)`
`Enumerable<TSource>`	ExtendedEnumerable.`except(Enumerable<TSource> enumerable1)`	Produces the set difference of two sequences by using the default equality comparer to compare values.
`Enumerable<TSource>`	ExtendedEnumerable.`except(Enumerable<TSource> enumerable1, EqualityComparer<TSource> comparer)`	Produces the set difference of two sequences by using the specified `EqualityComparer<TSource>` to compare values.
`Queryable<TSource>`	ExtendedQueryable.`except(Enumerable<TSource> enumerable)`	Produces the set difference of two sequences by using the default equality comparer to compare values.
`Queryable<TSource>`	ExtendedQueryable.`except(Enumerable<TSource> enumerable, EqualityComparer<TSource> comparer)`	Produces the set difference of two sequences by using the specified `EqualityComparer<TSource>` to compare values.
`static <T> Queryable<T>`	QueryableDefaults.`except(Queryable<T> queryable, Enumerable<T> enumerable)`	Produces the set difference of two sequences by using the default equality comparer to compare values.
`static <T> Queryable<T>`	QueryableDefaults.`except(Queryable<T> queryable, Enumerable<T> enumerable, EqualityComparer<T> comparer)`	Produces the set difference of two sequences by using the specified `EqualityComparer<T>` to compare values.
`Queryable<T>`	QueryableFactory.`except(Queryable<T> source, Enumerable<T> enumerable)`	Produces the set difference of two sequences by using the default equality comparer to compare values.
`Queryable<T>`	QueryableFactory.`except(Queryable<T> source, Enumerable<T> enumerable, EqualityComparer<T> comparer)`	Produces the set difference of two sequences by using the specified `EqualityComparer<T>` to compare values.
`Queryable<T>`	QueryableRecorder.`except(Queryable<T> source, Enumerable<T> enumerable)`
`Queryable<T>`	QueryableRecorder.`except(Queryable<T> source, Enumerable<T> enumerable, EqualityComparer<T> comparer)`
`static <TSource> TSource`	EnumerableDefaults.`first(Enumerable<TSource> enumerable)`	Returns the first element of a sequence.
`static <TSource> TSource`	EnumerableDefaults.`first(Enumerable<TSource> enumerable, Predicate1<TSource> predicate)`	Returns the first element in a sequence that satisfies a specified condition.
`static <TSource> TSource`	EnumerableDefaults.`firstOrDefault(Enumerable<TSource> enumerable)`	Returns the first element of a sequence, or a default value if the sequence contains no elements.
`static <TSource> TSource`	EnumerableDefaults.`firstOrDefault(Enumerable<TSource> enumerable, Predicate1<TSource> predicate)`	Returns the first element of the sequence that satisfies a condition or a default value if no such element is found.
`static <TSource,TKey> Enumerable<Grouping<TKey,TSource>>`	EnumerableDefaults.`groupBy(Enumerable<TSource> enumerable, Function1<TSource,TKey> keySelector)`	Groups the elements of a sequence according to a specified key selector function.
`static <TSource,TKey> Enumerable<Grouping<TKey,TSource>>`	EnumerableDefaults.`groupBy(Enumerable<TSource> enumerable, Function1<TSource,TKey> keySelector, EqualityComparer<TKey> comparer)`	Groups the elements of a sequence according to a specified key selector function and compares the keys by using a specified comparer.
`static <TSource,TKey,TAccumulate,TResult> Enumerable<TResult>`	EnumerableDefaults.`groupBy(Enumerable<TSource> enumerable, Function1<TSource,TKey> keySelector, Function0<TAccumulate> accumulatorInitializer, Function2<TAccumulate,TSource,TAccumulate> accumulatorAdder, Function2<TKey,TAccumulate,TResult> resultSelector)`	Groups the elements of a sequence according to a specified key selector function, initializing an accumulator for each group and adding to it each time an element with the same key is seen.
`static <TSource,TKey,TAccumulate,TResult> Enumerable<TResult>`	EnumerableDefaults.`groupBy(Enumerable<TSource> enumerable, Function1<TSource,TKey> keySelector, Function0<TAccumulate> accumulatorInitializer, Function2<TAccumulate,TSource,TAccumulate> accumulatorAdder, Function2<TKey,TAccumulate,TResult> resultSelector, EqualityComparer<TKey> comparer)`	Groups the elements of a sequence according to a specified key selector function, initializing an accumulator for each group and adding to it each time an element with the same key is seen.
`static <TSource,TKey,TElement> Enumerable<Grouping<TKey,TElement>>`	EnumerableDefaults.`groupBy(Enumerable<TSource> enumerable, Function1<TSource,TKey> keySelector, Function1<TSource,TElement> elementSelector)`	Groups the elements of a sequence according to a specified key selector function and projects the elements for each group by using a specified function.
`static <TSource,TKey,TElement> Enumerable<Grouping<TKey,TElement>>`	EnumerableDefaults.`groupBy(Enumerable<TSource> enumerable, Function1<TSource,TKey> keySelector, Function1<TSource,TElement> elementSelector, EqualityComparer<TKey> comparer)`	Groups the elements of a sequence according to a key selector function.
`static <TSource,TKey,TElement,TResult> Enumerable<TResult>`	EnumerableDefaults.`groupBy(Enumerable<TSource> enumerable, Function1<TSource,TKey> keySelector, Function1<TSource,TElement> elementSelector, Function2<TKey,Enumerable<TElement>,TResult> resultSelector)`	Groups the elements of a sequence according to a specified key selector function and creates a result value from each group and its key.
`static <TSource,TKey,TElement,TResult> Enumerable<TResult>`	EnumerableDefaults.`groupBy(Enumerable<TSource> enumerable, Function1<TSource,TKey> keySelector, Function1<TSource,TElement> elementSelector, Function2<TKey,Enumerable<TElement>,TResult> resultSelector, EqualityComparer<TKey> comparer)`	Groups the elements of a sequence according to a specified key selector function and creates a result value from each group and its key.
`static <TSource,TKey,TResult> Enumerable<TResult>`	EnumerableDefaults.`groupBy(Enumerable<TSource> enumerable, Function1<TSource,TKey> keySelector, Function2<TKey,Enumerable<TSource>,TResult> resultSelector)`	Groups the elements of a sequence according to a specified key selector function and creates a result value from each group and its key.
`static <TSource,TKey,TResult> Enumerable<TResult>`	EnumerableDefaults.`groupBy(Enumerable<TSource> enumerable, Function1<TSource,TKey> keySelector, Function2<TKey,Enumerable<TSource>,TResult> resultSelector, EqualityComparer<TKey> comparer)`	Groups the elements of a sequence according to a specified key selector function and creates a result value from each group and its key.
`private static <TSource,TKey,TAccumulate,TResult> Enumerable<TResult>`	EnumerableDefaults.`groupBy_(Map<TKey,TAccumulate> map, Enumerable<TSource> enumerable, Function1<TSource,TKey> keySelector, Function0<TAccumulate> accumulatorInitializer, Function2<TAccumulate,TSource,TAccumulate> accumulatorAdder, Function2<TKey,TAccumulate,TResult> resultSelector)`
`private static <TSource,TKey,TResult> Enumerable<TResult>`	EnumerableDefaults.`groupBy_(Set<TKey> map, Enumerable<TSource> enumerable, Function1<TSource,TKey> keySelector, Function1<TKey,TResult> resultSelector)`
`static <TSource,TKey,TAccumulate,TResult> Enumerable<TResult>`	EnumerableDefaults.`groupByMultiple(Enumerable<TSource> enumerable, List<Function1<TSource,TKey>> keySelectors, Function0<TAccumulate> accumulatorInitializer, Function2<TAccumulate,TSource,TAccumulate> accumulatorAdder, Function2<TKey,TAccumulate,TResult> resultSelector)`	Groups the elements of a sequence according to a list of specified key selector functions, initializing an accumulator for each group and adding to it each time an element with the same key is seen.
`private static <TSource,TKey,TAccumulate,TResult> Enumerable<TResult>`	EnumerableDefaults.`groupByMultiple_(Map<TKey,TAccumulate> map, Enumerable<TSource> enumerable, List<Function1<TSource,TKey>> keySelectors, Function0<TAccumulate> accumulatorInitializer, Function2<TAccumulate,TSource,TAccumulate> accumulatorAdder, Function2<TKey,TAccumulate,TResult> resultSelector)`
`<TInner,TKey,TResult> Enumerable<TResult>`	DefaultEnumerable.`groupJoin(Enumerable<TInner> inner, Function1<T,TKey> outerKeySelector, Function1<TInner,TKey> innerKeySelector, Function2<T,Enumerable<TInner>,TResult> resultSelector)`
`<TInner,TKey,TResult> Enumerable<TResult>`	DefaultEnumerable.`groupJoin(Enumerable<TInner> inner, Function1<T,TKey> outerKeySelector, Function1<TInner,TKey> innerKeySelector, Function2<T,Enumerable<TInner>,TResult> resultSelector, EqualityComparer<TKey> comparer)`
`<TInner,TKey,TResult> Queryable<TResult>`	DefaultQueryable.`groupJoin(Enumerable<TInner> inner, FunctionExpression<Function1<T,TKey>> outerKeySelector, FunctionExpression<Function1<TInner,TKey>> innerKeySelector, FunctionExpression<Function2<T,Enumerable<TInner>,TResult>> resultSelector)`
`<TInner,TKey,TResult> Queryable<TResult>`	DefaultQueryable.`groupJoin(Enumerable<TInner> inner, FunctionExpression<Function1<T,TKey>> outerKeySelector, FunctionExpression<Function1<TInner,TKey>> innerKeySelector, FunctionExpression<Function2<T,Enumerable<TInner>,TResult>> resultSelector, EqualityComparer<TKey> comparer)`
`static <TSource,TInner,TKey,TResult> Enumerable<TResult>`	EnumerableDefaults.`groupJoin(Enumerable<TSource> outer, Enumerable<TInner> inner, Function1<TSource,TKey> outerKeySelector, Function1<TInner,TKey> innerKeySelector, Function2<TSource,Enumerable<TInner>,TResult> resultSelector)`	Correlates the elements of two sequences based on equality of keys and groups the results.
`static <TSource,TInner,TKey,TResult> Enumerable<TResult>`	EnumerableDefaults.`groupJoin(Enumerable<TSource> outer, Enumerable<TInner> inner, Function1<TSource,TKey> outerKeySelector, Function1<TInner,TKey> innerKeySelector, Function2<TSource,Enumerable<TInner>,TResult> resultSelector, EqualityComparer<TKey> comparer)`	Correlates the elements of two sequences based on key equality and groups the results.
`<TInner,TKey,TResult> Queryable<TResult>`	EnumerableQueryable.`groupJoin(Enumerable<TInner> inner, FunctionExpression<Function1<T,TKey>> outerKeySelector, FunctionExpression<Function1<TInner,TKey>> innerKeySelector, FunctionExpression<Function2<T,Enumerable<TInner>,TResult>> resultSelector)`
`<TInner,TKey,TResult> Queryable<TResult>`	EnumerableQueryable.`groupJoin(Enumerable<TInner> inner, FunctionExpression<Function1<T,TKey>> outerKeySelector, FunctionExpression<Function1<TInner,TKey>> innerKeySelector, FunctionExpression<Function2<T,Enumerable<TInner>,TResult>> resultSelector, EqualityComparer<TKey> comparer)`
`<TInner,TKey,TResult> Enumerable<TResult>`	ExtendedEnumerable.`groupJoin(Enumerable<TInner> inner, Function1<TSource,TKey> outerKeySelector, Function1<TInner,TKey> innerKeySelector, Function2<TSource,Enumerable<TInner>,TResult> resultSelector)`	Correlates the elements of two sequences based on equality of keys and groups the results.
`<TInner,TKey,TResult> Enumerable<TResult>`	ExtendedEnumerable.`groupJoin(Enumerable<TInner> inner, Function1<TSource,TKey> outerKeySelector, Function1<TInner,TKey> innerKeySelector, Function2<TSource,Enumerable<TInner>,TResult> resultSelector, EqualityComparer<TKey> comparer)`	Correlates the elements of two sequences based on key equality and groups the results.
`<TInner,TKey,TResult> Queryable<TResult>`	ExtendedQueryable.`groupJoin(Enumerable<TInner> inner, FunctionExpression<Function1<TSource,TKey>> outerKeySelector, FunctionExpression<Function1<TInner,TKey>> innerKeySelector, FunctionExpression<Function2<TSource,Enumerable<TInner>,TResult>> resultSelector)`	Correlates the elements of two sequences based on key equality and groups the results.
`<TInner,TKey,TResult> Queryable<TResult>`	ExtendedQueryable.`groupJoin(Enumerable<TInner> inner, FunctionExpression<Function1<TSource,TKey>> outerKeySelector, FunctionExpression<Function1<TInner,TKey>> innerKeySelector, FunctionExpression<Function2<TSource,Enumerable<TInner>,TResult>> resultSelector, EqualityComparer<TKey> comparer)`	Correlates the elements of two sequences based on key equality and groups the results.
`static <TOuter,TInner,TKey,TResult> Queryable<TResult>`	QueryableDefaults.`groupJoin(Queryable<TOuter> outer, Enumerable<TInner> inner, FunctionExpression<Function1<TOuter,TKey>> outerKeySelector, FunctionExpression<Function1<TInner,TKey>> innerKeySelector, FunctionExpression<Function2<TOuter,Enumerable<TInner>,TResult>> resultSelector)`	Correlates the elements of two sequences based on key equality and groups the results.
`static <TOuter,TInner,TKey,TResult> Enumerable<TResult>`	QueryableDefaults.`groupJoin(Queryable<TOuter> outer, Enumerable<TInner> inner, FunctionExpression<Function1<TOuter,TKey>> outerKeySelector, FunctionExpression<Function1<TInner,TKey>> innerKeySelector, FunctionExpression<Function2<TOuter,Enumerable<TInner>,TResult>> resultSelector, EqualityComparer<TKey> comparer)`	Correlates the elements of two sequences based on key equality and groups the results.
`<TInner,TKey,TResult> Queryable<TResult>`	QueryableFactory.`groupJoin(Queryable<T> source, Enumerable<TInner> inner, FunctionExpression<Function1<T,TKey>> outerKeySelector, FunctionExpression<Function1<TInner,TKey>> innerKeySelector, FunctionExpression<Function2<T,Enumerable<TInner>,TResult>> resultSelector)`	Correlates the elements of two sequences based on key equality and groups the results.
`<TInner,TKey,TResult> Queryable<TResult>`	QueryableFactory.`groupJoin(Queryable<T> source, Enumerable<TInner> inner, FunctionExpression<Function1<T,TKey>> outerKeySelector, FunctionExpression<Function1<TInner,TKey>> innerKeySelector, FunctionExpression<Function2<T,Enumerable<TInner>,TResult>> resultSelector, EqualityComparer<TKey> comparer)`	Correlates the elements of two sequences based on key equality and groups the results.
`<TInner,TKey,TResult> Queryable<TResult>`	QueryableRecorder.`groupJoin(Queryable<T> source, Enumerable<TInner> inner, FunctionExpression<Function1<T,TKey>> outerKeySelector, FunctionExpression<Function1<TInner,TKey>> innerKeySelector, FunctionExpression<Function2<T,Enumerable<TInner>,TResult>> resultSelector)`
`<TInner,TKey,TResult> Queryable<TResult>`	QueryableRecorder.`groupJoin(Queryable<T> source, Enumerable<TInner> inner, FunctionExpression<Function1<T,TKey>> outerKeySelector, FunctionExpression<Function1<TInner,TKey>> innerKeySelector, FunctionExpression<Function2<T,Enumerable<TInner>,TResult>> resultSelector, EqualityComparer<TKey> comparer)`
`Enumerable<T>`	DefaultEnumerable.`intersect(Enumerable<T> enumerable1)`
`Enumerable<T>`	DefaultEnumerable.`intersect(Enumerable<T> enumerable1, EqualityComparer<T> comparer)`
`Queryable<T>`	DefaultQueryable.`intersect(Enumerable<T> source1)`
`Queryable<T>`	DefaultQueryable.`intersect(Enumerable<T> source1, EqualityComparer<T> comparer)`
`static <TSource> Enumerable<TSource>`	EnumerableDefaults.`intersect(Enumerable<TSource> source0, Enumerable<TSource> source1)`	Produces the set intersection of two sequences by using the default equality comparer to compare values.
`static <TSource> Enumerable<TSource>`	EnumerableDefaults.`intersect(Enumerable<TSource> source0, Enumerable<TSource> source1, EqualityComparer<TSource> comparer)`	Produces the set intersection of two sequences by using the specified `EqualityComparer<TSource>` to compare values.
`Queryable<T>`	EnumerableQueryable.`intersect(Enumerable<T> source1)`
`Queryable<T>`	EnumerableQueryable.`intersect(Enumerable<T> source1, EqualityComparer<T> comparer)`
`Enumerable<TSource>`	ExtendedEnumerable.`intersect(Enumerable<TSource> enumerable1)`	Produces the set intersection of two sequences by using the default equality comparer to compare values.
`Enumerable<TSource>`	ExtendedEnumerable.`intersect(Enumerable<TSource> enumerable1, EqualityComparer<TSource> comparer)`	Produces the set intersection of two sequences by using the specified `EqualityComparer<TSource>` to compare values.
`Queryable<TSource>`	ExtendedQueryable.`intersect(Enumerable<TSource> enumerable)`	Produces the set intersection of two sequences by using the default equality comparer to compare values.
`Queryable<TSource>`	ExtendedQueryable.`intersect(Enumerable<TSource> enumerable, EqualityComparer<TSource> comparer)`	Produces the set intersection of two sequences by using the specified `EqualityComparer<TSource>` to compare values.
`static <T> Queryable<T>`	QueryableDefaults.`intersect(Queryable<T> queryable, Enumerable<T> enumerable)`	Produces the set intersection of two sequences by using the default equality comparer to compare values.
`static <T> Queryable<T>`	QueryableDefaults.`intersect(Queryable<T> queryable, Enumerable<T> enumerable, EqualityComparer<T> comparer)`	Produces the set intersection of two sequences by using the specified `EqualityComparer<T>` to compare values.
`Queryable<T>`	QueryableFactory.`intersect(Queryable<T> source, Enumerable<T> enumerable)`	Produces the set intersection of two sequences by using the default equality comparer to compare values.
`Queryable<T>`	QueryableFactory.`intersect(Queryable<T> source, Enumerable<T> enumerable, EqualityComparer<T> comparer)`	Produces the set intersection of two sequences by using the specified EqualityComparer to compare values.
`Queryable<T>`	QueryableRecorder.`intersect(Queryable<T> source, Enumerable<T> enumerable)`
`Queryable<T>`	QueryableRecorder.`intersect(Queryable<T> source, Enumerable<T> enumerable, EqualityComparer<T> comparer)`
`static <T,C extends Collection<? super T>> C`	EnumerableDefaults.`into(Enumerable<T> source, C sink)`	Default implementation of `ExtendedEnumerable.into(Collection)`.
`<TInner,TKey,TResult> Enumerable<TResult>`	DefaultEnumerable.`join(Enumerable<TInner> inner, Function1<T,TKey> outerKeySelector, Function1<TInner,TKey> innerKeySelector, Function2<T,TInner,TResult> resultSelector)`
`<TInner,TKey,TResult> Enumerable<TResult>`	DefaultEnumerable.`join(Enumerable<TInner> inner, Function1<T,TKey> outerKeySelector, Function1<TInner,TKey> innerKeySelector, Function2<T,TInner,TResult> resultSelector, EqualityComparer<TKey> comparer)`
`<TInner,TKey,TResult> Enumerable<TResult>`	DefaultEnumerable.`join(Enumerable<TInner> inner, Function1<T,TKey> outerKeySelector, Function1<TInner,TKey> innerKeySelector, Function2<T,TInner,TResult> resultSelector, EqualityComparer<TKey> comparer, boolean generateNullsOnLeft, boolean generateNullsOnRight)`
`<TInner,TKey,TResult> Queryable<TResult>`	DefaultQueryable.`join(Enumerable<TInner> inner, FunctionExpression<Function1<T,TKey>> outerKeySelector, FunctionExpression<Function1<TInner,TKey>> innerKeySelector, FunctionExpression<Function2<T,TInner,TResult>> resultSelector)`
`<TInner,TKey,TResult> Queryable<TResult>`	DefaultQueryable.`join(Enumerable<TInner> inner, FunctionExpression<Function1<T,TKey>> outerKeySelector, FunctionExpression<Function1<TInner,TKey>> innerKeySelector, FunctionExpression<Function2<T,TInner,TResult>> resultSelector, EqualityComparer<TKey> comparer)`
`static <TSource,TInner,TKey,TResult> Enumerable<TResult>`	EnumerableDefaults.`join(Enumerable<TSource> outer, Enumerable<TInner> inner, Function1<TSource,TKey> outerKeySelector, Function1<TInner,TKey> innerKeySelector, Function2<TSource,TInner,TResult> resultSelector)`	Correlates the elements of two sequences based on matching keys.
`static <TSource,TInner,TKey,TResult> Enumerable<TResult>`	EnumerableDefaults.`join(Enumerable<TSource> outer, Enumerable<TInner> inner, Function1<TSource,TKey> outerKeySelector, Function1<TInner,TKey> innerKeySelector, Function2<TSource,TInner,TResult> resultSelector, EqualityComparer<TKey> comparer)`	Correlates the elements of two sequences based on matching keys.
`static <TSource,TInner,TKey,TResult> Enumerable<TResult>`	EnumerableDefaults.`join(Enumerable<TSource> outer, Enumerable<TInner> inner, Function1<TSource,TKey> outerKeySelector, Function1<TInner,TKey> innerKeySelector, Function2<TSource,TInner,TResult> resultSelector, EqualityComparer<TKey> comparer, boolean generateNullsOnLeft, boolean generateNullsOnRight)`	Correlates the elements of two sequences based on matching keys.
`<TInner,TKey,TResult> Queryable<TResult>`	EnumerableQueryable.`join(Enumerable<TInner> inner, FunctionExpression<Function1<T,TKey>> outerKeySelector, FunctionExpression<Function1<TInner,TKey>> innerKeySelector, FunctionExpression<Function2<T,TInner,TResult>> resultSelector)`
`<TInner,TKey,TResult> Queryable<TResult>`	EnumerableQueryable.`join(Enumerable<TInner> inner, FunctionExpression<Function1<T,TKey>> outerKeySelector, FunctionExpression<Function1<TInner,TKey>> innerKeySelector, FunctionExpression<Function2<T,TInner,TResult>> resultSelector, EqualityComparer<TKey> comparer)`
`<TInner,TKey,TResult> Enumerable<TResult>`	ExtendedEnumerable.`join(Enumerable<TInner> inner, Function1<TSource,TKey> outerKeySelector, Function1<TInner,TKey> innerKeySelector, Function2<TSource,TInner,TResult> resultSelector)`	Correlates the elements of two sequences based on matching keys.
`<TInner,TKey,TResult> Enumerable<TResult>`	ExtendedEnumerable.`join(Enumerable<TInner> inner, Function1<TSource,TKey> outerKeySelector, Function1<TInner,TKey> innerKeySelector, Function2<TSource,TInner,TResult> resultSelector, EqualityComparer<TKey> comparer)`	Correlates the elements of two sequences based on matching keys.
`<TInner,TKey,TResult> Enumerable<TResult>`	ExtendedEnumerable.`join(Enumerable<TInner> inner, Function1<TSource,TKey> outerKeySelector, Function1<TInner,TKey> innerKeySelector, Function2<TSource,TInner,TResult> resultSelector, EqualityComparer<TKey> comparer, boolean generateNullsOnLeft, boolean generateNullsOnRight)`	Correlates the elements of two sequences based on matching keys, with optional outer join semantics.
`<TInner,TKey,TResult> Queryable<TResult>`	ExtendedQueryable.`join(Enumerable<TInner> inner, FunctionExpression<Function1<TSource,TKey>> outerKeySelector, FunctionExpression<Function1<TInner,TKey>> innerKeySelector, FunctionExpression<Function2<TSource,TInner,TResult>> resultSelector)`	Correlates the elements of two sequences based on matching keys.
`<TInner,TKey,TResult> Queryable<TResult>`	ExtendedQueryable.`join(Enumerable<TInner> inner, FunctionExpression<Function1<TSource,TKey>> outerKeySelector, FunctionExpression<Function1<TInner,TKey>> innerKeySelector, FunctionExpression<Function2<TSource,TInner,TResult>> resultSelector, EqualityComparer<TKey> comparer)`	Correlates the elements of two sequences based on matching keys.
`static <TOuter,TInner,TKey,TResult> Queryable<TResult>`	QueryableDefaults.`join(Queryable<TOuter> outer, Enumerable<TInner> inner, FunctionExpression<Function1<TOuter,TKey>> outerKeySelector, FunctionExpression<Function1<TInner,TKey>> innerKeySelector, FunctionExpression<Function2<TOuter,TInner,TResult>> resultSelector)`	Correlates the elements of two sequences based on matching keys.
`static <TOuter,TInner,TKey,TResult> Queryable<TResult>`	QueryableDefaults.`join(Queryable<TOuter> outer, Enumerable<TInner> inner, FunctionExpression<Function1<TOuter,TKey>> outerKeySelector, FunctionExpression<Function1<TInner,TKey>> innerKeySelector, FunctionExpression<Function2<TOuter,TInner,TResult>> resultSelector, EqualityComparer<TKey> comparer)`	Correlates the elements of two sequences based on matching keys.
`<TInner,TKey,TResult> Queryable<TResult>`	QueryableFactory.`join(Queryable<T> source, Enumerable<TInner> inner, FunctionExpression<Function1<T,TKey>> outerKeySelector, FunctionExpression<Function1<TInner,TKey>> innerKeySelector, FunctionExpression<Function2<T,TInner,TResult>> resultSelector)`	Correlates the elements of two sequences based on matching keys.
`<TInner,TKey,TResult> Queryable<TResult>`	QueryableFactory.`join(Queryable<T> source, Enumerable<TInner> inner, FunctionExpression<Function1<T,TKey>> outerKeySelector, FunctionExpression<Function1<TInner,TKey>> innerKeySelector, FunctionExpression<Function2<T,TInner,TResult>> resultSelector, EqualityComparer<TKey> comparer)`	Correlates the elements of two sequences based on matching keys.
`<TInner,TKey,TResult> Queryable<TResult>`	QueryableRecorder.`join(Queryable<T> source, Enumerable<TInner> inner, FunctionExpression<Function1<T,TKey>> outerKeySelector, FunctionExpression<Function1<TInner,TKey>> innerKeySelector, FunctionExpression<Function2<T,TInner,TResult>> resultSelector)`
`<TInner,TKey,TResult> Queryable<TResult>`	QueryableRecorder.`join(Queryable<T> source, Enumerable<TInner> inner, FunctionExpression<Function1<T,TKey>> outerKeySelector, FunctionExpression<Function1<TInner,TKey>> innerKeySelector, FunctionExpression<Function2<T,TInner,TResult>> resultSelector, EqualityComparer<TKey> comparer)`
`private static <TSource,TInner,TKey,TResult> Enumerable<TResult>`	EnumerableDefaults.`join_(Enumerable<TSource> outer, Enumerable<TInner> inner, Function1<TSource,TKey> outerKeySelector, Function1<TInner,TKey> innerKeySelector, Function2<TSource,TInner,TResult> resultSelector, EqualityComparer<TKey> comparer, boolean generateNullsOnLeft, boolean generateNullsOnRight)`	Implementation of join that builds the right input and probes with the left.
`static <TSource> TSource`	EnumerableDefaults.`last(Enumerable<TSource> enumerable)`	Returns the last element of a sequence.
`static <TSource> TSource`	EnumerableDefaults.`last(Enumerable<TSource> enumerable, Predicate1<TSource> predicate)`	Returns the last element of a sequence that satisfies a specified condition.
`static <TSource> TSource`	EnumerableDefaults.`lastOrDefault(Enumerable<TSource> enumerable)`	Returns the last element of a sequence, or a default value if the sequence contains no elements.
`static <TSource> TSource`	EnumerableDefaults.`lastOrDefault(Enumerable<TSource> enumerable, Predicate1<TSource> predicate)`	Returns the last element of a sequence that satisfies a condition or a default value if no such element is found.
`static <TSource> long`	EnumerableDefaults.`longCount(Enumerable<TSource> source)`	Returns an long that represents the total number of elements in a sequence.
`static <TSource> long`	EnumerableDefaults.`longCount(Enumerable<TSource> enumerable, Predicate1<TSource> predicate)`	Returns an long that represents how many elements in a sequence satisfy a condition.
`static <TSource extends Comparable<TSource>> TSource`	EnumerableDefaults.`max(Enumerable<TSource> source)`	Returns the maximum value in a generic sequence.
`static <TSource> BigDecimal`	EnumerableDefaults.`max(Enumerable<TSource> source, BigDecimalFunction1<TSource> selector)`	Invokes a transform function on each element of a sequence and returns the maximum Decimal value.
`static <TSource> double`	EnumerableDefaults.`max(Enumerable<TSource> source, DoubleFunction1<TSource> selector)`	Invokes a transform function on each element of a sequence and returns the maximum Double value.
`static <TSource> float`	EnumerableDefaults.`max(Enumerable<TSource> source, FloatFunction1<TSource> selector)`	Invokes a transform function on each element of a sequence and returns the maximum Float value.
`static <TSource,TResult extends Comparable<TResult>> TResult`	EnumerableDefaults.`max(Enumerable<TSource> source, Function1<TSource,TResult> selector)`	Invokes a transform function on each element of a generic sequence and returns the maximum resulting value.
`static <TSource> int`	EnumerableDefaults.`max(Enumerable<TSource> source, IntegerFunction1<TSource> selector)`	Invokes a transform function on each element of a sequence and returns the maximum int value.
`static <TSource> long`	EnumerableDefaults.`max(Enumerable<TSource> source, LongFunction1<TSource> selector)`	Invokes a transform function on each element of a sequence and returns the maximum long value.
`static <TSource> BigDecimal`	EnumerableDefaults.`max(Enumerable<TSource> source, NullableBigDecimalFunction1<TSource> selector)`	Invokes a transform function on each element of a sequence and returns the maximum nullable Decimal value.
`static <TSource> Double`	EnumerableDefaults.`max(Enumerable<TSource> source, NullableDoubleFunction1<TSource> selector)`	Invokes a transform function on each element of a sequence and returns the maximum nullable Double value.
`static <TSource> Float`	EnumerableDefaults.`max(Enumerable<TSource> source, NullableFloatFunction1<TSource> selector)`	Invokes a transform function on each element of a sequence and returns the maximum nullable Float value.
`static <TSource> Integer`	EnumerableDefaults.`max(Enumerable<TSource> source, NullableIntegerFunction1<TSource> selector)`	Invokes a transform function on each element of a sequence and returns the maximum nullable int value.
`static <TSource> Long`	EnumerableDefaults.`max(Enumerable<TSource> source, NullableLongFunction1<TSource> selector)`	Invokes a transform function on each element of a sequence and returns the maximum nullable long value.
`static <TSource,TInner,TKey extends Comparable<TKey>,TResult> Enumerable<TResult>`	EnumerableDefaults.`mergeJoin(Enumerable<TSource> outer, Enumerable<TInner> inner, Function1<TSource,TKey> outerKeySelector, Function1<TInner,TKey> innerKeySelector, Function2<TSource,TInner,TResult> resultSelector, boolean generateNullsOnLeft, boolean generateNullsOnRight)`	Joins two inputs that are sorted on the key.
`static <TSource extends Comparable<TSource>> TSource`	EnumerableDefaults.`min(Enumerable<TSource> source)`	Returns the minimum value in a generic sequence.
`static <TSource> BigDecimal`	EnumerableDefaults.`min(Enumerable<TSource> source, BigDecimalFunction1<TSource> selector)`	Invokes a transform function on each element of a sequence and returns the minimum Decimal value.
`static <TSource> double`	EnumerableDefaults.`min(Enumerable<TSource> source, DoubleFunction1<TSource> selector)`	Invokes a transform function on each element of a sequence and returns the minimum Double value.
`static <TSource> float`	EnumerableDefaults.`min(Enumerable<TSource> source, FloatFunction1<TSource> selector)`	Invokes a transform function on each element of a sequence and returns the minimum Float value.
`static <TSource,TResult extends Comparable<TResult>> TResult`	EnumerableDefaults.`min(Enumerable<TSource> source, Function1<TSource,TResult> selector)`	Invokes a transform function on each element of a generic sequence and returns the minimum resulting value.
`static <TSource> int`	EnumerableDefaults.`min(Enumerable<TSource> source, IntegerFunction1<TSource> selector)`	Invokes a transform function on each element of a sequence and returns the minimum int value.
`static <TSource> long`	EnumerableDefaults.`min(Enumerable<TSource> source, LongFunction1<TSource> selector)`	Invokes a transform function on each element of a sequence and returns the minimum long value.
`static <TSource> BigDecimal`	EnumerableDefaults.`min(Enumerable<TSource> source, NullableBigDecimalFunction1<TSource> selector)`	Invokes a transform function on each element of a sequence and returns the minimum nullable Decimal value.
`static <TSource> Double`	EnumerableDefaults.`min(Enumerable<TSource> source, NullableDoubleFunction1<TSource> selector)`	Invokes a transform function on each element of a sequence and returns the minimum nullable Double value.
`static <TSource> Float`	EnumerableDefaults.`min(Enumerable<TSource> source, NullableFloatFunction1<TSource> selector)`	Invokes a transform function on each element of a sequence and returns the minimum nullable Float value.
`static <TSource> Integer`	EnumerableDefaults.`min(Enumerable<TSource> source, NullableIntegerFunction1<TSource> selector)`	Invokes a transform function on each element of a sequence and returns the minimum nullable int value.
`static <TSource> Long`	EnumerableDefaults.`min(Enumerable<TSource> source, NullableLongFunction1<TSource> selector)`	Invokes a transform function on each element of a sequence and returns the minimum nullable long value.
`static <TSource,TResult> Enumerable<TResult>`	EnumerableDefaults.`ofType(Enumerable<TSource> enumerable, Class<TResult> clazz)`	Filters the elements of an Enumerable based on a specified type.
`static <TSource,TKey extends Comparable> Enumerable<TSource>`	EnumerableDefaults.`orderBy(Enumerable<TSource> source, Function1<TSource,TKey> keySelector)`	Sorts the elements of a sequence in ascending order according to a key.
`static <TSource,TKey> Enumerable<TSource>`	EnumerableDefaults.`orderBy(Enumerable<TSource> source, Function1<TSource,TKey> keySelector, Comparator<TKey> comparator)`	Sorts the elements of a sequence in ascending order by using a specified comparer.
`static <TSource,TKey extends Comparable> Enumerable<TSource>`	EnumerableDefaults.`orderByDescending(Enumerable<TSource> source, Function1<TSource,TKey> keySelector)`	Sorts the elements of a sequence in descending order according to a key.
`static <TSource,TKey> Enumerable<TSource>`	EnumerableDefaults.`orderByDescending(Enumerable<TSource> source, Function1<TSource,TKey> keySelector, Comparator<TKey> comparator)`	Sorts the elements of a sequence in descending order by using a specified comparer.
`Enumerable<V>`	LookupImpl.`put(K key, Enumerable<V> value)`
`static <T,C extends Collection<? super T>> C`	EnumerableDefaults.`remove(Enumerable<T> source, C sink)`	Default implementation of `ExtendedEnumerable.removeAll(Collection)`.
`static <TSource> Enumerable<TSource>`	EnumerableDefaults.`reverse(Enumerable<TSource> source)`	Inverts the order of the elements in a sequence.
`static <TSource,TResult> Enumerable<TResult>`	EnumerableDefaults.`select(Enumerable<TSource> source, Function1<TSource,TResult> selector)`	Projects each element of a sequence into a new form.
`static <TSource,TResult> Enumerable<TResult>`	EnumerableDefaults.`select(Enumerable<TSource> source, Function2<TSource,Integer,TResult> selector)`	Projects each element of a sequence into a new form by incorporating the element's index.
`static <TSource,TCollection,TResult> Enumerable<TResult>`	EnumerableDefaults.`selectMany(Enumerable<TSource> source, Function1<TSource,Enumerable<TCollection>> collectionSelector, Function2<TSource,TCollection,TResult> resultSelector)`	Projects each element of a sequence to an `Enumerable<TSource>`, flattens the resulting sequences into one sequence, and invokes a result selector function on each element therein.
`static <TSource,TResult> Enumerable<TResult>`	EnumerableDefaults.`selectMany(Enumerable<TSource> source, Function1<TSource,Enumerable<TResult>> selector)`	Projects each element of a sequence to an `Enumerable<TSource>` and flattens the resulting sequences into one sequence.
`static <TSource,TCollection,TResult> Enumerable<TResult>`	EnumerableDefaults.`selectMany(Enumerable<TSource> source, Function2<TSource,Integer,Enumerable<TCollection>> collectionSelector, Function2<TSource,TCollection,TResult> resultSelector)`	Projects each element of a sequence to an `Enumerable<TSource>`, flattens the resulting sequences into one sequence, and invokes a result selector function on each element therein.
`static <TSource,TResult> Enumerable<TResult>`	EnumerableDefaults.`selectMany(Enumerable<TSource> source, Function2<TSource,Integer,Enumerable<TResult>> selector)`	Projects each element of a sequence to an `Enumerable<TSource>`, and flattens the resulting sequences into one sequence.
`static <TSource,TInner,TKey> Enumerable<TSource>`	EnumerableDefaults.`semiJoin(Enumerable<TSource> outer, Enumerable<TInner> inner, Function1<TSource,TKey> outerKeySelector, Function1<TInner,TKey> innerKeySelector)`	Returns elements of `outer` for which there is a member of `inner` with a matching key.
`static <TSource,TInner,TKey> Enumerable<TSource>`	EnumerableDefaults.`semiJoin(Enumerable<TSource> outer, Enumerable<TInner> inner, Function1<TSource,TKey> outerKeySelector, Function1<TInner,TKey> innerKeySelector, EqualityComparer<TKey> comparer)`	Returns elements of `outer` for which there is a member of `inner` with a matching key.
`boolean`	DefaultEnumerable.`sequenceEqual(Enumerable<T> enumerable1)`
`boolean`	DefaultEnumerable.`sequenceEqual(Enumerable<T> enumerable1, EqualityComparer<T> comparer)`
`static <TSource> boolean`	EnumerableDefaults.`sequenceEqual(Enumerable<TSource> first, Enumerable<TSource> second)`	Determines whether two sequences are equal by comparing the elements by using the default equality comparer for their type.
`static <TSource> boolean`	EnumerableDefaults.`sequenceEqual(Enumerable<TSource> first, Enumerable<TSource> second, EqualityComparer<TSource> comparer)`	Determines whether two sequences are equal by comparing their elements by using a specified `EqualityComparer<TSource>`.
`boolean`	ExtendedEnumerable.`sequenceEqual(Enumerable<TSource> enumerable1)`	Determines whether two sequences are equal by comparing the elements by using the default equality comparer for their type.
`boolean`	ExtendedEnumerable.`sequenceEqual(Enumerable<TSource> enumerable1, EqualityComparer<TSource> comparer)`	Determines whether two sequences are equal by comparing their elements by using a specified `EqualityComparer<TSource>`.
`static <T> boolean`	QueryableDefaults.`sequenceEqual(Queryable<T> queryable, Enumerable<T> enumerable)`	Determines whether two sequences are equal by using the default equality comparer to compare elements.
`static <T> boolean`	QueryableDefaults.`sequenceEqual(Queryable<T> queryable, Enumerable<T> enumerable, EqualityComparer<T> comparer)`	Determines whether two sequences are equal by using a specified `EqualityComparer<T>` to compare elements.
`boolean`	QueryableFactory.`sequenceEqual(Queryable<T> source, Enumerable<T> enumerable)`	Determines whether two sequences are equal by using the default equality comparer to compare elements.
`boolean`	QueryableFactory.`sequenceEqual(Queryable<T> source, Enumerable<T> enumerable, EqualityComparer<T> comparer)`	Determines whether two sequences are equal by using a specified EqualityComparer to compare elements.
`boolean`	QueryableRecorder.`sequenceEqual(Queryable<T> source, Enumerable<T> enumerable)`
`boolean`	QueryableRecorder.`sequenceEqual(Queryable<T> source, Enumerable<T> enumerable, EqualityComparer<T> comparer)`
`Enumerable<V>`	GroupingImpl.`setValue(Enumerable<V> value)`
`static <TSource> TSource`	EnumerableDefaults.`single(Enumerable<TSource> source)`	Returns the only element of a sequence, and throws an exception if there is not exactly one element in the sequence.
`static <TSource> TSource`	EnumerableDefaults.`single(Enumerable<TSource> source, Predicate1<TSource> predicate)`	Returns the only element of a sequence that satisfies a specified condition, and throws an exception if more than one such element exists.
`static <TSource> TSource`	EnumerableDefaults.`singleOrDefault(Enumerable<TSource> source)`	Returns the only element of a sequence, or a default value if the sequence is empty; this method throws an exception if there is more than one element in the sequence.
`static <TSource> TSource`	EnumerableDefaults.`singleOrDefault(Enumerable<TSource> source, Predicate1<TSource> predicate)`	Returns the only element of a sequence that satisfies a specified condition or a default value if no such element exists; this method throws an exception if more than one element satisfies the condition.
`static <TSource> Enumerable<TSource>`	EnumerableDefaults.`skip(Enumerable<TSource> source, int count)`	Bypasses a specified number of elements in a sequence and then returns the remaining elements.
`static <TSource> Enumerable<TSource>`	EnumerableDefaults.`skipWhile(Enumerable<TSource> source, Predicate1<TSource> predicate)`	Bypasses elements in a sequence as long as a specified condition is true and then returns the remaining elements.
`static <TSource> Enumerable<TSource>`	EnumerableDefaults.`skipWhile(Enumerable<TSource> source, Predicate2<TSource,Integer> predicate)`	Bypasses elements in a sequence as long as a specified condition is true and then returns the remaining elements.
`static <TSource> BigDecimal`	EnumerableDefaults.`sum(Enumerable<TSource> source, BigDecimalFunction1<TSource> selector)`	Computes the sum of the sequence of Decimal values that are obtained by invoking a transform function on each element of the input sequence.
`static <TSource> double`	EnumerableDefaults.`sum(Enumerable<TSource> source, DoubleFunction1<TSource> selector)`	Computes the sum of the sequence of Double values that are obtained by invoking a transform function on each element of the input sequence.
`static <TSource> float`	EnumerableDefaults.`sum(Enumerable<TSource> source, FloatFunction1<TSource> selector)`	Computes the sum of the sequence of Float values that are obtained by invoking a transform function on each element of the input sequence.
`static <TSource> int`	EnumerableDefaults.`sum(Enumerable<TSource> source, IntegerFunction1<TSource> selector)`	Computes the sum of the sequence of int values that are obtained by invoking a transform function on each element of the input sequence.
`static <TSource> long`	EnumerableDefaults.`sum(Enumerable<TSource> source, LongFunction1<TSource> selector)`	Computes the sum of the sequence of long values that are obtained by invoking a transform function on each element of the input sequence.
`static <TSource> BigDecimal`	EnumerableDefaults.`sum(Enumerable<TSource> source, NullableBigDecimalFunction1<TSource> selector)`	Computes the sum of the sequence of nullable Decimal values that are obtained by invoking a transform function on each element of the input sequence.
`static <TSource> Double`	EnumerableDefaults.`sum(Enumerable<TSource> source, NullableDoubleFunction1<TSource> selector)`	Computes the sum of the sequence of nullable Double values that are obtained by invoking a transform function on each element of the input sequence.
`static <TSource> Float`	EnumerableDefaults.`sum(Enumerable<TSource> source, NullableFloatFunction1<TSource> selector)`	Computes the sum of the sequence of nullable Float values that are obtained by invoking a transform function on each element of the input sequence.
`static <TSource> Integer`	EnumerableDefaults.`sum(Enumerable<TSource> source, NullableIntegerFunction1<TSource> selector)`	Computes the sum of the sequence of nullable int values that are obtained by invoking a transform function on each element of the input sequence.
`static <TSource> Long`	EnumerableDefaults.`sum(Enumerable<TSource> source, NullableLongFunction1<TSource> selector)`	Computes the sum of the sequence of nullable long values that are obtained by invoking a transform function on each element of the input sequence.
`static <TSource> Enumerable<TSource>`	EnumerableDefaults.`take(Enumerable<TSource> source, int count)`	Returns a specified number of contiguous elements from the start of a sequence.
`static <TSource> Enumerable<TSource>`	EnumerableDefaults.`take(Enumerable<TSource> source, long count)`	Returns a specified number of contiguous elements from the start of a sequence.
`static <TSource> Enumerable<TSource>`	EnumerableDefaults.`takeWhile(Enumerable<TSource> source, Predicate1<TSource> predicate)`	Returns elements from a sequence as long as a specified condition is true.
`static <TSource> Enumerable<TSource>`	EnumerableDefaults.`takeWhile(Enumerable<TSource> source, Predicate2<TSource,Integer> predicate)`	Returns elements from a sequence as long as a specified condition is true.
`static <TSource> Enumerable<TSource>`	EnumerableDefaults.`takeWhileLong(Enumerable<TSource> source, Predicate2<TSource,Long> predicate)`	Returns elements from a sequence as long as a specified condition is true.
`static <TSource,TInner,TResult> Enumerable<TResult>`	EnumerableDefaults.`thetaJoin(Enumerable<TSource> outer, Enumerable<TInner> inner, Predicate2<TSource,TInner> predicate, Function2<TSource,TInner,TResult> resultSelector, boolean generateNullsOnLeft, boolean generateNullsOnRight)`	Correlates the elements of two sequences based on a predicate.
`static <TSource> List<TSource>`	EnumerableDefaults.`toList(Enumerable<TSource> source)`	Creates a `List<TSource>` from an `Enumerable<TSource>`.
`static <TSource,TKey> Lookup<TKey,TSource>`	EnumerableDefaults.`toLookup(Enumerable<TSource> source, Function1<TSource,TKey> keySelector)`	Creates a Lookup<TKey, TElement> from an Enumerable<TSource> according to a specified key selector function.
`static <TSource,TKey> Lookup<TKey,TSource>`	EnumerableDefaults.`toLookup(Enumerable<TSource> source, Function1<TSource,TKey> keySelector, EqualityComparer<TKey> comparer)`	Creates a `Lookup<TKey, TElement>` from an `Enumerable<TSource>` according to a specified key selector function and key comparer.
`static <TSource,TKey,TElement> Lookup<TKey,TElement>`	EnumerableDefaults.`toLookup(Enumerable<TSource> source, Function1<TSource,TKey> keySelector, Function1<TSource,TElement> elementSelector)`	Creates a `Lookup<TKey, TElement>` from an `Enumerable<TSource>` according to specified key selector and element selector functions.
`static <TSource,TKey,TElement> Lookup<TKey,TElement>`	EnumerableDefaults.`toLookup(Enumerable<TSource> source, Function1<TSource,TKey> keySelector, Function1<TSource,TElement> elementSelector, EqualityComparer<TKey> comparer)`	Creates a `Lookup<TKey, TElement>` from an `Enumerable<TSource>` according to a specified key selector function, a comparer and an element selector function.
`(package private) static <TSource,TKey,TElement> LookupImpl<TKey,TElement>`	EnumerableDefaults.`toLookup_(Map<TKey,List<TElement>> map, Enumerable<TSource> source, Function1<TSource,TKey> keySelector, Function1<TSource,TElement> elementSelector)`
`static <TSource,TKey> Map<TKey,TSource>`	EnumerableDefaults.`toMap(Enumerable<TSource> source, Function1<TSource,TKey> keySelector)`	Creates a Map<TKey, TValue> from an Enumerable<TSource> according to a specified key selector function.
`static <TSource,TKey> Map<TKey,TSource>`	EnumerableDefaults.`toMap(Enumerable<TSource> source, Function1<TSource,TKey> keySelector, EqualityComparer<TKey> comparer)`	Creates a `Map<TKey, TValue>` from an `Enumerable<TSource>` according to a specified key selector function and key comparer.
`static <TSource,TKey,TElement> Map<TKey,TElement>`	EnumerableDefaults.`toMap(Enumerable<TSource> source, Function1<TSource,TKey> keySelector, Function1<TSource,TElement> elementSelector)`	Creates a `Map<TKey, TValue>` from an `Enumerable<TSource>` according to specified key selector and element selector functions.
`static <TSource,TKey,TElement> Map<TKey,TElement>`	EnumerableDefaults.`toMap(Enumerable<TSource> source, Function1<TSource,TKey> keySelector, Function1<TSource,TElement> elementSelector, EqualityComparer<TKey> comparer)`	Creates a `Map<TKey, TValue>` from an `Enumerable<TSource>` according to a specified key selector function, a comparer, and an element selector function.
`Enumerable<T>`	DefaultEnumerable.`union(Enumerable<T> source1)`
`Enumerable<T>`	DefaultEnumerable.`union(Enumerable<T> source1, EqualityComparer<T> comparer)`
`Queryable<T>`	DefaultQueryable.`union(Enumerable<T> source1)`
`Queryable<T>`	DefaultQueryable.`union(Enumerable<T> source1, EqualityComparer<T> comparer)`
`static <TSource> Enumerable<TSource>`	EnumerableDefaults.`union(Enumerable<TSource> source0, Enumerable<TSource> source1)`	Produces the set union of two sequences by using the default equality comparer.
`static <TSource> Enumerable<TSource>`	EnumerableDefaults.`union(Enumerable<TSource> source0, Enumerable<TSource> source1, EqualityComparer<TSource> comparer)`	Produces the set union of two sequences by using a specified EqualityComparer<TSource>.
`Queryable<T>`	EnumerableQueryable.`union(Enumerable<T> source1)`
`Queryable<T>`	EnumerableQueryable.`union(Enumerable<T> source1, EqualityComparer<T> comparer)`
`Enumerable<TSource>`	ExtendedEnumerable.`union(Enumerable<TSource> source1)`	Produces the set union of two sequences by using the default equality comparer.
`Enumerable<TSource>`	ExtendedEnumerable.`union(Enumerable<TSource> source1, EqualityComparer<TSource> comparer)`	Produces the set union of two sequences by using a specified `EqualityComparer<TSource>`.
`Queryable<TSource>`	ExtendedQueryable.`union(Enumerable<TSource> source1)`	Produces the set union of two sequences by using the default equality comparer.
`Queryable<TSource>`	ExtendedQueryable.`union(Enumerable<TSource> source1, EqualityComparer<TSource> comparer)`	Produces the set union of two sequences by using a specified `EqualityComparer<TSource>`.
`static <T> Queryable<T>`	QueryableDefaults.`union(Queryable<T> source0, Enumerable<T> source1)`	Produces the set union of two sequences by using the default equality comparer.
`static <T> Queryable<T>`	QueryableDefaults.`union(Queryable<T> source0, Enumerable<T> source1, EqualityComparer<T> comparer)`	Produces the set union of two sequences by using a specified `EqualityComparer<T>`.
`Queryable<T>`	QueryableFactory.`union(Queryable<T> source, Enumerable<T> source1)`	Produces the set union of two sequences by using the default equality comparer.
`Queryable<T>`	QueryableFactory.`union(Queryable<T> source, Enumerable<T> source1, EqualityComparer<T> comparer)`	Produces the set union of two sequences by using a specified `EqualityComparer<T>`.
`Queryable<T>`	QueryableRecorder.`union(Queryable<T> source, Enumerable<T> source1)`
`Queryable<T>`	QueryableRecorder.`union(Queryable<T> source, Enumerable<T> source1, EqualityComparer<T> comparer)`
`static <TSource> Enumerable<TSource>`	EnumerableDefaults.`where(Enumerable<TSource> source, Predicate1<TSource> predicate)`	Filters a sequence of values based on a predicate.
`static <TSource> Enumerable<TSource>`	EnumerableDefaults.`where(Enumerable<TSource> source, Predicate2<TSource,Integer> predicate)`	Filters a sequence of values based on a predicate.
`<T1,TResult> Enumerable<TResult>`	DefaultEnumerable.`zip(Enumerable<T1> source1, Function2<T,T1,TResult> resultSelector)`
`<T1,TResult> Queryable<TResult>`	DefaultQueryable.`zip(Enumerable<T1> source1, FunctionExpression<Function2<T,T1,TResult>> resultSelector)`
`static <T0,T1,TResult> Enumerable<TResult>`	EnumerableDefaults.`zip(Enumerable<T0> first, Enumerable<T1> second, Function2<T0,T1,TResult> resultSelector)`	Applies a specified function to the corresponding elements of two sequences, producing a sequence of the results.
`<T1,TResult> Queryable<TResult>`	EnumerableQueryable.`zip(Enumerable<T1> source1, FunctionExpression<Function2<T,T1,TResult>> resultSelector)`
`<T1,TResult> Enumerable<TResult>`	ExtendedEnumerable.`zip(Enumerable<T1> source1, Function2<TSource,T1,TResult> resultSelector)`	Applies a specified function to the corresponding elements of two sequences, producing a sequence of the results.
`<T1,TResult> Queryable<TResult>`	ExtendedQueryable.`zip(Enumerable<T1> source1, FunctionExpression<Function2<TSource,T1,TResult>> resultSelector)`	Merges two sequences by using the specified predicate function.
`static <T0,T1,TResult> Queryable<TResult>`	QueryableDefaults.`zip(Queryable<T0> source0, Enumerable<T1> source1, FunctionExpression<Function2<T0,T1,TResult>> resultSelector)`	Merges two sequences by using the specified predicate function.
`<T1,TResult> Queryable<TResult>`	QueryableFactory.`zip(Queryable<T> source, Enumerable<T1> source1, FunctionExpression<Function2<T,T1,TResult>> resultSelector)`	Merges two sequences by using the specified predicate function.
`<T1,TResult> Queryable<TResult>`	QueryableRecorder.`zip(Queryable<T> source, Enumerable<T1> source1, FunctionExpression<Function2<T,T1,TResult>> resultSelector)`

Method parameters in org.apache.calcite.linq4j with type arguments of type Enumerable
Modifier and Type	Method	Description
`<TResult> Enumerable<TResult>`	Lookup.`applyResultSelector(Function2<K,Enumerable<V>,TResult> resultSelector)`	Applies a transform function to each key and its associated values and returns the results.
`<TResult> Enumerable<TResult>`	LookupImpl.`applyResultSelector(Function2<K,Enumerable<V>,TResult> resultSelector)`
`static <E> Enumerable<E>`	Linq4j.`concat(List<Enumerable<E>> enumerableList)`	Concatenates two or more `Enumerable`s to form a composite enumerable that contains the union of their elements.
`<TInner,TResult> Enumerable<TResult>`	DefaultEnumerable.`correlateJoin(CorrelateJoinType joinType, Function1<T,Enumerable<TInner>> inner, Function2<T,TInner,TResult> resultSelector)`
`static <TSource,TInner,TResult> Enumerable<TResult>`	EnumerableDefaults.`correlateJoin(CorrelateJoinType joinType, Enumerable<TSource> outer, Function1<TSource,Enumerable<TInner>> inner, Function2<TSource,TInner,TResult> resultSelector)`	Returns elements of `outer` for which there is a member of `inner` with a matching key.
`<TInner,TResult> Enumerable<TResult>`	ExtendedEnumerable.`correlateJoin(CorrelateJoinType joinType, Function1<TSource,Enumerable<TInner>> inner, Function2<TSource,TInner,TResult> resultSelector)`	For each row of the current enumerable returns the correlated rows from the `inner` enumerable (nested loops join).
`<TKey,TElement,TResult> Enumerable<TResult>`	DefaultEnumerable.`groupBy(Function1<T,TKey> keySelector, Function1<T,TElement> elementSelector, Function2<TKey,Enumerable<TElement>,TResult> resultSelector)`
`<TKey,TElement,TResult> Enumerable<TResult>`	DefaultEnumerable.`groupBy(Function1<T,TKey> keySelector, Function1<T,TElement> elementSelector, Function2<TKey,Enumerable<TElement>,TResult> resultSelector, EqualityComparer<TKey> comparer)`
`<TKey,TResult> Enumerable<TResult>`	DefaultEnumerable.`groupBy(Function1<T,TKey> keySelector, Function2<TKey,Enumerable<T>,TResult> resultSelector)`
`<TKey,TResult> Enumerable<TResult>`	DefaultEnumerable.`groupBy(Function1<T,TKey> keySelector, Function2<TKey,Enumerable<T>,TResult> elementSelector, EqualityComparer<TKey> comparer)`
`static <TSource,TKey,TElement,TResult> Enumerable<TResult>`	EnumerableDefaults.`groupBy(Enumerable<TSource> enumerable, Function1<TSource,TKey> keySelector, Function1<TSource,TElement> elementSelector, Function2<TKey,Enumerable<TElement>,TResult> resultSelector)`	Groups the elements of a sequence according to a specified key selector function and creates a result value from each group and its key.
`static <TSource,TKey,TElement,TResult> Enumerable<TResult>`	EnumerableDefaults.`groupBy(Enumerable<TSource> enumerable, Function1<TSource,TKey> keySelector, Function1<TSource,TElement> elementSelector, Function2<TKey,Enumerable<TElement>,TResult> resultSelector, EqualityComparer<TKey> comparer)`	Groups the elements of a sequence according to a specified key selector function and creates a result value from each group and its key.
`static <TSource,TKey,TResult> Enumerable<TResult>`	EnumerableDefaults.`groupBy(Enumerable<TSource> enumerable, Function1<TSource,TKey> keySelector, Function2<TKey,Enumerable<TSource>,TResult> resultSelector)`	Groups the elements of a sequence according to a specified key selector function and creates a result value from each group and its key.
`static <TSource,TKey,TResult> Enumerable<TResult>`	EnumerableDefaults.`groupBy(Enumerable<TSource> enumerable, Function1<TSource,TKey> keySelector, Function2<TKey,Enumerable<TSource>,TResult> resultSelector, EqualityComparer<TKey> comparer)`	Groups the elements of a sequence according to a specified key selector function and creates a result value from each group and its key.
`<TKey,TElement,TResult> Enumerable<TResult>`	ExtendedEnumerable.`groupBy(Function1<TSource,TKey> keySelector, Function1<TSource,TElement> elementSelector, Function2<TKey,Enumerable<TElement>,TResult> resultSelector)`	Groups the elements of a sequence according to a specified key selector function and creates a result value from each group and its key.
`<TKey,TElement,TResult> Enumerable<TResult>`	ExtendedEnumerable.`groupBy(Function1<TSource,TKey> keySelector, Function1<TSource,TElement> elementSelector, Function2<TKey,Enumerable<TElement>,TResult> resultSelector, EqualityComparer<TKey> comparer)`	Groups the elements of a sequence according to a specified key selector function and creates a result value from each group and its key.
`<TKey,TResult> Enumerable<TResult>`	ExtendedEnumerable.`groupBy(Function1<TSource,TKey> keySelector, Function2<TKey,Enumerable<TSource>,TResult> resultSelector)`	Groups the elements of a sequence according to a specified key selector function and creates a result value from each group and its key.
`<TKey,TResult> Enumerable<TResult>`	ExtendedEnumerable.`groupBy(Function1<TSource,TKey> keySelector, Function2<TKey,Enumerable<TSource>,TResult> resultSelector, EqualityComparer<TKey> comparer)`	Groups the elements of a sequence according to a specified key selector function and creates a result value from each group and its key.
`<TInner,TKey,TResult> Enumerable<TResult>`	DefaultEnumerable.`groupJoin(Enumerable<TInner> inner, Function1<T,TKey> outerKeySelector, Function1<TInner,TKey> innerKeySelector, Function2<T,Enumerable<TInner>,TResult> resultSelector)`
`<TInner,TKey,TResult> Enumerable<TResult>`	DefaultEnumerable.`groupJoin(Enumerable<TInner> inner, Function1<T,TKey> outerKeySelector, Function1<TInner,TKey> innerKeySelector, Function2<T,Enumerable<TInner>,TResult> resultSelector, EqualityComparer<TKey> comparer)`
`static <TSource,TInner,TKey,TResult> Enumerable<TResult>`	EnumerableDefaults.`groupJoin(Enumerable<TSource> outer, Enumerable<TInner> inner, Function1<TSource,TKey> outerKeySelector, Function1<TInner,TKey> innerKeySelector, Function2<TSource,Enumerable<TInner>,TResult> resultSelector)`	Correlates the elements of two sequences based on equality of keys and groups the results.
`static <TSource,TInner,TKey,TResult> Enumerable<TResult>`	EnumerableDefaults.`groupJoin(Enumerable<TSource> outer, Enumerable<TInner> inner, Function1<TSource,TKey> outerKeySelector, Function1<TInner,TKey> innerKeySelector, Function2<TSource,Enumerable<TInner>,TResult> resultSelector, EqualityComparer<TKey> comparer)`	Correlates the elements of two sequences based on key equality and groups the results.
`<TInner,TKey,TResult> Enumerable<TResult>`	ExtendedEnumerable.`groupJoin(Enumerable<TInner> inner, Function1<TSource,TKey> outerKeySelector, Function1<TInner,TKey> innerKeySelector, Function2<TSource,Enumerable<TInner>,TResult> resultSelector)`	Correlates the elements of two sequences based on equality of keys and groups the results.
`<TInner,TKey,TResult> Enumerable<TResult>`	ExtendedEnumerable.`groupJoin(Enumerable<TInner> inner, Function1<TSource,TKey> outerKeySelector, Function1<TInner,TKey> innerKeySelector, Function2<TSource,Enumerable<TInner>,TResult> resultSelector, EqualityComparer<TKey> comparer)`	Correlates the elements of two sequences based on key equality and groups the results.
`void`	LookupImpl.`putAll(Map<? extends K,? extends Enumerable<V>> m)`
`<TCollection,TResult> Enumerable<TResult>`	DefaultEnumerable.`selectMany(Function1<T,Enumerable<TCollection>> collectionSelector, Function2<T,TCollection,TResult> resultSelector)`
`<TResult> Enumerable<TResult>`	DefaultEnumerable.`selectMany(Function1<T,Enumerable<TResult>> selector)`
`<TCollection,TResult> Enumerable<TResult>`	DefaultEnumerable.`selectMany(Function2<T,Integer,Enumerable<TCollection>> collectionSelector, Function2<T,TCollection,TResult> resultSelector)`
`<TResult> Enumerable<TResult>`	DefaultEnumerable.`selectMany(Function2<T,Integer,Enumerable<TResult>> selector)`
`<TResult> Queryable<TResult>`	DefaultQueryable.`selectMany(FunctionExpression<Function1<T,Enumerable<TResult>>> selector)`
`<TCollection,TResult> Queryable<TResult>`	DefaultQueryable.`selectMany(FunctionExpression<Function2<T,Integer,Enumerable<TCollection>>> collectionSelector, FunctionExpression<Function2<T,TCollection,TResult>> resultSelector)`
`static <TSource,TCollection,TResult> Enumerable<TResult>`	EnumerableDefaults.`selectMany(Enumerable<TSource> source, Function1<TSource,Enumerable<TCollection>> collectionSelector, Function2<TSource,TCollection,TResult> resultSelector)`	Projects each element of a sequence to an `Enumerable<TSource>`, flattens the resulting sequences into one sequence, and invokes a result selector function on each element therein.
`static <TSource,TResult> Enumerable<TResult>`	EnumerableDefaults.`selectMany(Enumerable<TSource> source, Function1<TSource,Enumerable<TResult>> selector)`	Projects each element of a sequence to an `Enumerable<TSource>` and flattens the resulting sequences into one sequence.
`static <TSource,TCollection,TResult> Enumerable<TResult>`	EnumerableDefaults.`selectMany(Enumerable<TSource> source, Function2<TSource,Integer,Enumerable<TCollection>> collectionSelector, Function2<TSource,TCollection,TResult> resultSelector)`	Projects each element of a sequence to an `Enumerable<TSource>`, flattens the resulting sequences into one sequence, and invokes a result selector function on each element therein.
`static <TSource,TResult> Enumerable<TResult>`	EnumerableDefaults.`selectMany(Enumerable<TSource> source, Function2<TSource,Integer,Enumerable<TResult>> selector)`	Projects each element of a sequence to an `Enumerable<TSource>`, and flattens the resulting sequences into one sequence.
`<TResult> Queryable<TResult>`	EnumerableQueryable.`selectMany(FunctionExpression<Function1<T,Enumerable<TResult>>> selector)`
`<TCollection,TResult> Queryable<TResult>`	EnumerableQueryable.`selectMany(FunctionExpression<Function2<T,Integer,Enumerable<TCollection>>> collectionSelector, FunctionExpression<Function2<T,TCollection,TResult>> resultSelector)`
`<TCollection,TResult> Enumerable<TResult>`	ExtendedEnumerable.`selectMany(Function1<TSource,Enumerable<TCollection>> collectionSelector, Function2<TSource,TCollection,TResult> resultSelector)`	Projects each element of a sequence to an `Enumerable<TSource>`, flattens the resulting sequences into one sequence, and invokes a result selector function on each element therein.
`<TResult> Enumerable<TResult>`	ExtendedEnumerable.`selectMany(Function1<TSource,Enumerable<TResult>> selector)`	Projects each element of a sequence to an `Enumerable<TSource>` and flattens the resulting sequences into one sequence.
`<TCollection,TResult> Enumerable<TResult>`	ExtendedEnumerable.`selectMany(Function2<TSource,Integer,Enumerable<TCollection>> collectionSelector, Function2<TSource,TCollection,TResult> resultSelector)`	Projects each element of a sequence to an `Enumerable<TSource>`, flattens the resulting sequences into one sequence, and invokes a result selector function on each element therein.
`<TResult> Enumerable<TResult>`	ExtendedEnumerable.`selectMany(Function2<TSource,Integer,Enumerable<TResult>> selector)`	Projects each element of a sequence to an `Enumerable<TSource>`, and flattens the resulting sequences into one sequence.
`<TResult> Queryable<TResult>`	ExtendedQueryable.`selectMany(FunctionExpression<Function1<TSource,Enumerable<TResult>>> selector)`	Projects each element of a sequence to an `Enumerable<TSource>` and combines the resulting sequences into one sequence.
`<TCollection,TResult> Queryable<TResult>`	ExtendedQueryable.`selectMany(FunctionExpression<Function2<TSource,Integer,Enumerable<TCollection>>> collectionSelector, FunctionExpression<Function2<TSource,TCollection,TResult>> resultSelector)`	Projects each element of a sequence to an `Enumerable<TSource>` that incorporates the index of the source element that produced it.
`static <T,TResult> Queryable<TResult>`	QueryableDefaults.`selectMany(Queryable<T> source, FunctionExpression<Function1<T,Enumerable<TResult>>> selector)`	Projects each element of a sequence to an `Enumerable<T>` and combines the resulting sequences into one sequence.
`static <T,TCollection,TResult> Queryable<TResult>`	QueryableDefaults.`selectMany(Queryable<T> source, FunctionExpression<Function2<T,Integer,Enumerable<TCollection>>> collectionSelector, FunctionExpression<Function2<T,TCollection,TResult>> resultSelector)`	Projects each element of a sequence to an `Enumerable<T>` that incorporates the index of the source element that produced it.
`<TResult> Queryable<TResult>`	QueryableFactory.`selectMany(Queryable<T> source, FunctionExpression<Function1<T,Enumerable<TResult>>> selector)`	Projects each element of a sequence to an `Enumerable<T>` and combines the resulting sequences into one sequence.
`<TCollection,TResult> Queryable<TResult>`	QueryableFactory.`selectMany(Queryable<T> source, FunctionExpression<Function2<T,Integer,Enumerable<TCollection>>> collectionSelector, FunctionExpression<Function2<T,TCollection,TResult>> resultSelector)`	Projects each element of a sequence to an `Enumerable<T>` that incorporates the index of the source element that produced it.
`<TResult> Queryable<TResult>`	QueryableRecorder.`selectMany(Queryable<T> source, FunctionExpression<Function1<T,Enumerable<TResult>>> selector)`
`<TCollection,TResult> Queryable<TResult>`	QueryableRecorder.`selectMany(Queryable<T> source, FunctionExpression<Function2<T,Integer,Enumerable<TCollection>>> collectionSelector, FunctionExpression<Function2<T,TCollection,TResult>> resultSelector)`
`<TCollection,TResult> Queryable<TResult>`	DefaultQueryable.`selectManyN(FunctionExpression<Function1<T,Enumerable<TCollection>>> collectionSelector, FunctionExpression<Function2<T,TCollection,TResult>> resultSelector)`
`<TResult> Queryable<TResult>`	DefaultQueryable.`selectManyN(FunctionExpression<Function2<T,Integer,Enumerable<TResult>>> selector)`
`<TCollection,TResult> Queryable<TResult>`	EnumerableQueryable.`selectManyN(FunctionExpression<Function1<T,Enumerable<TCollection>>> collectionSelector, FunctionExpression<Function2<T,TCollection,TResult>> resultSelector)`
`<TResult> Queryable<TResult>`	EnumerableQueryable.`selectManyN(FunctionExpression<Function2<T,Integer,Enumerable<TResult>>> selector)`
`<TCollection,TResult> Queryable<TResult>`	ExtendedQueryable.`selectManyN(FunctionExpression<Function1<TSource,Enumerable<TCollection>>> collectionSelector, FunctionExpression<Function2<TSource,TCollection,TResult>> resultSelector)`	Projects each element of a sequence to an `Enumerable<TSource>` and invokes a result selector function on each element therein.
`<TResult> Queryable<TResult>`	ExtendedQueryable.`selectManyN(FunctionExpression<Function2<TSource,Integer,Enumerable<TResult>>> selector)`	Projects each element of a sequence to an `Enumerable<TSource>` and combines the resulting sequences into one sequence.
`static <T,TCollection,TResult> Queryable<TResult>`	QueryableDefaults.`selectManyN(Queryable<T> source, FunctionExpression<Function1<T,Enumerable<TCollection>>> collectionSelector, FunctionExpression<Function2<T,TCollection,TResult>> resultSelector)`	Projects each element of a sequence to an `Enumerable<T>` and invokes a result selector function on each element therein.
`static <T,TResult> Queryable<TResult>`	QueryableDefaults.`selectManyN(Queryable<T> source, FunctionExpression<Function2<T,Integer,Enumerable<TResult>>> selector)`	Projects each element of a sequence to an `Enumerable<T>` and combines the resulting sequences into one sequence.
`<TCollection,TResult> Queryable<TResult>`	QueryableFactory.`selectManyN(Queryable<T> source, FunctionExpression<Function1<T,Enumerable<TCollection>>> collectionSelector, FunctionExpression<Function2<T,TCollection,TResult>> resultSelector)`	Projects each element of a sequence to an `Enumerable<T>` and invokes a result selector function on each element therein.
`<TResult> Queryable<TResult>`	QueryableFactory.`selectManyN(Queryable<T> source, FunctionExpression<Function2<T,Integer,Enumerable<TResult>>> selector)`	Projects each element of a sequence to an `Enumerable<T>` and combines the resulting sequences into one sequence.
`<TCollection,TResult> Queryable<TResult>`	QueryableRecorder.`selectManyN(Queryable<T> source, FunctionExpression<Function1<T,Enumerable<TCollection>>> collectionSelector, FunctionExpression<Function2<T,TCollection,TResult>> resultSelector)`
`<TResult> Queryable<TResult>`	QueryableRecorder.`selectManyN(Queryable<T> source, FunctionExpression<Function2<T,Integer,Enumerable<TResult>>> selector)`

Constructors in org.apache.calcite.linq4j with parameters of type Enumerable
Constructor	Description
`EnumerableOrderedQueryable(Enumerable<T> enumerable, Class<T> rowType, QueryProvider provider, Expression expression)`
`EnumerableQueryable(QueryProvider provider, Class<T> elementType, Expression expression, Enumerable<T> enumerable)`

Constructor parameters in org.apache.calcite.linq4j with type arguments of type Enumerable
Constructor	Description
`CompositeEnumerable(List<Enumerable<E>> enumerableList)`

Uses of Interfaceorg.apache.calcite.linq4j.Enumerable

Uses of Enumerable in org.apache.calcite.linq4j

Uses of Interface
org.apache.calcite.linq4j.Enumerable