import { type default } from "https://deno.land/x/linq@4.0.0/linq.d.ts";
const { IEnumerable } = default;
Call Signatures
(getEnumerator: () => IEnumerator<T>): void
Methods
getEnumerator(): IEnumerator<T>
[[Symbol.iterator]](): Iterator<T>
traverseBreadthFirst(childrenSelector: (element: T) => IEnumerable<T>): IEnumerable<T>
traverseBreadthFirst<TResult>(childrenSelector: (element: T) => IEnumerable<T>, resultSelector: (element: T, nestLevel: number) => TResult): IEnumerable<TResult>
traverseDepthFirst<TResult>(childrenSelector: (element: T) => IEnumerable<T>, resultSelector?: (element: T, nestLevel: number) => TResult): IEnumerable<TResult>
flatten(): IEnumerable<unknown>
pairwise<TResult>(selector: (prev: T, current: T) => TResult): IEnumerable<TResult>
scan(func: (prev: T, current: T) => T): IEnumerable<T>
scan<TAccumulate>(seed: TAccumulate, func: (prev: TAccumulate, current: T) => TAccumulate): IEnumerable<TAccumulate>
select<TResult>(selector: (element: T, index: number) => TResult): IEnumerable<TResult>
selectMany<TOther>(collectionSelector: (element: T, index: number) => IEnumerable<TOther>): IEnumerable<TOther>
selectMany<TCollection, TResult>(collectionSelector: (element: T, index: number) => IEnumerable<TCollection>, resultSelector: (outer: T, inner: TCollection) => TResult): IEnumerable<TResult>
selectMany<TOther>(collectionSelector: (element: T, index: number) => TOther[]): IEnumerable<TOther>
selectMany<TCollection, TResult>(collectionSelector: (element: T, index: number) => TCollection[], resultSelector: (outer: T, inner: TCollection) => TResult): IEnumerable<TResult>
selectMany<TOther>(collectionSelector: (element: T, index: number) => { [x: number]: TOther; length: number; }): IEnumerable<TOther>
selectMany<TCollection, TResult>(collectionSelector: (element: T, index: number) => { [x: number]: TCollection; length: number; }, resultSelector: (outer: T, inner: TCollection) => TResult): IEnumerable<TResult>
where(predicate: (element: T, index: number) => boolean): IEnumerable<T>
choose(selector: (element: T, index: number) => T): IEnumerable<T>
ofType<TResult>(type: unknown): IEnumerable<TResult>
zip<U, TResult>(second: IEnumerable<U>, resultSelector: () => TResult): IEnumerable<TResult>
zip<U, TResult>(second: { [x: number]: U; length: number; }, resultSelector: () => TResult): IEnumerable<TResult>
zip<U, TResult>(second: U[], resultSelector: () => TResult): IEnumerable<TResult>
zip<TResult>(...params: unknown[]): IEnumerable<TResult>
merge(...params: (T[] | IEnumerable<T> | { [x: number]: T; length: number; })[]): IEnumerable<T>
join<TInner, TKey, TResult>(): IEnumerable<TResult>
inner: IEnumerable<TInner>,
outerKeySelector: (outer: T) => TKey,
innerKeySelector: (inner: TInner) => TKey,
resultSelector: (outer: T, inner: TInner) => TResult,
compareSelector?: (obj: T) => TKey,
join<TInner, TKey, TResult>(): IEnumerable<TResult>
inner: { [x: number]: TInner; length: number; },
outerKeySelector: (outer: T) => TKey,
innerKeySelector: (inner: TInner) => TKey,
resultSelector: (outer: T, inner: TInner) => TResult,
compareSelector?: (obj: T) => TKey,
join<TInner, TKey, TResult>(): IEnumerable<TResult>
inner: TInner[],
outerKeySelector: (outer: T) => TKey,
innerKeySelector: (inner: TInner) => TKey,
resultSelector: (outer: T, inner: TInner) => TResult,
compareSelector?: (obj: T) => TKey,
groupJoin<TInner, TKey, TResult>(): IEnumerable<TResult>
inner: IEnumerable<TInner>,
outerKeySelector: (outer: T) => TKey,
innerKeySelector: (inner: TInner) => TKey,
resultSelector: (outer: T, inner: IEnumerable<TInner>) => TResult,
compareSelector?: (obj: T) => TKey,
groupJoin<TInner, TKey, TResult>(): IEnumerable<TResult>
inner: { [x: number]: TInner; length: number; },
outerKeySelector: (outer: T) => TKey,
innerKeySelector: (inner: TInner) => TKey,
resultSelector: (outer: T, inner: IEnumerable<TInner>) => TResult,
compareSelector?: (obj: T) => TKey,
groupJoin<TInner, TKey, TResult>(): IEnumerable<TResult>
inner: TInner[],
outerKeySelector: (outer: T) => TKey,
innerKeySelector: (inner: TInner) => TKey,
resultSelector: (outer: T, inner: IEnumerable<TInner>) => TResult,
compareSelector?: (obj: T) => TKey,
all(predicate: (element: T) => boolean): boolean
any(predicate?: (element: T) => boolean): boolean
concat(...sequences: (T[] | IEnumerable<T> | { [x: number]: T; length: number; })[]): IEnumerable<T>
insert(index: number, second: IEnumerable<T>): IEnumerable<T>
insert(index: number, second: { [x: number]: T; length: number; }): IEnumerable<T>
alternate(alternateValue: T): IEnumerable<T>
alternate(alternateSequence: { [x: number]: T; length: number; }): IEnumerable<T>
alternate(alternateSequence: IEnumerable<T>): IEnumerable<T>
alternate(alternateSequence: T[]): IEnumerable<T>
contains(value: T): boolean
defaultIfEmpty(defaultValue?: T): IEnumerable<T>
distinct(): IEnumerable<T>
distinct<TCompare>(compareSelector: (element: T) => TCompare): IEnumerable<T>
distinctUntilChanged(): IEnumerable<T>
distinctUntilChanged<TCompare>(compareSelector: (element: T) => TCompare): IEnumerable<T>
except(second: { [x: number]: T; length: number; }): IEnumerable<T>
except<TCompare>(second: { [x: number]: T; length: number; }, compareSelector: (element: T) => TCompare): IEnumerable<T>
except(second: IEnumerable<T>): IEnumerable<T>
except<TCompare>(second: IEnumerable<T>, compareSelector: (element: T) => TCompare): IEnumerable<T>
except(second: T[]): IEnumerable<T>
except<TCompare>(second: T[], compareSelector: (element: T) => TCompare): IEnumerable<T>
intersect(second: { [x: number]: T; length: number; }): IEnumerable<T>
intersect<TCompare>(second: { [x: number]: T; length: number; }, compareSelector: (element: T) => TCompare): IEnumerable<T>
intersect(second: IEnumerable<T>): IEnumerable<T>
intersect<TCompare>(second: IEnumerable<T>, compareSelector: (element: T) => TCompare): IEnumerable<T>
intersect(second: T[]): IEnumerable<T>
intersect<TCompare>(second: T[], compareSelector: (element: T) => TCompare): IEnumerable<T>
union(second: { [x: number]: T; length: number; }): IEnumerable<T>
union<TCompare>(second: { [x: number]: T; length: number; }, compareSelector: (element: T) => TCompare): IEnumerable<T>
union(second: IEnumerable<T>): IEnumerable<T>
union<TCompare>(second: IEnumerable<T>, compareSelector: (element: T) => TCompare): IEnumerable<T>
union(second: T[]): IEnumerable<T>
union<TCompare>(second: T[], compareSelector: (element: T) => TCompare): IEnumerable<T>
sequenceEqual(second: { [x: number]: T; length: number; }): boolean
sequenceEqual(second: IEnumerable<T>): boolean
sequenceEqual<TCompare>(second: IEnumerable<T>, compareSelector: (element: T) => TCompare): boolean
sequenceEqual(second: T[]): boolean
orderBy<TKey>(keySelector: (element: T) => TKey): IOrderedEnumerable<T>
orderBy<TKey>(keySelector: (element: T) => TKey, comparer: (first: TKey, second: TKey) => number): IOrderedEnumerable<T>
orderByDescending<TKey>(keySelector: (element: T) => TKey): IOrderedEnumerable<T>
orderByDescending<TKey>(keySelector: (element: T) => TKey, comparer: (first: TKey, second: TKey) => number): IOrderedEnumerable<T>
reverse(): IEnumerable<T>
shuffle(): IEnumerable<T>
weightedSample(weightSelector: (element: T) => number): IEnumerable<T>
groupBy<TKey>(keySelector: (element: T) => TKey): IEnumerable<IGrouping<TKey, T>>
groupBy<TKey, TElement>(keySelector: (element: T) => TKey, elementSelector: (element: T) => TElement): IEnumerable<IGrouping<TKey, TElement>>
groupBy<TKey, TElement, TResult>(): IEnumerable<TResult>
keySelector: (element: T) => TKey,
elementSelector: (element: T) => TElement,
resultSelector: (key: TKey, element: IEnumerable<TElement>) => TResult,
groupBy<TKey, TElement, TResult, TCompare>(): IEnumerable<TResult>
keySelector: (element: T) => TKey,
elementSelector: (element: T) => TElement,
resultSelector: (key: TKey, element: IEnumerable<TElement>) => TResult,
compareSelector: (element: TKey) => TCompare,
partitionBy<TKey>(keySelector: (element: T) => TKey): IEnumerable<IGrouping<TKey, unknown>>
partitionBy<TKey, TElement>(keySelector: (element: T) => TKey, elementSelector: (element: T) => TElement): IEnumerable<IGrouping<TKey, TElement>>
partitionBy<TKey, TElement, TResult>(): IEnumerable<TResult>
keySelector: (element: T) => TKey,
elementSelector: (element: T) => TElement,
resultSelector: (key: TKey, element: IEnumerable<TElement>) => TResult,
partitionBy<TKey, TElement, TResult, TCompare>(): IEnumerable<TResult>
keySelector: (element: T) => TKey,
elementSelector: (element: T) => TElement,
resultSelector: (key: TKey, element: IEnumerable<TElement>) => TResult,
compareSelector: (element: TKey) => TCompare,
buffer(count: number): IEnumerable<T[]>
aggregate<TAccumulate>(seed: TAccumulate, func: (prev: TAccumulate, current: T) => TAccumulate): TAccumulate
aggregate<TAccumulate, TResult>(): TResult
seed: TAccumulate,
func: (prev: TAccumulate, current: T) => TAccumulate,
resultSelector: (last: TAccumulate) => TResult,
average(selector?: (element: T) => number): number
count(predicate?: (element: T, index: number) => boolean): number
max(selector?: (element: T) => number): number
min(selector?: (element: T) => number): number
sum(selector?: (element: T) => number): number
elementAt(index: number): T
skip(count: number): IEnumerable<T>
skipWhile(predicate: (element: T, index: number) => boolean): IEnumerable<T>
take(count: number): IEnumerable<T>
takeWhile(predicate: (element: T, index: number) => boolean): IEnumerable<T>
takeExceptLast(count?: number): IEnumerable<T>
takeFromLast(count: number): IEnumerable<T>
indexOf(item: T): number
indexOf(predicate: (element: T, index: number) => boolean): number
lastIndexOf(item: T): number
lastIndexOf(predicate: (element: T, index: number) => boolean): number
asEnumerable(): IEnumerable<T>
cast<TResult>(): IEnumerable<TResult>
toArray(): T[]
toDictionary<TKey>(keySelector: (element: T) => TKey): IDictionary<TKey, T>
toDictionary<TKey, TValue>(keySelector: (element: T) => TKey, elementSelector: (element: T) => TValue): IDictionary<TKey, TValue>
toDictionary<TKey, TValue, TCompare>(): IDictionary<TKey, TValue>
keySelector: (element: T) => TKey,
elementSelector: (element: T) => TValue,
compareSelector: (key: TKey) => TCompare,
toJoinedString<TResult>(separator: string, selector: (element: T, index: number) => TResult): string
doAction(action: (element: T, index: number) => void): IEnumerable<T>
doAction(action: (element: T, index: number) => boolean): IEnumerable<T>
forEach(action: (element: T, index: number) => void): void
forEach(action: (element: T, index: number) => boolean): void
write<TResult>(separator: string, selector: (element: T) => TResult): void
writeLine<TResult>(selector: (element: T) => TResult): void
letBind<TResult>(func: (source: IEnumerable<T>) => { [x: number]: TResult; length: number; }): IEnumerable<TResult>
letBind<TResult>(func: (source: IEnumerable<T>) => TResult[]): IEnumerable<TResult>
letBind<TResult>(func: (source: IEnumerable<T>) => IEnumerable<TResult>): IEnumerable<TResult>
memoize(): IDisposableEnumerable<T>
catchError(handler: string | ((exception: unknown) => void)): IEnumerable<T>
finallyAction(finallyAction: () => void): IEnumerable<T>
log(): IEnumerable<T>
log<TValue>(selector: (element: T) => TValue): IEnumerable<T>
trace(message?: string): IEnumerable<T>
trace<TValue>(message: string, selector: (element: T) => TValue): IEnumerable<T>