Class Collection

Package: @aurigma/design-atoms-model

Constructors

(constructor)(items)

Constructs a new instance of the Collection class

Declaration
constructor(items?: T[]);
Parameters
Type Name Description
T[] items

(constructor)(items)

Constructs a new instance of the Collection class

Declaration
constructor(items?: Collection<T>);
Parameters
Type Name Description
Collection<T> items

(constructor)(items)

Constructs a new instance of the Collection class

Declaration
constructor(...items: T[]);
Parameters
Type Name Description
T[] items

Properties

_collection

Declaration
protected _collection: T[];
Property Value
Type Description
T[]

constructor

Declaration
["constructor"]: (getEnumerator: () => Enumerable.IEnumerator<T>) => never;
Property Value
Type Description
(getEnumerator: () => Enumerable.IEnumerator<T>) => never

empty

Declaration
get empty(): boolean;
Property Value
Type Description
boolean

length

Declaration
get length(): number;
Property Value
Type Description
number

Methods

[Symbol.iterator]()

Declaration
[Symbol.iterator](): IterableIterator<T>;
Returns
Type Description
IterableIterator<T>

add_collectionChanged(h)

Declaration
add_collectionChanged(h: AnyFunction): void;
Parameters
Type Name Description
AnyFunction h
Returns
Type Description
void

add_itemAdded(h)

Declaration
add_itemAdded(h: (data?: {
        item: T;
        index: number;
    }) => any): void;
Parameters
Type Name Description
(data?: { item: T; index: number; }) => any h
Returns
Type Description
void

add_itemMoved(h)

Declaration
add_itemMoved(h: (data?: {
        oldIndex: number;
        newIndex: number;
    }) => any): void;
Parameters
Type Name Description
(data?: { oldIndex: number; newIndex: number; }) => any h
Returns
Type Description
void

add_itemRemoved(h)

Declaration
add_itemRemoved(h: (data?: {
        item: T;
        index: number;
    }) => any): void;
Parameters
Type Name Description
(data?: { item: T; index: number; }) => any h
Returns
Type Description
void

add(items)

Declaration
add(...items: T[]): void;
Parameters
Type Name Description
T[] items
Returns
Type Description
void

addRange(items)

Adds the specified items to the end of the collection.

Declaration
addRange(items: T[] | Collection<T> | Enumerable.IEnumerable<T>): void;
Parameters
Type Name Description
T[] | Collection<T> | Enumerable.IEnumerable<T> items
Returns
Type Description
void

aggregate(func)

Declaration
aggregate(func: (prev: T, current: T) => T): T;
Parameters
Type Name Description
(prev: T, current: T) => T func
Returns
Type Description
T

aggregate(seed, func)

Declaration
aggregate<TAccumulate>(seed: TAccumulate, func: (prev: TAccumulate, current: T) => TAccumulate): TAccumulate;
Parameters
Type Name Description
TAccumulate seed
(prev: TAccumulate, current: T) => TAccumulate func
Returns
Type Description
TAccumulate
Type Parameters
Name Description
TAccumulate

aggregate(seed, func, resultSelector)

Declaration
aggregate<TAccumulate, TResult>(seed: TAccumulate, func: (prev: TAccumulate, current: T) => TAccumulate, resultSelector: (last: TAccumulate) => TResult): TResult;
Parameters
Type Name Description
TAccumulate seed
(prev: TAccumulate, current: T) => TAccumulate func
(last: TAccumulate) => TResult resultSelector
Returns
Type Description
TResult
Type Parameters
Name Description
TAccumulate
TResult

all(predicate)

Declaration
all(predicate: (element: T) => boolean): boolean;
Parameters
Type Name Description
(element: T) => boolean predicate
Returns
Type Description
boolean

alternate(alternateValue)

Declaration
alternate(alternateValue: T): IEnumerable<T>;
Parameters
Type Name Description
T alternateValue
Returns
Type Description
Enumerable.IEnumerable<T>

alternate(alternateSequence)

Declaration
alternate(alternateSequence: {
        [x: number]: T;
        length: number;
    }): IEnumerable<T>;
Parameters
Type Name Description
{ [x: number]: T; length: number; } alternateSequence
Returns
Type Description
Enumerable.IEnumerable<T>

alternate(alternateSequence)

Declaration
alternate(alternateSequence: IEnumerable<T>): IEnumerable<T>;
Parameters
Type Name Description
Enumerable.IEnumerable<T> alternateSequence
Returns
Type Description
Enumerable.IEnumerable<T>

alternate(alternateSequence)

Declaration
alternate(alternateSequence: T[]): IEnumerable<T>;
Parameters
Type Name Description
T[] alternateSequence
Returns
Type Description
Enumerable.IEnumerable<T>

any(predicate)

Declaration
any(predicate?: (element: T) => boolean): boolean;
Parameters
Type Name Description
(element: T) => boolean predicate
Returns
Type Description
boolean

asEnumerable()

Declaration
asEnumerable(): IEnumerable<T>;
Returns
Type Description
Enumerable.IEnumerable<T>

average(selector)

Declaration
average(selector?: (element: T) => number): number;
Parameters
Type Name Description
(element: T) => number selector
Returns
Type Description
number

buffer(count)

Declaration
buffer(count: number): IEnumerable<T[]>;
Parameters
Type Name Description
number count
Returns
Type Description
Enumerable.IEnumerable<T[]>

cast()

Declaration
cast<TResult>(): IEnumerable<TResult>;
Returns
Type Description
Enumerable.IEnumerable<TResult>
Type Parameters
Name Description
TResult

catchError(handler)

Declaration
catchError(handler: (exception: any) => void): IEnumerable<T>;
Parameters
Type Name Description
(exception: any) => void handler
Returns
Type Description
Enumerable.IEnumerable<T>

choose(selector)

Declaration
choose(selector: (element: T, index: number) => T): IEnumerable<T>;
Parameters
Type Name Description
(element: T, index: number) => T selector
Returns
Type Description
Enumerable.IEnumerable<T>

clear()

Removes all items from the collection

Declaration
clear(): void;
Returns
Type Description
void

concat(sequences)

Declaration
concat(...sequences: IEnumerable<T>[]): IEnumerable<T>;
Parameters
Type Name Description
Enumerable.IEnumerable<T>[] sequences
Returns
Type Description
Enumerable.IEnumerable<T>

concat(sequences)

Declaration
concat(...sequences: {
        [x: number]: T;
        length: number;
    }[]): IEnumerable<T>;
Parameters
Type Name Description
{ [x: number]: T; length: number; }[] sequences
Returns
Type Description
Enumerable.IEnumerable<T>

concat(sequences)

Declaration
concat(...sequences: T[]): IEnumerable<T>;
Parameters
Type Name Description
T[] sequences
Returns
Type Description
Enumerable.IEnumerable<T>

contains(value)

Declaration
contains(value: T): boolean;
Parameters
Type Name Description
T value
Returns
Type Description
boolean

contains(value, compareSelector)

Declaration
contains<TCompare>(value: T, compareSelector?: (element: T) => TCompare): boolean;
Parameters
Type Name Description
T value
(element: T) => TCompare compareSelector
Returns
Type Description
boolean
Type Parameters
Name Description
TCompare

count(predicate)

Declaration
count(predicate?: (element: T, index: number) => boolean): number;
Parameters
Type Name Description
(element: T, index: number) => boolean predicate
Returns
Type Description
number

defaultIfEmpty(defaultValue)

Declaration
defaultIfEmpty(defaultValue?: T): IEnumerable<T>;
Parameters
Type Name Description
T defaultValue
Returns
Type Description
Enumerable.IEnumerable<T>

distinct()

Declaration
distinct(): IEnumerable<T>;
Returns
Type Description
Enumerable.IEnumerable<T>

distinct(compareSelector)

Declaration
distinct<TCompare>(compareSelector: (element: T) => TCompare): IEnumerable<T>;
Parameters
Type Name Description
(element: T) => TCompare compareSelector
Returns
Type Description
Enumerable.IEnumerable<T>
Type Parameters
Name Description
TCompare

distinctUntilChanged()

Declaration
distinctUntilChanged(): IEnumerable<T>;
Returns
Type Description
Enumerable.IEnumerable<T>

distinctUntilChanged(compareSelector)

Declaration
distinctUntilChanged<TCompare>(compareSelector: (element: T) => TCompare): IEnumerable<T>;
Parameters
Type Name Description
(element: T) => TCompare compareSelector
Returns
Type Description
Enumerable.IEnumerable<T>
Type Parameters
Name Description
TCompare

doAction(action)

Declaration
doAction(action: (element: T, index: number) => void): IEnumerable<T>;
Parameters
Type Name Description
(element: T, index: number) => void action
Returns
Type Description
Enumerable.IEnumerable<T>

doAction(action)

Declaration
doAction(action: (element: T, index: number) => boolean): IEnumerable<T>;
Parameters
Type Name Description
(element: T, index: number) => boolean action
Returns
Type Description
Enumerable.IEnumerable<T>

elementAt(index)

Declaration
elementAt(index: number): T;
Parameters
Type Name Description
number index
Returns
Type Description
T

elementAtOrDefault(index, defaultValue)

Declaration
elementAtOrDefault(index: number, defaultValue?: T): T;
Parameters
Type Name Description
number index
T defaultValue
Returns
Type Description
T

except(second)

Declaration
except(second: {
        [x: number]: T;
        length: number;
    }): IEnumerable<T>;
Parameters
Type Name Description
{ [x: number]: T; length: number; } second
Returns
Type Description
Enumerable.IEnumerable<T>

except(second, compareSelector)

Declaration
except<TCompare>(second: {
        [x: number]: T;
        length: number;
    }, compareSelector: (element: T) => TCompare): IEnumerable<T>;
Parameters
Type Name Description
{ [x: number]: T; length: number; } second
(element: T) => TCompare compareSelector
Returns
Type Description
Enumerable.IEnumerable<T>
Type Parameters
Name Description
TCompare

except(second)

Declaration
except(second: IEnumerable<T>): IEnumerable<T>;
Parameters
Type Name Description
Enumerable.IEnumerable<T> second
Returns
Type Description
Enumerable.IEnumerable<T>

except(second, compareSelector)

Declaration
except<TCompare>(second: IEnumerable<T>, compareSelector: (element: T) => TCompare): IEnumerable<T>;
Parameters
Type Name Description
Enumerable.IEnumerable<T> second
(element: T) => TCompare compareSelector
Returns
Type Description
Enumerable.IEnumerable<T>
Type Parameters
Name Description
TCompare

except(second)

Declaration
except(second: T[]): IEnumerable<T>;
Parameters
Type Name Description
T[] second
Returns
Type Description
Enumerable.IEnumerable<T>

except(second, compareSelector)

Declaration
except<TCompare>(second: T[], compareSelector: (element: T) => TCompare): IEnumerable<T>;
Parameters
Type Name Description
T[] second
(element: T) => TCompare compareSelector
Returns
Type Description
Enumerable.IEnumerable<T>
Type Parameters
Name Description
TCompare

finallyAction(finallyAction)

Declaration
finallyAction(finallyAction: () => void): IEnumerable<T>;
Parameters
Type Name Description
() => void finallyAction
Returns
Type Description
Enumerable.IEnumerable<T>

first(predicate)

Declaration
first(predicate?: (element: T, index: number) => boolean): T;
Parameters
Type Name Description
(element: T, index: number) => boolean predicate
Returns
Type Description
T

firstOrDefault(predicate, defaultValue)

Declaration
firstOrDefault(predicate?: ((element: T, index: number) => boolean) | T, defaultValue?: T): T;
Parameters
Type Name Description
((element: T, index: number) => boolean) | T predicate
T defaultValue
Returns
Type Description
T

flatten()

Declaration
flatten(): IEnumerable<any>;
Returns
Type Description
Enumerable.IEnumerable<any>

force()

Declaration
force(): void;
Returns
Type Description
void

forEach(action)

Declaration
forEach(action: (element: T, index: number) => void): void;
Parameters
Type Name Description
(element: T, index: number) => void action
Returns
Type Description
void

forEach(action)

Declaration
forEach(action: (element: T, index: number) => boolean): void;
Parameters
Type Name Description
(element: T, index: number) => boolean action
Returns
Type Description
void

get(index)

Declaration
get(index: number): T;
Parameters
Type Name Description
number index
Returns
Type Description
T

getEnumerator()

Declaration
getEnumerator(): Enumerable.IEnumerator<T>;
Returns
Type Description
Enumerable.IEnumerator<T>

getItem(index)

Declaration
getItem(index: any): T;
Parameters
Type Name Description
any index
Returns
Type Description
T

groupBy(keySelector)

Declaration
groupBy<TKey>(keySelector: (element: T) => TKey): IEnumerable<Enumerable.IGrouping<TKey, T>>;
Parameters
Type Name Description
(element: T) => TKey keySelector
Returns
Type Description
Enumerable.IEnumerable<Enumerable.IGrouping<TKey, T>>
Type Parameters
Name Description
TKey

groupBy(keySelector, elementSelector)

Declaration
groupBy<TKey, TElement>(keySelector: (element: T) => TKey, elementSelector: (element: T) => TElement): IEnumerable<Enumerable.IGrouping<TKey, TElement>>;
Parameters
Type Name Description
(element: T) => TKey keySelector
(element: T) => TElement elementSelector
Returns
Type Description
Enumerable.IEnumerable<Enumerable.IGrouping<TKey, TElement>>
Type Parameters
Name Description
TKey
TElement

groupBy(keySelector, elementSelector, resultSelector)

Declaration
groupBy<TKey, TElement, TResult>(keySelector: (element: T) => TKey, elementSelector: (element: T) => TElement, resultSelector: (key: TKey, element: IEnumerable<TElement>) => TResult): IEnumerable<TResult>;
Parameters
Type Name Description
(element: T) => TKey keySelector
(element: T) => TElement elementSelector
(key: TKey, element: Enumerable.IEnumerable<TElement>) => TResult resultSelector
Returns
Type Description
Enumerable.IEnumerable<TResult>
Type Parameters
Name Description
TKey
TElement
TResult

groupBy(keySelector, elementSelector, resultSelector, compareSelector)

Declaration
groupBy<TKey, TElement, TResult, TCompare>(keySelector: (element: T) => TKey, elementSelector: (element: T) => TElement, resultSelector: (key: TKey, element: IEnumerable<TElement>) => TResult, compareSelector: (element: T) => TCompare): IEnumerable<TResult>;
Parameters
Type Name Description
(element: T) => TKey keySelector
(element: T) => TElement elementSelector
(key: TKey, element: Enumerable.IEnumerable<TElement>) => TResult resultSelector
(element: T) => TCompare compareSelector
Returns
Type Description
Enumerable.IEnumerable<TResult>
Type Parameters
Name Description
TKey
TElement
TResult
TCompare

groupJoin(inner, outerKeySelector, innerKeySelector, resultSelector, compareSelector)

Declaration
groupJoin<TInner, TKey, TResult>(inner: IEnumerable<TInner>, outerKeySelector: (outer: T) => TKey, innerKeySelector: (inner: TInner) => TKey, resultSelector: (outer: T, inner: TInner) => TResult, compareSelector?: (obj: T) => TKey): IEnumerable<TResult>;
Parameters
Type Name Description
Enumerable.IEnumerable<TInner> inner
(outer: T) => TKey outerKeySelector
(inner: TInner) => TKey innerKeySelector
(outer: T, inner: TInner) => TResult resultSelector
(obj: T) => TKey compareSelector
Returns
Type Description
Enumerable.IEnumerable<TResult>
Type Parameters
Name Description
TInner
TKey
TResult

groupJoin(inner, outerKeySelector, innerKeySelector, resultSelector, compareSelector)

Declaration
groupJoin<TInner, TKey, 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): IEnumerable<TResult>;
Parameters
Type Name Description
{ [x: number]: TInner; length: number; } inner
(outer: T) => TKey outerKeySelector
(inner: TInner) => TKey innerKeySelector
(outer: T, inner: TInner) => TResult resultSelector
(obj: T) => TKey compareSelector
Returns
Type Description
Enumerable.IEnumerable<TResult>
Type Parameters
Name Description
TInner
TKey
TResult

groupJoin(inner, outerKeySelector, innerKeySelector, resultSelector, compareSelector)

Declaration
groupJoin<TInner, TKey, TResult>(inner: TInner[], outerKeySelector: (outer: T) => TKey, innerKeySelector: (inner: TInner) => TKey, resultSelector: (outer: T, inner: TInner) => TResult, compareSelector?: (obj: T) => TKey): IEnumerable<TResult>;
Parameters
Type Name Description
TInner[] inner
(outer: T) => TKey outerKeySelector
(inner: TInner) => TKey innerKeySelector
(outer: T, inner: TInner) => TResult resultSelector
(obj: T) => TKey compareSelector
Returns
Type Description
Enumerable.IEnumerable<TResult>
Type Parameters
Name Description
TInner
TKey
TResult

indexOf(item)

Declaration
indexOf(item: T): number;
Parameters
Type Name Description
T item
Returns
Type Description
number

indexOf(predicate)

Declaration
indexOf(predicate: (element: T, index: number) => boolean): number;
Parameters
Type Name Description
(element: T, index: number) => boolean predicate
Returns
Type Description
number

insert(index, second)

Declaration
insert(index: number, second: Enumerable.IEnumerable<T>): Enumerable.IEnumerable<T>;
Parameters
Type Name Description
number index
Enumerable.IEnumerable<T> second
Returns
Type Description
Enumerable.IEnumerable<T>

insert(index, second)

Declaration
insert(index: number, second: {
        [x: number]: T;
        length: number;
    }): Enumerable.IEnumerable<T>;
Parameters
Type Name Description
number index
{ [x: number]: T; length: number; } second
Returns
Type Description
Enumerable.IEnumerable<T>

insertAt(index, items)

Inserts the specified item into the collection at the specified index.

Declaration
insertAt(index: number, items: T | T[]): void;
Parameters
Type Name Description
number index
T | T[] items
Returns
Type Description
void

intersect(second)

Declaration
intersect(second: {
        [x: number]: T;
        length: number;
    }): IEnumerable<T>;
Parameters
Type Name Description
{ [x: number]: T; length: number; } second
Returns
Type Description
Enumerable.IEnumerable<T>

intersect(second, compareSelector)

Declaration
intersect<TCompare>(second: {
        [x: number]: T;
        length: number;
    }, compareSelector: (element: T) => TCompare): IEnumerable<T>;
Parameters
Type Name Description
{ [x: number]: T; length: number; } second
(element: T) => TCompare compareSelector
Returns
Type Description
Enumerable.IEnumerable<T>
Type Parameters
Name Description
TCompare

intersect(second)

Declaration
intersect(second: IEnumerable<T>): IEnumerable<T>;
Parameters
Type Name Description
Enumerable.IEnumerable<T> second
Returns
Type Description
Enumerable.IEnumerable<T>

intersect(second, compareSelector)

Declaration
intersect<TCompare>(second: IEnumerable<T>, compareSelector: (element: T) => TCompare): IEnumerable<T>;
Parameters
Type Name Description
Enumerable.IEnumerable<T> second
(element: T) => TCompare compareSelector
Returns
Type Description
Enumerable.IEnumerable<T>
Type Parameters
Name Description
TCompare

intersect(second)

Declaration
intersect(second: T[]): IEnumerable<T>;
Parameters
Type Name Description
T[] second
Returns
Type Description
Enumerable.IEnumerable<T>

intersect(second, compareSelector)

Declaration
intersect<TCompare>(second: T[], compareSelector: (element: T) => TCompare): IEnumerable<T>;
Parameters
Type Name Description
T[] second
(element: T) => TCompare compareSelector
Returns
Type Description
Enumerable.IEnumerable<T>
Type Parameters
Name Description
TCompare

isEmpty()

Declaration
isEmpty(): boolean;
Returns
Type Description
boolean

join(inner, outerKeySelector, innerKeySelector, resultSelector, compareSelector)

Declaration
join<TInner, TKey, TResult>(inner: IEnumerable<TInner>, outerKeySelector: (outer: T) => TKey, innerKeySelector: (inner: TInner) => TKey, resultSelector: (outer: T, inner: TInner) => TResult, compareSelector?: (obj: T) => TKey): IEnumerable<TResult>;
Parameters
Type Name Description
Enumerable.IEnumerable<TInner> inner
(outer: T) => TKey outerKeySelector
(inner: TInner) => TKey innerKeySelector
(outer: T, inner: TInner) => TResult resultSelector
(obj: T) => TKey compareSelector
Returns
Type Description
Enumerable.IEnumerable<TResult>
Type Parameters
Name Description
TInner
TKey
TResult

join(inner, outerKeySelector, innerKeySelector, resultSelector, compareSelector)

Declaration
join<TInner, TKey, 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): IEnumerable<TResult>;
Parameters
Type Name Description
{ [x: number]: TInner; length: number; } inner
(outer: T) => TKey outerKeySelector
(inner: TInner) => TKey innerKeySelector
(outer: T, inner: TInner) => TResult resultSelector
(obj: T) => TKey compareSelector
Returns
Type Description
Enumerable.IEnumerable<TResult>
Type Parameters
Name Description
TInner
TKey
TResult

join(inner, outerKeySelector, innerKeySelector, resultSelector, compareSelector)

Declaration
join<TInner, TKey, TResult>(inner: TInner[], outerKeySelector: (outer: T) => TKey, innerKeySelector: (inner: TInner) => TKey, resultSelector: (outer: T, inner: TInner) => TResult, compareSelector?: (obj: T) => TKey): IEnumerable<TResult>;
Parameters
Type Name Description
TInner[] inner
(outer: T) => TKey outerKeySelector
(inner: TInner) => TKey innerKeySelector
(outer: T, inner: TInner) => TResult resultSelector
(obj: T) => TKey compareSelector
Returns
Type Description
Enumerable.IEnumerable<TResult>
Type Parameters
Name Description
TInner
TKey
TResult

last(predicate)

Declaration
last(predicate?: (element: T, index: number) => boolean): T;
Parameters
Type Name Description
(element: T, index: number) => boolean predicate
Returns
Type Description
T

lastIndexOf(item)

Declaration
lastIndexOf(item: T): number;
Parameters
Type Name Description
T item
Returns
Type Description
number

lastIndexOf(predicate)

Declaration
lastIndexOf(predicate: (element: T, index: number) => boolean): number;
Parameters
Type Name Description
(element: T, index: number) => boolean predicate
Returns
Type Description
number

lastOrDefault(predicate, defaultValue)

Declaration
lastOrDefault(predicate?: ((element: T, index: number) => boolean) | T, defaultValue?: T): T;
Parameters
Type Name Description
((element: T, index: number) => boolean) | T predicate
T defaultValue
Returns
Type Description
T

letBind(func)

Declaration
letBind<TResult>(func: (source: IEnumerable<T>) => {
        [x: number]: TResult;
        length: number;
    }): IEnumerable<TResult>;
Parameters
Type Name Description
(source: Enumerable.IEnumerable<T>) => { [x: number]: TResult; length: number; } func
Returns
Type Description
Enumerable.IEnumerable<TResult>
Type Parameters
Name Description
TResult

letBind(func)

Declaration
letBind<TResult>(func: (source: IEnumerable<T>) => TResult[]): IEnumerable<TResult>;
Parameters
Type Name Description
(source: Enumerable.IEnumerable<T>) => TResult[] func
Returns
Type Description
Enumerable.IEnumerable<TResult>
Type Parameters
Name Description
TResult

letBind(func)

Declaration
letBind<TResult>(func: (source: IEnumerable<T>) => IEnumerable<TResult>): IEnumerable<TResult>;
Parameters
Type Name Description
(source: Enumerable.IEnumerable<T>) => Enumerable.IEnumerable<TResult> func
Returns
Type Description
Enumerable.IEnumerable<TResult>
Type Parameters
Name Description
TResult

log()

Declaration
log(): IEnumerable<T>;
Returns
Type Description
Enumerable.IEnumerable<T>

log(selector)

Declaration
log<TValue>(selector: (element: T) => TValue): IEnumerable<T>;
Parameters
Type Name Description
(element: T) => TValue selector
Returns
Type Description
Enumerable.IEnumerable<T>
Type Parameters
Name Description
TValue

max(selector)

Declaration
max(selector?: (element: T) => number): number;
Parameters
Type Name Description
(element: T) => number selector
Returns
Type Description
number

maxBy(keySelector)

Declaration
maxBy<TKey>(keySelector: (element: T) => TKey): T;
Parameters
Type Name Description
(element: T) => TKey keySelector
Returns
Type Description
T
Type Parameters
Name Description
TKey

memoize()

Declaration
memoize(): Enumerable.IDisposableEnumerable<T>;
Returns
Type Description
Enumerable.IDisposableEnumerable<T>

merge(params)

Declaration
merge<TResult>(...params: IEnumerable<T>[]): IEnumerable<T>;
Parameters
Type Name Description
Enumerable.IEnumerable<T>[] params
Returns
Type Description
Enumerable.IEnumerable<T>
Type Parameters
Name Description
TResult

merge(params)

Declaration
merge<TResult>(...params: {
        [x: number]: T;
        length: number;
    }[]): IEnumerable<T>;
Parameters
Type Name Description
{ [x: number]: T; length: number; }[] params
Returns
Type Description
Enumerable.IEnumerable<T>
Type Parameters
Name Description
TResult

merge(params)

Declaration
merge<TResult>(...params: T[][]): IEnumerable<T>;
Parameters
Type Name Description
T[][] params
Returns
Type Description
Enumerable.IEnumerable<T>
Type Parameters
Name Description
TResult

min(selector)

Declaration
min(selector?: (element: T) => number): number;
Parameters
Type Name Description
(element: T) => number selector
Returns
Type Description
number

minBy(keySelector)

Declaration
minBy<TKey>(keySelector: (element: T) => TKey): T;
Parameters
Type Name Description
(element: T) => TKey keySelector
Returns
Type Description
T
Type Parameters
Name Description
TKey

move(oldIndex, newIndex, supressEvent)

Declaration
move(oldIndex: any, newIndex: any, supressEvent?: boolean): T;
Parameters
Type Name Description
any oldIndex
any newIndex
boolean supressEvent
Returns
Type Description
T

ofType(type)

Declaration
ofType<TOf>(type: Type<TOf>): IEnumerable<TOf>;
Parameters
Type Name Description
unknown<TOf> type
Returns
Type Description
Enumerable.IEnumerable<TOf>
Type Parameters
Name Description
TOf

orderBy(keySelector)

Declaration
orderBy<TKey>(keySelector: (element: T) => TKey): Enumerable.IOrderedEnumerable<T>;
Parameters
Type Name Description
(element: T) => TKey keySelector
Returns
Type Description
Enumerable.IOrderedEnumerable<T>
Type Parameters
Name Description
TKey

orderByDescending(keySelector)

Declaration
orderByDescending<TKey>(keySelector: (element: T) => TKey): Enumerable.IOrderedEnumerable<T>;
Parameters
Type Name Description
(element: T) => TKey keySelector
Returns
Type Description
Enumerable.IOrderedEnumerable<T>
Type Parameters
Name Description
TKey

pairwise(selector)

Declaration
pairwise<TResult>(selector: (prev: T, current: T) => TResult): IEnumerable<TResult>;
Parameters
Type Name Description
(prev: T, current: T) => TResult selector
Returns
Type Description
Enumerable.IEnumerable<TResult>
Type Parameters
Name Description
TResult

partitionBy(keySelector)

Declaration
partitionBy<TKey>(keySelector: (element: T) => TKey): IEnumerable<Enumerable.IGrouping<TKey, any>>;
Parameters
Type Name Description
(element: T) => TKey keySelector
Returns
Type Description
Enumerable.IEnumerable<Enumerable.IGrouping<TKey, any>>
Type Parameters
Name Description
TKey

partitionBy(keySelector, elementSelector)

Declaration
partitionBy<TKey, TElement>(keySelector: (element: T) => TKey, elementSelector: (element: T) => TElement): IEnumerable<Enumerable.IGrouping<TKey, TElement>>;
Parameters
Type Name Description
(element: T) => TKey keySelector
(element: T) => TElement elementSelector
Returns
Type Description
Enumerable.IEnumerable<Enumerable.IGrouping<TKey, TElement>>
Type Parameters
Name Description
TKey
TElement

partitionBy(keySelector, elementSelector, resultSelector)

Declaration
partitionBy<TKey, TElement, TResult>(keySelector: (element: T) => TKey, elementSelector: (element: T) => TElement, resultSelector: (key: TKey, element: IEnumerable<TElement>) => TResult): IEnumerable<TResult>;
Parameters
Type Name Description
(element: T) => TKey keySelector
(element: T) => TElement elementSelector
(key: TKey, element: Enumerable.IEnumerable<TElement>) => TResult resultSelector
Returns
Type Description
Enumerable.IEnumerable<TResult>
Type Parameters
Name Description
TKey
TElement
TResult

partitionBy(keySelector, elementSelector, resultSelector, compareSelector)

Declaration
partitionBy<TKey, TElement, TResult, TCompare>(keySelector: (element: T) => TKey, elementSelector: (element: T) => TElement, resultSelector: (key: TKey, element: IEnumerable<TElement>) => TResult, compareSelector: (element: T) => TCompare): IEnumerable<TResult>;
Parameters
Type Name Description
(element: T) => TKey keySelector
(element: T) => TElement elementSelector
(key: TKey, element: Enumerable.IEnumerable<TElement>) => TResult resultSelector
(element: T) => TCompare compareSelector
Returns
Type Description
Enumerable.IEnumerable<TResult>
Type Parameters
Name Description
TKey
TElement
TResult
TCompare

push(item)

Declaration
push(item: T): number;
Parameters
Type Name Description
T item
Returns
Type Description
number

remove_collectionChanged(h)

Declaration
remove_collectionChanged(h: AnyFunction): void;
Parameters
Type Name Description
AnyFunction h
Returns
Type Description
void

remove_itemAdded(h)

Declaration
remove_itemAdded(h: any): void;
Parameters
Type Name Description
any h
Returns
Type Description
void

remove_itemMoved(h)

Declaration
remove_itemMoved(h: (data?: {
        oldIndex: number;
        newIndex: number;
    }) => any): void;
Parameters
Type Name Description
(data?: { oldIndex: number; newIndex: number; }) => any h
Returns
Type Description
void

remove_itemRemoved(h)

Declaration
remove_itemRemoved(h: any): void;
Parameters
Type Name Description
any h
Returns
Type Description
void

remove(item)

Declaration
remove(item: T): T;
Parameters
Type Name Description
T item
Returns
Type Description
T

removeAt(index)

Removes the item at the specified index of the collection.

Declaration
removeAt(index: number): T;
Parameters
Type Name Description
number index
Returns
Type Description
T

removeRange(from, to)

Declaration
removeRange(from: number, to: number): T[];
Parameters
Type Name Description
number from
number to
Returns
Type Description
T[]

replaceAt(item, index)

Declaration
replaceAt(item: T, index: number): void;
Parameters
Type Name Description
T item
number index
Returns
Type Description
void

reverse()

Declaration
reverse(): IEnumerable<T>;
Returns
Type Description
Enumerable.IEnumerable<T>

scan(func)

Declaration
scan(func: (prev: T, current: T) => T): IEnumerable<T>;
Parameters
Type Name Description
(prev: T, current: T) => T func
Returns
Type Description
Enumerable.IEnumerable<T>

scan(seed, func)

Declaration
scan<TAccumulate>(seed: TAccumulate, func: (prev: TAccumulate, current: T) => TAccumulate): IEnumerable<TAccumulate>;
Parameters
Type Name Description
TAccumulate seed
(prev: TAccumulate, current: T) => TAccumulate func
Returns
Type Description
Enumerable.IEnumerable<TAccumulate>
Type Parameters
Name Description
TAccumulate

select(selector)

Declaration
select<TResult>(selector: (element: T, index: number) => TResult): IEnumerable<TResult>;
Parameters
Type Name Description
(element: T, index: number) => TResult selector
Returns
Type Description
Enumerable.IEnumerable<TResult>
Type Parameters
Name Description
TResult

selectMany(collectionSelector)

Declaration
selectMany<TOther>(collectionSelector: (element: T, index: number) => IEnumerable<TOther>): IEnumerable<TOther>;
Parameters
Type Name Description
(element: T, index: number) => Enumerable.IEnumerable<TOther> collectionSelector
Returns
Type Description
Enumerable.IEnumerable<TOther>
Type Parameters
Name Description
TOther

selectMany(collectionSelector, resultSelector)

Declaration
selectMany<TCollection, TResult>(collectionSelector: (element: T, index: number) => IEnumerable<TCollection>, resultSelector: (outer: T, inner: TCollection) => TResult): IEnumerable<TResult>;
Parameters
Type Name Description
(element: T, index: number) => Enumerable.IEnumerable<TCollection> collectionSelector
(outer: T, inner: TCollection) => TResult resultSelector
Returns
Type Description
Enumerable.IEnumerable<TResult>
Type Parameters
Name Description
TCollection
TResult

selectMany(collectionSelector)

Declaration
selectMany<TOther>(collectionSelector: (element: T, index: number) => TOther[]): IEnumerable<TOther>;
Parameters
Type Name Description
(element: T, index: number) => TOther[] collectionSelector
Returns
Type Description
Enumerable.IEnumerable<TOther>
Type Parameters
Name Description
TOther

selectMany(collectionSelector, resultSelector)

Declaration
selectMany<TCollection, TResult>(collectionSelector: (element: T, index: number) => TCollection[], resultSelector: (outer: T, inner: TCollection) => TResult): IEnumerable<TResult>;
Parameters
Type Name Description
(element: T, index: number) => TCollection[] collectionSelector
(outer: T, inner: TCollection) => TResult resultSelector
Returns
Type Description
Enumerable.IEnumerable<TResult>
Type Parameters
Name Description
TCollection
TResult

selectMany(collectionSelector)

Declaration
selectMany<TOther>(collectionSelector: (element: T, index: number) => {
        [x: number]: TOther;
        length: number;
    }): IEnumerable<TOther>;
Parameters
Type Name Description
(element: T, index: number) => { [x: number]: TOther; length: number; } collectionSelector
Returns
Type Description
Enumerable.IEnumerable<TOther>
Type Parameters
Name Description
TOther

selectMany(collectionSelector, resultSelector)

Declaration
selectMany<TCollection, TResult>(collectionSelector: (element: T, index: number) => {
        [x: number]: TCollection;
        length: number;
    }, resultSelector: (outer: T, inner: TCollection) => TResult): IEnumerable<TResult>;
Parameters
Type Name Description
(element: T, index: number) => { [x: number]: TCollection; length: number; } collectionSelector
(outer: T, inner: TCollection) => TResult resultSelector
Returns
Type Description
Enumerable.IEnumerable<TResult>
Type Parameters
Name Description
TCollection
TResult

sequenceEqual(second)

Declaration
sequenceEqual(second: {
        [x: number]: T;
        length: number;
    }): boolean;
Parameters
Type Name Description
{ [x: number]: T; length: number; } second
Returns
Type Description
boolean

sequenceEqual(second, compareSelector)

Declaration
sequenceEqual<TCompare>(second: {
        [x: number]: T;
        length: number;
    }, compareSelector: (element: T) => TCompare): boolean;
Parameters
Type Name Description
{ [x: number]: T; length: number; } second
(element: T) => TCompare compareSelector
Returns
Type Description
boolean
Type Parameters
Name Description
TCompare

sequenceEqual(second)

Declaration
sequenceEqual(second: IEnumerable<T>): boolean;
Parameters
Type Name Description
Enumerable.IEnumerable<T> second
Returns
Type Description
boolean

sequenceEqual(second, compareSelector)

Declaration
sequenceEqual<TCompare>(second: IEnumerable<T>, compareSelector: (element: T) => TCompare): boolean;
Parameters
Type Name Description
Enumerable.IEnumerable<T> second
(element: T) => TCompare compareSelector
Returns
Type Description
boolean
Type Parameters
Name Description
TCompare

sequenceEqual(second)

Declaration
sequenceEqual(second: T[]): boolean;
Parameters
Type Name Description
T[] second
Returns
Type Description
boolean

sequenceEqual(second, compareSelector)

Declaration
sequenceEqual<TCompare>(second: T[], compareSelector: (element: T) => TCompare): boolean;
Parameters
Type Name Description
T[] second
(element: T) => TCompare compareSelector
Returns
Type Description
boolean
Type Parameters
Name Description
TCompare

set(index, value)

Declaration
set(index: number, value: T): void;
Parameters
Type Name Description
number index
T value
Returns
Type Description
void

setRange(items)

Declaration
setRange(items: T[] | Collection<T> | Enumerable.IEnumerable<T>): void;
Parameters
Type Name Description
T[] | Collection<T> | Enumerable.IEnumerable<T> items
Returns
Type Description
void

share()

Declaration
share(): Enumerable.IDisposableEnumerable<T>;
Returns
Type Description
Enumerable.IDisposableEnumerable<T>

shuffle()

Declaration
shuffle(): IEnumerable<T>;
Returns
Type Description
Enumerable.IEnumerable<T>

single(predicate)

Declaration
single(predicate?: (element: T, index: number) => boolean): T;
Parameters
Type Name Description
(element: T, index: number) => boolean predicate
Returns
Type Description
T

singleOrDefault(predicate, defaultValue)

Declaration
singleOrDefault(predicate?: (element: T, index: number) => boolean, defaultValue?: T): T;
Parameters
Type Name Description
(element: T, index: number) => boolean predicate
T defaultValue
Returns
Type Description
T

skip(count)

Declaration
skip(count: number): IEnumerable<T>;
Parameters
Type Name Description
number count
Returns
Type Description
Enumerable.IEnumerable<T>

skipWhile(predicate)

Declaration
skipWhile(predicate: (element: T, index: number) => boolean): IEnumerable<T>;
Parameters
Type Name Description
(element: T, index: number) => boolean predicate
Returns
Type Description
Enumerable.IEnumerable<T>

sum(selector)

Declaration
sum(selector?: (element: T) => number): number;
Parameters
Type Name Description
(element: T) => number selector
Returns
Type Description
number

take(count)

Declaration
take(count: number): IEnumerable<T>;
Parameters
Type Name Description
number count
Returns
Type Description
Enumerable.IEnumerable<T>

takeExceptLast(count)

Declaration
takeExceptLast(count?: number): IEnumerable<T>;
Parameters
Type Name Description
number count
Returns
Type Description
Enumerable.IEnumerable<T>

takeFromLast(count)

Declaration
takeFromLast(count: number): IEnumerable<T>;
Parameters
Type Name Description
number count
Returns
Type Description
Enumerable.IEnumerable<T>

takeWhile(predicate)

Declaration
takeWhile(predicate: (element: T, index: number) => boolean): IEnumerable<T>;
Parameters
Type Name Description
(element: T, index: number) => boolean predicate
Returns
Type Description
Enumerable.IEnumerable<T>

toArray()

Declaration
toArray(): T[];
Returns
Type Description
T[]

toDictionary(keySelector)

Declaration
toDictionary<TKey>(keySelector: (element: T) => TKey): Enumerable.IDictionary<TKey, any>;
Parameters
Type Name Description
(element: T) => TKey keySelector
Returns
Type Description
Enumerable.IDictionary<TKey, any>
Type Parameters
Name Description
TKey

toDictionary(keySelector, elementSelector)

Declaration
toDictionary<TKey, TValue>(keySelector: (element: T) => TKey, elementSelector: (element: T) => TValue): Enumerable.IDictionary<TKey, TValue>;
Parameters
Type Name Description
(element: T) => TKey keySelector
(element: T) => TValue elementSelector
Returns
Type Description
Enumerable.IDictionary<TKey, TValue>
Type Parameters
Name Description
TKey
TValue

toDictionary(keySelector, elementSelector, compareSelector)

Declaration
toDictionary<TKey, TValue, TCompare>(keySelector: (element: T) => TKey, elementSelector: (element: T) => TValue, compareSelector: (key: TKey) => TCompare): Enumerable.IDictionary<TKey, TValue>;
Parameters
Type Name Description
(element: T) => TKey keySelector
(element: T) => TValue elementSelector
(key: TKey) => TCompare compareSelector
Returns
Type Description
Enumerable.IDictionary<TKey, TValue>
Type Parameters
Name Description
TKey
TValue
TCompare

toJoinedString(separator)

Declaration
toJoinedString(separator?: string): string;
Parameters
Type Name Description
string separator
Returns
Type Description
string

toJoinedString(separator, selector)

Declaration
toJoinedString<TResult>(separator: string, selector: (element: T, index: number) => TResult): string;
Parameters
Type Name Description
string separator
(element: T, index: number) => TResult selector
Returns
Type Description
string
Type Parameters
Name Description
TResult

toJSONString(replacer)

Declaration
toJSONString(replacer: (key: string, value: any) => any): string;
Parameters
Type Name Description
(key: string, value: any) => any replacer
Returns
Type Description
string

toJSONString(replacer)

Declaration
toJSONString(replacer: any[]): string;
Parameters
Type Name Description
any[] replacer
Returns
Type Description
string

toJSONString(replacer, space)

Declaration
toJSONString(replacer: (key: string, value: any) => any, space: any): string;
Parameters
Type Name Description
(key: string, value: any) => any replacer
any space
Returns
Type Description
string

toJSONString(replacer, space)

Declaration
toJSONString(replacer: any[], space: any): string;
Parameters
Type Name Description
any[] replacer
any space
Returns
Type Description
string

toLookup(keySelector)

Declaration
toLookup<TKey>(keySelector: (element: T) => TKey): Enumerable.ILookup<TKey, T>;
Parameters
Type Name Description
(element: T) => TKey keySelector
Returns
Type Description
Enumerable.ILookup<TKey, T>
Type Parameters
Name Description
TKey

toLookup(keySelector, elementSelector)

Declaration
toLookup<TKey, TElement>(keySelector: (element: T) => TKey, elementSelector: (element: T) => TElement): Enumerable.ILookup<TKey, TElement>;
Parameters
Type Name Description
(element: T) => TKey keySelector
(element: T) => TElement elementSelector
Returns
Type Description
Enumerable.ILookup<TKey, TElement>
Type Parameters
Name Description
TKey
TElement

toLookup(keySelector, elementSelector, compareSelector)

Declaration
toLookup<TKey, TElement, TCompare>(keySelector: (element: T) => TKey, elementSelector: (element: T) => TElement, compareSelector: (key: TKey) => TCompare): Enumerable.ILookup<TKey, TElement>;
Parameters
Type Name Description
(element: T) => TKey keySelector
(element: T) => TElement elementSelector
(key: TKey) => TCompare compareSelector
Returns
Type Description
Enumerable.ILookup<TKey, TElement>
Type Parameters
Name Description
TKey
TElement
TCompare

toObject(keySelector, elementSelector)

Declaration
toObject(keySelector: (element: T) => any, elementSelector?: (element: T) => any): Object;
Parameters
Type Name Description
(element: T) => any keySelector
(element: T) => any elementSelector
Returns
Type Description
Object

trace(message)

Declaration
trace(message?: string): IEnumerable<T>;
Parameters
Type Name Description
string message
Returns
Type Description
Enumerable.IEnumerable<T>

trace(message, selector)

Declaration
trace<TValue>(message: string, selector: (element: T) => TValue): IEnumerable<T>;
Parameters
Type Name Description
string message
(element: T) => TValue selector
Returns
Type Description
Enumerable.IEnumerable<T>
Type Parameters
Name Description
TValue

traverseBreadthFirst(childrenSelector)

Declaration
traverseBreadthFirst(childrenSelector: (element: T) => IEnumerable<T>): IEnumerable<T>;
Parameters
Type Name Description
(element: T) => Enumerable.IEnumerable<T> childrenSelector
Returns
Type Description
Enumerable.IEnumerable<T>

traverseBreadthFirst(childrenSelector, resultSelector)

Declaration
traverseBreadthFirst<TResult>(childrenSelector: (element: T) => IEnumerable<T>, resultSelector: (element: T, nestLevel: number) => TResult): IEnumerable<TResult>;
Parameters
Type Name Description
(element: T) => Enumerable.IEnumerable<T> childrenSelector
(element: T, nestLevel: number) => TResult resultSelector
Returns
Type Description
Enumerable.IEnumerable<TResult>
Type Parameters
Name Description
TResult

traverseDepthFirst(childrenSelector)

Declaration
traverseDepthFirst<TResult>(childrenSelector: (element: T) => IEnumerable<T>): IEnumerable<T>;
Parameters
Type Name Description
(element: T) => Enumerable.IEnumerable<T> childrenSelector
Returns
Type Description
Enumerable.IEnumerable<T>
Type Parameters
Name Description
TResult

traverseDepthFirst(childrenSelector, resultSelector)

Declaration
traverseDepthFirst<TResult>(childrenSelector: (element: T) => IEnumerable<T>, resultSelector?: (element: T, nestLevel: number) => TResult): IEnumerable<TResult>;
Parameters
Type Name Description
(element: T) => Enumerable.IEnumerable<T> childrenSelector
(element: T, nestLevel: number) => TResult resultSelector
Returns
Type Description
Enumerable.IEnumerable<TResult>
Type Parameters
Name Description
TResult

union(second)

Declaration
union(second: {
        [x: number]: T;
        length: number;
    }): IEnumerable<T>;
Parameters
Type Name Description
{ [x: number]: T; length: number; } second
Returns
Type Description
Enumerable.IEnumerable<T>

union(second, compareSelector)

Declaration
union<TCompare>(second: {
        [x: number]: T;
        length: number;
    }, compareSelector: (element: T) => TCompare): IEnumerable<T>;
Parameters
Type Name Description
{ [x: number]: T; length: number; } second
(element: T) => TCompare compareSelector
Returns
Type Description
Enumerable.IEnumerable<T>
Type Parameters
Name Description
TCompare

union(second)

Declaration
union(second: IEnumerable<T>): IEnumerable<T>;
Parameters
Type Name Description
Enumerable.IEnumerable<T> second
Returns
Type Description
Enumerable.IEnumerable<T>

union(second, compareSelector)

Declaration
union<TCompare>(second: IEnumerable<T>, compareSelector: (element: T) => TCompare): IEnumerable<T>;
Parameters
Type Name Description
Enumerable.IEnumerable<T> second
(element: T) => TCompare compareSelector
Returns
Type Description
Enumerable.IEnumerable<T>
Type Parameters
Name Description
TCompare

union(second)

Declaration
union(second: T[]): IEnumerable<T>;
Parameters
Type Name Description
T[] second
Returns
Type Description
Enumerable.IEnumerable<T>

union(second, compareSelector)

Declaration
union<TCompare>(second: T[], compareSelector: (element: T) => TCompare): IEnumerable<T>;
Parameters
Type Name Description
T[] second
(element: T) => TCompare compareSelector
Returns
Type Description
Enumerable.IEnumerable<T>
Type Parameters
Name Description
TCompare

weightedSample(weightSelector)

Declaration
weightedSample(weightSelector: (element: T) => number): IEnumerable<T>;
Parameters
Type Name Description
(element: T) => number weightSelector
Returns
Type Description
Enumerable.IEnumerable<T>

where(predicate)

Declaration
where(predicate: (element: T, index: number) => boolean): IEnumerable<T>;
Parameters
Type Name Description
(element: T, index: number) => boolean predicate
Returns
Type Description
Enumerable.IEnumerable<T>

write(separator)

Declaration
write(separator?: string): void;
Parameters
Type Name Description
string separator
Returns
Type Description
void

write(separator, selector)

Declaration
write<TResult>(separator: string, selector: (element: T) => TResult): void;
Parameters
Type Name Description
string separator
(element: T) => TResult selector
Returns
Type Description
void
Type Parameters
Name Description
TResult

writeLine()

Declaration
writeLine(): void;
Returns
Type Description
void

writeLine(selector)

Declaration
writeLine<TResult>(selector: (element: T) => TResult): void;
Parameters
Type Name Description
(element: T) => TResult selector
Returns
Type Description
void
Type Parameters
Name Description
TResult

zip(second, resultSelector)

Declaration
zip<TResult>(second: IEnumerable<T>, resultSelector: (first: T, second: T, index: number) => TResult): IEnumerable<TResult>;
Parameters
Type Name Description
Enumerable.IEnumerable<T> second
(first: T, second: T, index: number) => TResult resultSelector
Returns
Type Description
Enumerable.IEnumerable<TResult>
Type Parameters
Name Description
TResult

zip(second, resultSelector)

Declaration
zip<TResult>(second: {
        [x: number]: T;
        length: number;
    }, resultSelector: (first: T, second: T, index: number) => TResult): IEnumerable<TResult>;
Parameters
Type Name Description
{ [x: number]: T; length: number; } second
(first: T, second: T, index: number) => TResult resultSelector
Returns
Type Description
Enumerable.IEnumerable<TResult>
Type Parameters
Name Description
TResult

zip(second, resultSelector)

Declaration
zip<TResult>(second: T[], resultSelector: (first: T, second: T, index: number) => TResult): IEnumerable<TResult>;
Parameters
Type Name Description
T[] second
(first: T, second: T, index: number) => TResult resultSelector
Returns
Type Description
Enumerable.IEnumerable<TResult>
Type Parameters
Name Description
TResult

zip(params)

Declaration
zip<TResult>(...params: any[]): IEnumerable<TResult>;
Parameters
Type Name Description
any[] params
Returns
Type Description
Enumerable.IEnumerable<TResult>
Type Parameters
Name Description
TResult
Was this page helpful?
Back to top Copyright © 2001–2025 Aurigma, Inc. All rights reserved.