Class List<TSource>

Interface that exposes an iterator, which supports a simple iteration and various methods.

Typeparam

TSource The type of elements in the IEnumerable.

Type Parameters

TSource

Hierarchy (View Summary)

ArrayEnumerable<TSource>
- List

Implements

IList<TSource>

Index

Constructors

constructor

new List<TSource>(): List<TSource>
Type Parameters
- TSource
Returns List<TSource>
Overrides ArrayEnumerable.constructor
- Defined in collections/List.ts:9
new List<TSource>(collection: Iterable<TSource>): List<TSource>
Type Parameters
- TSource
Parameters
- collection: Iterable<TSource>
Returns List<TSource>
Overrides ArrayEnumerable<TSource>.constructor
- Defined in collections/List.ts:11

Accessors

length

get length(): number
Returns number
Implementation of IList.length
- Defined in collections/List.ts:42

Methods

[iterator]

"[iterator]"(): Generator<TSource>
Exposes an iterator that can be used for iteration.

Returns Generator<TSource>
The iterator for the IEnumerable.
Example
```
const numbers = from([1, 2, 3]);
for (const number of numbers) {
  // Iteration is allowed because of the iterator.
}
```
Implementation of IList.[iterator]
Inherited from ArrayEnumerable.[iterator]
- Defined in enumerables/BasicEnumerable.ts:94

add

add(item: TSource): void
Parameters
- item: TSource
Returns void
Implementation of IList.add
- Defined in collections/List.ts:46

addRange

addRange(collection: Iterable<TSource>): void
Parameters
- collection: Iterable<TSource>
Returns void
Implementation of IList.addRange
- Defined in collections/List.ts:50

aggregate

aggregate(
aggregator: (prev: TSource, curr: TSource, index: number) => TSource,
): TSource
Applies an accumulator function over a sequence.
Parameters
- aggregator: (prev: TSource, curr: TSource, index: number) => TSource
  An accumulator function to be invoked on each element.
Returns TSource
The final accumulator value.
Example
```
const items = [1, 2, 3];
const sum = from(items)
  .aggregate((prev, curr) => prev + curr); // sum will be 6
```
Implementation of IList.aggregate
Inherited from ArrayEnumerable.aggregate
- Defined in enumerables/BasicEnumerable.ts:109
aggregate<TAccumulate>(
    seed: TAccumulate,
    aggregator: (
        prev: TAccumulate,
        curr: TSource,
        index: number,
    ) => TAccumulate,
): TAccumulate
Applies an accumulator function over a sequence. The specified seed value is used as the initial accumulator value.
Type Parameters
- TAccumulate
Parameters
- seed: TAccumulate
  The initial accumulator value.
- aggregator: (prev: TAccumulate, curr: TSource, index: number) => TAccumulate
  An accumulator function to be invoked on each element.
Returns TAccumulate
The final accumulator value.
Example
```
const items = [1, 2, 3];
const sum = from(items)
  .aggregate(10, (prev, curr) => prev + curr); // sum will be 16
```
Typeparam
TAccumulate The type of the accumulator value.
Implementation of IList.aggregate
Inherited from ArrayEnumerable.aggregate
- Defined in enumerables/BasicEnumerable.ts:124
aggregate<TAccumulate, TResult>(
    seed: TAccumulate,
    aggregator: (
        prev: TAccumulate,
        curr: TSource,
        index: number,
    ) => TAccumulate,
    resultSelector: (accumulated: TAccumulate) => TResult,
): TResult
Applies an accumulator function over a sequence. The specified seed value is used as the initial accumulator value, and the specified function is used to select the result value.
Type Parameters
- TAccumulate
- TResult
Parameters
- seed: TAccumulate
  The initial accumulator value.
- aggregator: (prev: TAccumulate, curr: TSource, index: number) => TAccumulate
  An accumulator function to be invoked on each element.
- resultSelector: (accumulated: TAccumulate) => TResult
  An accumulator function to be invoked on each element.
Returns TResult
The final accumulator value.
Example
```
const items = [1, 2, 3];
const sum = from(items)
  .aggregate(10, (prev, curr) => prev + curr, result => ({ result })); // sum will be { result: 16 }
```
Typeparam
TAccumulate The type of the accumulator value.

Typeparam
TResult The type of the resulting value.
Implementation of IList.aggregate
Inherited from ArrayEnumerable.aggregate
- Defined in enumerables/BasicEnumerable.ts:145

all

all(predicate: (item: TSource, index: number) => boolean): boolean
Determines whether all elements of a sequence satisfy a condition.
Parameters
- predicate: (item: TSource, index: number) => boolean
  A function to test each element for a condition.
Returns boolean
true if every element of the source sequence passes the test in the specified predicate, or if the sequence is empty; otherwise, false.
Example
```
const numbers = [1, 2, 3, 4];
const areAllNumbersEven = from(numbers).all(x => x % 2 === 0); // false
```
Implementation of IList.all
Inherited from ArrayEnumerable.all
- Defined in enumerables/ArrayEnumerable.ts:22

any

any(): boolean
Determines whether any element of a sequence exists or satisfies a condition.

Returns boolean
true if the source sequence contains any elements (or if at least one matches condition if condition is passed); otherwise, false.
Example
```
const numbers = [1, 2, 3, 4];
const areAnyNumbersEven = from(numbers).any(); // true
```
Implementation of IList.any
Inherited from ArrayEnumerable.any
- Defined in enumerables/ArrayEnumerable.ts:35
any(predicate: (item: TSource, index: number) => boolean): boolean
Determines whether any element of a sequence exists or satisfies a condition.
Parameters
- predicate: (item: TSource, index: number) => boolean
  A function to test each element for a condition.
Returns boolean
true if the source sequence contains any elements (or if at least one matches condition if condition is passed); otherwise, false.
Example
```
const numbers = [1, 2, 3, 4];
const areAnyNumbersEven = from(numbers).any(x => x % 2 === 0); // true
```
Implementation of IList.any
Inherited from ArrayEnumerable.any
- Defined in enumerables/ArrayEnumerable.ts:47

append

append(item: TSource): IEnumerable<TSource>
Appends a value to the end of the sequence.
Parameters
- item: TSource
  The value to append.
Returns IEnumerable<TSource>
A new sequence that ends with element.
Example
```
const numbers = [1, 2, 3, 4];
const withFive = from(numbers).append(5); // [1, 2, 3, 4, 5]
```
Implementation of IList.append
Inherited from ArrayEnumerable.append
- Defined in enumerables/BasicEnumerable.ts:212

asEnumerable

asEnumerable(): IEnumerable<TSource>
Returns the input as an IEnumerable.

Returns IEnumerable<TSource>
The input sequence as IEnumerable.
Example
```
const items = [1, 2, 3];
const asEnumerable = from(items).asEnumerable();
```
Implementation of IList.asEnumerable
Inherited from ArrayEnumerable.asEnumerable
- Defined in enumerables/BasicEnumerable.ts:225

assert

assert(
predicate: (item: TSource, index: number) => boolean,
): IEnumerable<TSource>
Tests a sequence with a given predicate. An error will be thrown if any element fails the sequence.
Parameters
- predicate: (item: TSource, index: number) => boolean
  A function to test each element for a condition. If false, an error will be thrown.
Returns IEnumerable<TSource>
A sequence with source elements in their original order.
Example
```
const items = [1, 2, '3'];
const sum = from(items).assert(x => typeof x === 'number').sum(); // throws due to '3'
```
Implementation of IList.assert
Inherited from ArrayEnumerable.assert
- Defined in enumerables/BasicEnumerable.ts:239
assert(
predicate: (item: TSource, index: number) => boolean,
message: string,
): IEnumerable<TSource>
Tests a sequence with a given predicate. An error will be thrown if any element fails the sequence.
Parameters
- predicate: (item: TSource, index: number) => boolean
  A function to test each element for a condition. If false, an error will be thrown.
- message: string
  The message to use for thrown errors.
Returns IEnumerable<TSource>
A sequence with source elements in their original order.
Example
```
const items = [1, 2, '3'];
const sum = from(items).assert(x => typeof x === 'number', 'Should be number').sum(); // throws due to '3'
```
Implementation of IList.assert
Inherited from ArrayEnumerable.assert
- Defined in enumerables/BasicEnumerable.ts:252
assert<TError extends Error>(
predicate: (item: TSource, index: number) => boolean,
errorType: new (message?: string) => TError,
): IEnumerable<TSource>
Tests a sequence with a given predicate. An error will be thrown if any element fails the sequence.
Type Parameters
- TError extends Error
Parameters
- predicate: (item: TSource, index: number) => boolean
  A function to test each element for a condition. If false, an error will be thrown.
- errorType: new (message?: string) => TError
  Type of error to throw.
Returns IEnumerable<TSource>
A sequence with source elements in their original order.
Example
```
class MyError extends Error {}
const items = [1, 2, '3'];
const sum = from(items).assert(x => typeof x === 'number', MyError).sum(); // throws instance of MyError due to '3'
```
Typeparam
TError The type of error to be thrown.
Implementation of IList.assert
Inherited from ArrayEnumerable.assert
- Defined in enumerables/BasicEnumerable.ts:267
assert<TError extends Error>(
    predicate: (item: TSource, index: number) => boolean,
    message: string,
    errorType: new (message?: string) => TError,
): IEnumerable<TSource>
Tests a sequence with a given predicate. An error will be thrown if any element fails the sequence.
Type Parameters
- TError extends Error
Parameters
- predicate: (item: TSource, index: number) => boolean
  A function to test each element for a condition. If false, an error will be thrown.
- message: string
  The message to use for thrown errors.
- errorType: new (message?: string) => TError
  Type of error to throw.
Returns IEnumerable<TSource>
A sequence with source elements in their original order.
Example
```
class MyError extends Error {}
const items = [1, 2, '3'];
const sum = from(items).assert(x => typeof x === 'number', 'Must be number', MyError).sum(); // throws instance of MyError with message due to '3'
```
Typeparam
TError The type of error to be thrown.
Implementation of IList.assert
Inherited from ArrayEnumerable.assert
- Defined in enumerables/BasicEnumerable.ts:286

atLeast

atLeast(count: number): boolean
Determines whether or not the number of elements in the sequence is greater than or equal to the given integer.
Parameters
- count: number
  The minimum number of items a sequence must have for this function to return true
Returns boolean
true if the number of elements in the sequence is greater than or equal to the given integer or false otherwise.
Example
```
const items = [1, 2, 3];
const atLeastThree = from(items).atLeast(3); // true
const atLeastFour = from(items).atLeast(4); // false
```
Implementation of IList.atLeast
Inherited from ArrayEnumerable.atLeast
- Defined in enumerables/BasicEnumerable.ts:311
atLeast(
count: number,
predicate: (item: TSource, index: number) => boolean,
): boolean
Determines whether or not the number of elements in the sequence is greater than or equal to the given integer.
Parameters
- count: number
  The minimum number of items a sequence must have for this function to return true
- predicate: (item: TSource, index: number) => boolean
  A function to test each element for a condition.
Returns boolean
true if the number of elements in the sequence is greater than or equal to the given integer or false otherwise.
Example
```
const items = [1, 2, 3];
const atLeastOneEven = from(items).atLeast(1, x => x % 2 === 0); // true
const atLeastTwoEven = from(items).atLeast(2, x => x % 2 === 0); // false
```
Implementation of IList.atLeast
Inherited from ArrayEnumerable.atLeast
- Defined in enumerables/BasicEnumerable.ts:325

atMost

atMost(count: number): boolean
Determines whether or not the number of elements in the sequence is lesser than or equal to the given integer.
Parameters
- count: number
  The maximun number of items a sequence must have for this function to return true.
Returns boolean
true if the number of elements in the sequence is lesser than or equal to the given integer or false otherwise.
Example
```
const items = [1, 2, 3];
const atMostTwo = from(items).atMost(2); // false
const atMostFour = from(items).atMost(4); // true
```
Implementation of IList.atMost
Inherited from ArrayEnumerable.atMost
- Defined in enumerables/BasicEnumerable.ts:342
atMost(
count: number,
predicate: (item: TSource, index: number) => boolean,
): boolean
Determines whether or not the number of elements that match the predicate in the sequence is lesser than or equal to the given integer.
Parameters
- count: number
  The maximun number of items a sequence must have for this function to return true.
- predicate: (item: TSource, index: number) => boolean
  The condition to match the elements by.
Returns boolean
true if the number of elements that match the predicate in the sequence is lesser than or equal to the given integer or false otherwise.
Example
```
const items = [1, 2, 3];
const atMostTwo = from(items).atMost(2, x => x > 0); // false
const atMostFour = from(items).atMost(4, x => x > 2); // true
```
Implementation of IList.atMost
Inherited from ArrayEnumerable.atMost
- Defined in enumerables/BasicEnumerable.ts:356

average

average(): number
Computes the average of a sequence of numeric values.

Returns number
The average of the sequence of values.
Example
```
const numbers = [2, 2, 1, 3];
const average = from(numbers).average(); // 2
```
Implementation of IList.average
Inherited from ArrayEnumerable.average
- Defined in enumerables/BasicEnumerable.ts:371
average(selector: (item: TSource) => number): number
Computes the average of a sequence of numeric values.
Parameters
- selector: (item: TSource) => number
  A transform function to apply to each element.
Returns number
The average of the sequence of values.
Example
```
const numbers = [{ age: 20 }, { age: 10 }, { age: 30 }];
const average = from(numbers).average(x => x.age); // 20
```
Implementation of IList.average
Inherited from ArrayEnumerable.average
- Defined in enumerables/BasicEnumerable.ts:383

chunk

chunk(chunkSize: number): IEnumerable<IEnumerable<TSource>>
Split the elements of a sequence into chunks of size at most chunkSize.
Parameters
- chunkSize: number
  The maximum size of each chunk.
Returns IEnumerable<IEnumerable<TSource>>
An IEnumerable that contains the elements the input sequence split into chunks of size chunkSize.
Example
```
const numbers = [1, 2, 3, 4, 5];
const chunks = from(numbers).chunk(2); // [[1, 2], [3, 4], [5]]
```
Implementation of IList.chunk
Inherited from ArrayEnumerable.chunk
- Defined in enumerables/BasicEnumerable.ts:399

clear

clear(): void
Returns void
Implementation of IList.clear
- Defined in collections/List.ts:54

concatenate

concatenate(collection: Iterable<TSource>): IEnumerable<TSource>
Concatenates two sequences.
Parameters
- collection: Iterable<TSource>
  The sequence to concatenate to the first sequence.
Returns IEnumerable<TSource>
An IEnumerable that contains the concatenated elements of the two input sequences.
Example
```
const numbers = [1, 2];
const moreNumbers = from(numbers).concatenate([3, 4, 5]); // [1, 2, 3, 4, 5]
```
Implementation of IList.concatenate
Inherited from ArrayEnumerable.concatenate
- Defined in enumerables/BasicEnumerable.ts:413
concatenate(...collections: Iterable<TSource>[]): IEnumerable<TSource>
Concatenates two or more sequences.
Parameters
- ...collections: Iterable<TSource>[]
  The sequences to concatenate to the first sequence.
Returns IEnumerable<TSource>
An IEnumerable that contains the concatenated elements of the two or more input sequences.
Example
```
const numbers = [1, 2];
const evenMoreNumbers = from(numbers).concatenate([3, 4], [5, 6]); // [1, 2, 3, 4, 5, 6]
```
Implementation of IList.concatenate
Inherited from ArrayEnumerable.concatenate
- Defined in enumerables/BasicEnumerable.ts:425

contains

contains(value: TSource): boolean
Determines whether a sequence contains a specified element.
Parameters
- value: TSource
  The value to locate in the sequence.
Returns boolean
true if the source sequence contains an element that has the specified value; otherwise, false.
Example
```
const numbers = [1, 2, 3];
const hasThree = from(numbers).contains(3); // true
```
Implementation of IList.contains
Inherited from ArrayEnumerable.contains
- Defined in enumerables/BasicEnumerable.ts:441
contains(value: TSource, equalityComparer: EqualityComparer<TSource>): boolean
Determines whether a sequence contains a specified element.
Parameters
- value: TSource
  The value to locate in the sequence.
- equalityComparer: EqualityComparer<TSource>
  An equality comparer to compare values.
Returns boolean
true if the source sequence contains an element that has the specified value; otherwise, false.
Example
```
const numbers = [1, 2, 3];
const hasThree = from(numbers).contains(3, (a, b) => a === b); // true
```
Implementation of IList.contains
Inherited from ArrayEnumerable.contains
- Defined in enumerables/BasicEnumerable.ts:454

copyTo

copyTo(array: TSource[]): void
Parameters
- array: TSource[]
Returns void
Implementation of IList.copyTo
- Defined in collections/List.ts:58
copyTo(array: TSource[], arrayIndex: number): void
Parameters
- array: TSource[]
- arrayIndex: number
Returns void
Implementation of IList.copyTo
- Defined in collections/List.ts:60
copyTo(index: number, array: TSource[], arrayIndex: number, count: number): void
Parameters
- index: number
- array: TSource[]
- arrayIndex: number
- count: number
Returns void
Implementation of IList.copyTo
- Defined in collections/List.ts:62

count

count(): number
Returns the number of elements in a sequence.

Returns number
The number of elements in the input sequence.
Example
```
const numbers = [1, 2, 3];
const numCount = from(numbers).count(); // 3
```
Implementation of IList.count
Inherited from ArrayEnumerable.count
- Defined in enumerables/ArrayEnumerable.ts:66
count(predicate: (item: TSource, index: number) => boolean): number
Returns the number of elements in a sequence.
Parameters
- predicate: (item: TSource, index: number) => boolean
  A function to test each element for a condition.
Returns number
The number of elements in the input sequence.
Example
```
const numbers = [1, 2, 3];
const evenNumCount = from(numbers).count(x => x % 2 === 0); // 1
```
Implementation of IList.count
Inherited from ArrayEnumerable.count
- Defined in enumerables/ArrayEnumerable.ts:78

defaultIfEmpty

defaultIfEmpty(defaultItem: TSource): IEnumerable<TSource>
Returns the elements of the specified sequence or the specified value in a singleton collection if the sequence is empty.
Parameters
- defaultItem: TSource
  The value to return if the sequence is empty.
Returns IEnumerable<TSource>
An IEnumerable that contains defaultValue if source is empty; otherwise, source.
Example
```
const defaultNum = 0;
const items = [];
const itemsWithDefault = from(items).defaultIfEmpty(defaultNum); // [0];
```
Implementation of IList.defaultIfEmpty
Inherited from ArrayEnumerable.defaultIfEmpty
- Defined in enumerables/BasicEnumerable.ts:498

distinct

distinct(): IEnumerable<TSource>
Returns distinct elements from a sequence.

Returns IEnumerable<TSource>
An IEnumerable that contains distinct elements from the source sequence.
Example
```
const items = [1, 2, 3, 1, 2];
const distinct = from(items).distinct(); // Will be [1, 2, 3]
```
Implementation of IList.distinct
Inherited from ArrayEnumerable.distinct
- Defined in enumerables/BasicEnumerable.ts:511
distinct(equalityComparer: EqualityComparer<TSource>): IEnumerable<TSource>
Returns distinct elements from a sequence.
Parameters
- equalityComparer: EqualityComparer<TSource>
  An EqualityComparer to compare values.
Returns IEnumerable<TSource>
An IEnumerable that contains distinct elements from the source sequence.
Example
```
const items = [{ name: 'bob' }, { name: 'Joe' }, { name: 'Bob' }];
const distinct = from(items).distinct((a, b) => a.name.toUpperCase() === b.name.toUpperCase()); // Will be [{ name: 'bob' }, { name: 'Joe' }]
```
Implementation of IList.distinct
Inherited from ArrayEnumerable.distinct
- Defined in enumerables/BasicEnumerable.ts:523

distinctBy

distinctBy<TKey>(keySelector: (item: TSource) => TKey): IEnumerable<TSource>
Returns distinct elements from a sequence according to a specified key selector function.
Type Parameters
- TKey
Parameters
- keySelector: (item: TSource) => TKey
  A function to extract the key for each element.
Returns IEnumerable<TSource>
An IEnumerable that contains distinct elements from the source sequence.
Example
```
const items = [{ name: 'bob', id: 1 }, { name: 'Joe', id: 2 }, { name: 'Bob', id: 3 }, { name: 'John', id: 2 }];
const distinct = from(items).distinctBy(x => x.id); // Will be [{ name: 'bob', id: 1 }, { name: 'Joe', id: 2 }, { name: 'Bob', id: 3 }]
```
Typeparam
TKey The type of key to distinguish elements by.
Implementation of IList.distinctBy
Inherited from ArrayEnumerable.distinctBy
- Defined in enumerables/BasicEnumerable.ts:540
distinctBy<TKey>(
keySelector: (item: TSource) => TKey,
equalityComparer: EqualityComparer<TKey>,
): IEnumerable<TSource>
Returns distinct elements from a sequence according to a specified key selector function.
Type Parameters
- TKey
Parameters
- keySelector: (item: TSource) => TKey
  A function to extract the key for each element.
- equalityComparer: EqualityComparer<TKey>
  An EqualityComparer to compare values.
Returns IEnumerable<TSource>
An IEnumerable that contains distinct elements from the source sequence.
Example
```
const items = [{ name: 'bob', id: 1 }, { name: 'Joe', id: 2 }, { name: 'Bob', id: 3 }, { name: 'John', id: 2 }];
const distinct = from(items).distinctBy(x => x.id, (a, b) => a === b); // Will be [{ name: 'bob', id: 1 }, { name: 'Joe', id: 2 }, { name: 'Bob', id: 3 }]
```
Typeparam
TKey The type of key to distinguish elements by.
Implementation of IList.distinctBy
Inherited from ArrayEnumerable.distinctBy
- Defined in enumerables/BasicEnumerable.ts:554

elementAt

elementAt(index: number): TSource
Returns the element at a specified index in a sequence or throws if the index is out of range. A negative index can be used to get element starting from the end.
Parameters
- index: number
  The zero-based index of the element to retrieve.
Returns TSource
The element at the specified position in the source sequence.
Example
```
const items = [1, 2, 3];
const indexZero = from(items).elementAt(0); // Will be 1
const willBeNull = from(items).elementAt(10); // Will throw.
const last = from(items).elementAt(-1); // 3
```
Implementation of IList.elementAt
Inherited from ArrayEnumerable.elementAt
- Defined in enumerables/BasicEnumerable.ts:579

elementAtOrDefault

elementAtOrDefault(index: number): null | TSource
Returns the element at a specified index in a sequence or null if the index is out of range. A negative index can be used to get element starting from the end.
Parameters
- index: number
  The zero-based index of the element to retrieve.
Returns null | TSource
The element at the specified position in the source sequence.
Example
```
const items = [1, 2, 3];
const indexZero = from(items).elementAtOrDefault(0); // Will be 1
const willBeNull = from(items).elementAtOrDefault(10); // Will be null.
const last = from(items).elementAtOrDefault(-1); // 3
```
Implementation of IList.elementAtOrDefault
Inherited from ArrayEnumerable.elementAtOrDefault
- Defined in enumerables/ArrayEnumerable.ts:101

endsWith

endsWith(second: Iterable<TSource>): boolean
Determines whether the end of the first sequence is equivalent to the second sequence.
Parameters
- second: Iterable<TSource>
  The sequence to compare to.
Returns boolean
true if first ends with elements equivalent to second.
Example
```
const items = [1, 2, 3];
const endsWith = from(items).endsWith([2, 3]); // true
const doesNotEndWith = from(items).endsWith([3, 2]); // false
```
Implementation of IList.endsWith
Inherited from ArrayEnumerable.endsWith
- Defined in enumerables/BasicEnumerable.ts:611
endsWith(
second: Iterable<TSource>,
equalityComparer: EqualityComparer<TSource>,
): boolean
Determines whether the end of the first sequence is equivalent to the second sequence, using the specified element equality comparer.
Parameters
- second: Iterable<TSource>
  The sequence to compare to.
- equalityComparer: EqualityComparer<TSource>
  Equality comparer to use.
Returns boolean
true if first ends with elements equivalent to second.
Example
```
const items = [1, 2, 3];
const endsWith = from(items).endsWith([2, 3], (a, b) => a === b); // true
const doesNotEndWith = from(items).endsWith([3, 2], (a, b) => a === b); // false
```
Implementation of IList.endsWith
Inherited from ArrayEnumerable.endsWith
- Defined in enumerables/BasicEnumerable.ts:625

except

except(second: Iterable<TSource>): IEnumerable<TSource>
Produces the set difference of two sequences.
Parameters
- second: Iterable<TSource>
  An Iterable whose elements that also occur in the first sequence will cause those elements to be removed from the returned sequence.
Returns IEnumerable<TSource>
A sequence that contains the set difference of the elements of two sequences.
Example
```
const items = [1, 2, 3, 4];
const exceptItems = from(items).except([2, 4]); // [1, 3]
```
Implementation of IList.except
Inherited from ArrayEnumerable.except
- Defined in enumerables/BasicEnumerable.ts:641
except(...second: Iterable<TSource>[]): IEnumerable<TSource>
Produces the set difference of two sequences.
Parameters
- ...second: Iterable<TSource>[]
  An Iterable whose elements that also occur in the first sequence will cause those elements to be removed from the returned sequence.
Returns IEnumerable<TSource>
A sequence that contains the set difference of the elements of two sequences.
Example
```
const items = [1, 2, 3, 4];
const exceptItems = from(items).except([2, 4], [3, 4]); // [1]
```
Implementation of IList.except
Inherited from ArrayEnumerable.except
- Defined in enumerables/BasicEnumerable.ts:653
except(
second: Iterable<TSource>,
equalityComparer: EqualityComparer<TSource>,
): IEnumerable<TSource>
Produces the set difference of two sequences.
Parameters
- second: Iterable<TSource>
  An Iterable whose elements that also occur in the first sequence will cause those elements to be removed from the returned sequence.
- equalityComparer: EqualityComparer<TSource>
  An EqualityComparer to compare values.
Returns IEnumerable<TSource>
A sequence that contains the set difference of the elements of two sequences.
Example
```
const items = [1, 2, 3, 4];
const exceptItems = from(items).except([2, 4], (a, b) => a === b); // [1, 3]
```
Implementation of IList.except
Inherited from ArrayEnumerable.except
- Defined in enumerables/BasicEnumerable.ts:666
except(
    second: Iterable<TSource>,
    third: Iterable<TSource>,
    equalityComparer: EqualityComparer<TSource>,
): IEnumerable<TSource>
Produces the set difference of two sequences.
Parameters
- second: Iterable<TSource>
  An Iterable whose elements that also occur in the first sequence will cause those elements to be removed from the returned sequence.
- third: Iterable<TSource>
  An Iterable whose elements that also occur in the first sequence will cause those elements to be removed from the returned sequence.
- equalityComparer: EqualityComparer<TSource>
  An EqualityComparer to compare values.
Returns IEnumerable<TSource>
A sequence that contains the set difference of the elements of two sequences.
Example
```
const items = [1, 2, 3, 4];
const exceptItems = from(items).except([2, 4], [3], (a, b) => a === b); // [1]
```
Implementation of IList.except
Inherited from ArrayEnumerable.except
- Defined in enumerables/BasicEnumerable.ts:680
except(
    second: Iterable<TSource>,
    third: Iterable<TSource>,
    fourth: Iterable<TSource>,
    equalityComparer: EqualityComparer<TSource>,
): IEnumerable<TSource>
Produces the set difference of two sequences.
Parameters
- second: Iterable<TSource>
  An Iterable whose elements that also occur in the first sequence will cause those elements to be removed from the returned sequence.
- third: Iterable<TSource>
  An Iterable whose elements that also occur in the first sequence will cause those elements to be removed from the returned sequence.
- fourth: Iterable<TSource>
  An Iterable whose elements that also occur in the first sequence will cause those elements to be removed from the returned sequence.
- equalityComparer: EqualityComparer<TSource>
  An EqualityComparer to compare values.
Returns IEnumerable<TSource>
A sequence that contains the set difference of the elements of two sequences.
Example
```
const items = [1, 2, 3, 4, 5, 6, 7];
const exceptItems = from(items).except([2, 4], [3, 5], [7], (a, b) => a === b); // [1, 6]
```
Implementation of IList.except
Inherited from ArrayEnumerable.except
- Defined in enumerables/BasicEnumerable.ts:699

exceptBy

exceptBy<TKey>(
second: Iterable<TKey>,
keySelector: (item: TSource) => TKey,
): IEnumerable<TSource>
Produces the set difference of two sequences according to a specified key selector function.
Type Parameters
- TKey
Parameters
- second: Iterable<TKey>
  An Iterable whose keys that also occur in the first sequence will cause those elements to be removed from the returned sequence.
- keySelector: (item: TSource) => TKey
  A function to extract the key for each element.
Returns IEnumerable<TSource>
A sequence that contains the set difference of the elements of two sequences.

Typeparam
TKey The type of key to identify elements by.
Implementation of IList.exceptBy
Inherited from ArrayEnumerable.exceptBy
- Defined in enumerables/BasicEnumerable.ts:717
exceptBy<TKey>(
    second: Iterable<TKey>,
    third: Iterable<TKey>,
    keySelector: (item: TSource) => TKey,
): IEnumerable<TSource>
Produces the set difference of two sequences according to a specified key selector function.
Type Parameters
- TKey
Parameters
- second: Iterable<TKey>
  An Iterable whose keys that also occur in the first sequence will cause those elements to be removed from the returned sequence.
- third: Iterable<TKey>
  An Iterable whose keys that also occur in the first sequence will cause those elements to be removed from the returned sequence.
- keySelector: (item: TSource) => TKey
  A function to extract the key for each element.
Returns IEnumerable<TSource>
A sequence that contains the set difference of the elements of two sequences.

Typeparam
TKey The type of key to identify elements by.
Implementation of IList.exceptBy
Inherited from ArrayEnumerable.exceptBy
- Defined in enumerables/BasicEnumerable.ts:727
exceptBy<TKey>(
    second: Iterable<TKey>,
    third: Iterable<TKey>,
    fourth: Iterable<TKey>,
    keySelector: (item: TSource) => TKey,
): IEnumerable<TSource>
Produces the set difference of two sequences according to a specified key selector function.
Type Parameters
- TKey
Parameters
- second: Iterable<TKey>
  An Iterable whose keys that also occur in the first sequence will cause those elements to be removed from the returned sequence.
- third: Iterable<TKey>
  An Iterable whose keys that also occur in the first sequence will cause those elements to be removed from the returned sequence.
- fourth: Iterable<TKey>
  An Iterable whose keys that also occur in the first sequence will cause those elements to be removed from the returned sequence.
- keySelector: (item: TSource) => TKey
  A function to extract the key for each element.
Returns IEnumerable<TSource>
A sequence that contains the set difference of the elements of two sequences.

Typeparam
TKey The type of key to identify elements by.
Implementation of IList.exceptBy
Inherited from ArrayEnumerable.exceptBy
- Defined in enumerables/BasicEnumerable.ts:742
exceptBy<TKey>(
    second: Iterable<TKey>,
    keySelector: (item: TSource) => TKey,
    equalityComparer: EqualityComparer<TKey>,
): IEnumerable<TSource>
Produces the set difference of two sequences according to a specified key selector function.
Type Parameters
- TKey
Parameters
- second: Iterable<TKey>
  An Iterable whose keys that also occur in the first sequence will cause those elements to be removed from the returned sequence.
- keySelector: (item: TSource) => TKey
  A function to extract the key for each element.
- equalityComparer: EqualityComparer<TKey>
  An EqualityComparer to compare values.
Returns IEnumerable<TSource>
A sequence that contains the set difference of the elements of two sequences.

Typeparam
TKey The type of key to identify elements by.
Implementation of IList.exceptBy
Inherited from ArrayEnumerable.exceptBy
- Defined in enumerables/BasicEnumerable.ts:757
exceptBy<TKey>(
    second: Iterable<TKey>,
    thrid: Iterable<TKey>,
    keySelector: (item: TSource) => TKey,
    equalityComparer: EqualityComparer<TKey>,
): IEnumerable<TSource>
Produces the set difference of two sequences according to a specified key selector function.
Type Parameters
- TKey
Parameters
- second: Iterable<TKey>
  An Iterable whose keys that also occur in the first sequence will cause those elements to be removed from the returned sequence.
- thrid: Iterable<TKey>
- keySelector: (item: TSource) => TKey
  A function to extract the key for each element.
- equalityComparer: EqualityComparer<TKey>
  An EqualityComparer to compare values.
Returns IEnumerable<TSource>
A sequence that contains the set difference of the elements of two sequences.

Typeparam
TKey The type of key to identify elements by.
Implementation of IList.exceptBy
Inherited from ArrayEnumerable.exceptBy
- Defined in enumerables/BasicEnumerable.ts:772
exceptBy<TKey>(
    second: Iterable<TKey>,
    thrid: Iterable<TKey>,
    fourth: Iterable<TKey>,
    keySelector: (item: TSource) => TKey,
    equalityComparer: EqualityComparer<TKey>,
): IEnumerable<TSource>
Produces the set difference of two sequences according to a specified key selector function.
Type Parameters
- TKey
Parameters
- second: Iterable<TKey>
  An Iterable whose keys that also occur in the first sequence will cause those elements to be removed from the returned sequence.
- thrid: Iterable<TKey>
- fourth: Iterable<TKey>
  An Iterable whose keys that also occur in the first sequence will cause those elements to be removed from the returned sequence.
- keySelector: (item: TSource) => TKey
  A function to extract the key for each element.
- equalityComparer: EqualityComparer<TKey>
  An EqualityComparer to compare values.
Returns IEnumerable<TSource>
A sequence that contains the set difference of the elements of two sequences.

Typeparam
TKey The type of key to identify elements by.
Implementation of IList.exceptBy
Inherited from ArrayEnumerable.exceptBy
- Defined in enumerables/BasicEnumerable.ts:789

findIndex

findIndex(predicate: (item: TSource, index: number) => boolean): number
Parameters
- predicate: (item: TSource, index: number) => boolean
Returns number
Implementation of IList.findIndex
- Defined in collections/List.ts:104
findIndex(
startIndex: number,
predicate: (item: TSource, index: number) => boolean,
): number
Parameters
- startIndex: number
- predicate: (item: TSource, index: number) => boolean
Returns number
Implementation of IList.findIndex
- Defined in collections/List.ts:106
findIndex(
    startIndex: number,
    count: number,
    predicate: (item: TSource, index: number) => boolean,
): number
Parameters
- startIndex: number
- count: number
- predicate: (item: TSource, index: number) => boolean
Returns number
Implementation of IList.findIndex
- Defined in collections/List.ts:108

first

first(): TSource
Returns the first element in a sequence. Throws if sequence contains no elements.

Returns TSource
The first element in the sequence.
Implementation of IList.first
Inherited from ArrayEnumerable.first
- Defined in enumerables/BasicEnumerable.ts:807
first(predicate: (item: TSource, index: number) => boolean): TSource
Returns the first element in a sequence that satisfies a specified condition. Throws if sequence contains no elements that matches condition.
Parameters
- predicate: (item: TSource, index: number) => boolean
  A function to test each element for a condition.
Returns TSource
The first element in the sequence that passes the test in the specified predicate function.
Implementation of IList.first
Inherited from ArrayEnumerable.first
- Defined in enumerables/BasicEnumerable.ts:814

firstOrDefault

firstOrDefault(): null | TSource
Returns the first element in a sequence. Returns null if sequence contains no elements.

Returns null | TSource
The first element in the sequence or null.
Implementation of IList.firstOrDefault
Inherited from ArrayEnumerable.firstOrDefault
- Defined in enumerables/BasicEnumerable.ts:824
firstOrDefault(
predicate: (item: TSource, index: number) => boolean,
): null | TSource
Returns the first element in a sequence that satisfies a specified condition. Returns null if sequence contains no elements that matches condition.
Parameters
- predicate: (item: TSource, index: number) => boolean
  A function to test each element for a condition.
Returns null | TSource
The first element in the sequence that passes the test in the specified predicate function or null.
Implementation of IList.firstOrDefault
Inherited from ArrayEnumerable.firstOrDefault
- Defined in enumerables/BasicEnumerable.ts:831

flatten

flatten(): IEnumerable<TSource extends Iterable<InnerItr> ? InnerItr : TSource>
Returns a new IEnumerable with all sub-iterable elements concatenated into it one level deep.

Returns IEnumerable<TSource extends Iterable<InnerItr> ? InnerItr : TSource>
A new IEnumerable with all sub-iterable elements concatenated into it recursively up.
Example
```
const items = [1, 2, [3, 4, [5, []]]];
const res = from(items).flatten(); // [1, 2, 3, 4, [5, []]]
```
Implementation of IList.flatten
Inherited from ArrayEnumerable.flatten
- Defined in enumerables/BasicEnumerable.ts:846
flatten<Depth extends number>(
depth: Depth,
): IEnumerable<FlatIterable<Iterable<TSource>, Depth>>
Returns a new IEnumerable with all sub-iterable elements concatenated into it recursively up to the specified depth.
Type Parameters
- Depth extends number
Parameters
- depth: Depth
  The depth to flatten to.
Returns IEnumerable<FlatIterable<Iterable<TSource>, Depth>>
A new IEnumerable with all sub-iterable elements concatenated into it recursively up.
Example
```
const items = [1, 2, [3, 4, [5, []]]];
const res = from(items).flatten(3); // [1, 2, 3, 4, 5]
```
Implementation of IList.flatten
Inherited from ArrayEnumerable.flatten
- Defined in enumerables/BasicEnumerable.ts:858

forEach

forEach(callback: (item: TSource, index: number) => void): void
Iterates the sequence and calls an action on each element.
Parameters
- callback: (item: TSource, index: number) => void
Returns void
Implementation of IList.forEach
Inherited from ArrayEnumerable.forEach
- Defined in enumerables/BasicEnumerable.ts:868

fullJoinHeterogeneous

fullJoinHeterogeneous<TSecond, TKey, TResult>(
    second: Iterable<TSecond>,
    firstKeySelector: (item: TSource) => TKey,
    secondKeySelector: (item: TSecond) => TKey,
    firstSelector: (item: TSource) => TResult,
    secondSelector: (item: TSecond) => TResult,
    bothSelector: (a: TSource, b: TSecond) => TResult,
): IEnumerable<TResult>
Performs a full outer join on two heterogeneous sequences. Additional arguments specify key selection functions, result projection functions and a key comparer.
Type Parameters
- TSecond
- TKey
- TResult
Parameters
- second: Iterable<TSecond>
  The second sequence of the join operation.
- firstKeySelector: (item: TSource) => TKey
  Function that projects the key given an element from first.
- secondKeySelector: (item: TSecond) => TKey
  Function that projects the key given an element from second.
- firstSelector: (item: TSource) => TResult
- secondSelector: (item: TSecond) => TResult
  Function that projects the result given just an element from second where there is no corresponding element in first.
- bothSelector: (a: TSource, b: TSecond) => TResult
  Function that projects the result given an element from first and an element from second that match on a common key.
Returns IEnumerable<TResult>
A sequence containing results projected from a right outer join of the two input sequences.

Typeparam
TSecond The type of elements in the second sequence.

Typeparam
TKey The type of the key returned by the key selector functions.

Typeparam
TResult The type of the result elements.
Implementation of IList.fullJoinHeterogeneous
Inherited from ArrayEnumerable.fullJoinHeterogeneous
- Defined in enumerables/BasicEnumerable.ts:886
fullJoinHeterogeneous<TSecond, TKey, TResult>(
    second: Iterable<TSecond>,
    firstKeySelector: (item: TSource) => TKey,
    secondKeySelector: (item: TSecond) => TKey,
    firstSelector: (item: TSource) => TResult,
    secondSelector: (item: TSecond) => TResult,
    bothSelector: (a: TSource, b: TSecond) => TResult,
    equalityComparer: EqualityComparer<TKey>,
): IEnumerable<TResult>
Performs a full outer join on two heterogeneous sequences. Additional arguments specify key selection functions, result projection functions and a key comparer.
Type Parameters
- TSecond
- TKey
- TResult
Parameters
- second: Iterable<TSecond>
  The second sequence of the join operation.
- firstKeySelector: (item: TSource) => TKey
  Function that projects the key given an element from first.
- secondKeySelector: (item: TSecond) => TKey
  Function that projects the key given an element from second.
- firstSelector: (item: TSource) => TResult
- secondSelector: (item: TSecond) => TResult
  Function that projects the result given just an element from second where there is no corresponding element in first.
- bothSelector: (a: TSource, b: TSecond) => TResult
  Function that projects the result given an element from first and an element from second that match on a common key.
- equalityComparer: EqualityComparer<TKey>
  A function to compare keys.
Returns IEnumerable<TResult>
A sequence containing results projected from a right outer join of the two input sequences.

Typeparam
TSecond The type of elements in the second sequence.

Typeparam
TKey The type of the key returned by the key selector functions.

Typeparam
TResult The type of the result elements.
Implementation of IList.fullJoinHeterogeneous
Inherited from ArrayEnumerable.fullJoinHeterogeneous
- Defined in enumerables/BasicEnumerable.ts:910

fullJoinHomogeneous

fullJoinHomogeneous<TKey, TResult>(
    second: Iterable<TSource>,
    keySelector: (item: TSource) => TKey,
    firstSelector: (item: TSource) => TResult,
    secondSelector: (item: TSource) => TResult,
    bothSelector: (a: TSource, b: TSource) => TResult,
): IEnumerable<TResult>
Performs a full outer join on two homogeneous sequences. Additional arguments specify key selection functions and result projection functions.
Type Parameters
- TKey
- TResult
Parameters
- second: Iterable<TSource>
  The second sequence of the join operation.
- keySelector: (item: TSource) => TKey
  Function that projects the key given an element of one of the sequences to join.
- firstSelector: (item: TSource) => TResult
  Function that projects the result given just an element from first where there is no corresponding element in second.
- secondSelector: (item: TSource) => TResult
  Function that projects the result given just an element from second where there is no corresponding element in first.
- bothSelector: (a: TSource, b: TSource) => TResult
  Function that projects the result given an element from first and an element from second that match on a common key.
Returns IEnumerable<TResult>
A sequence containing results projected from a full outer join of the two input sequences.

Typeparam
TKey The type of the key returned by the key selector functions.

Typeparam
TResult The type of the result elements.
Implementation of IList.fullJoinHomogeneous
Inherited from ArrayEnumerable.fullJoinHomogeneous
- Defined in enumerables/BasicEnumerable.ts:954
fullJoinHomogeneous<TKey, TResult>(
    second: Iterable<TSource>,
    keySelector: (item: TSource) => TKey,
    firstSelector: (item: TSource) => TResult,
    secondSelector: (item: TSource) => TResult,
    bothSelector: (a: TSource, b: TSource) => TResult,
    equalityComparer: EqualityComparer<TKey>,
): IEnumerable<TResult>
Performs a full outer join on two homogeneous sequences. Additional arguments specify key selection functions and result projection functions.
Type Parameters
- TKey
- TResult
Parameters
- second: Iterable<TSource>
  The second sequence of the join operation.
- keySelector: (item: TSource) => TKey
  Function that projects the key given an element of one of the sequences to join.
- firstSelector: (item: TSource) => TResult
  Function that projects the result given just an element from first where there is no corresponding element in second.
- secondSelector: (item: TSource) => TResult
  Function that projects the result given just an element from second where there is no corresponding element in first.
- bothSelector: (a: TSource, b: TSource) => TResult
  Function that projects the result given an element from first and an element from second that match on a common key.
- equalityComparer: EqualityComparer<TKey>
  A function to compare keys.
Returns IEnumerable<TResult>
A sequence containing results projected from a full outer join of the two input sequences.

Typeparam
TKey The type of the key returned by the key selector functions.

Typeparam
TResult The type of the result elements.
Implementation of IList.fullJoinHomogeneous
Inherited from ArrayEnumerable.fullJoinHomogeneous
- Defined in enumerables/BasicEnumerable.ts:975

groupBy

groupBy<TKey>(
keySelector: (item: TSource) => TKey,
): IEnumerable<IGrouping<TKey, TSource>>
Groups the elements of a sequence according to a specified key selector function.
Type Parameters
- TKey
Parameters
- keySelector: (item: TSource) => TKey
  A function to extract the key for each element.
Returns IEnumerable<IGrouping<TKey, TSource>>
An IEnumerable<IGrouping<TKey, TSource>> where each IGrouping<TKey, TSource> object contains a sequence of objects and a key.

Typeparam
TKey The type of the key returned by keySelector.
Implementation of IList.groupBy
Inherited from ArrayEnumerable.groupBy
- Defined in enumerables/BasicEnumerable.ts:1010
groupBy<TKey>(
keySelector: (item: TSource) => TKey,
equalityComparer: EqualityComparer<TKey>,
): IEnumerable<IGrouping<TKey, TSource>>
Groups the elements of a sequence according to a specified key selector function.
Type Parameters
- TKey
Parameters
- keySelector: (item: TSource) => TKey
  A function to extract the key for each element.
- equalityComparer: EqualityComparer<TKey>
  A function to compare keys.
Returns IEnumerable<IGrouping<TKey, TSource>>
An IEnumerable<IGrouping<TKey, TSource>> where each IGrouping<TKey, TSource> object contains a sequence of objects and a key.

Typeparam
TKey The type of the key returned by keySelector.
Implementation of IList.groupBy
Inherited from ArrayEnumerable.groupBy
- Defined in enumerables/BasicEnumerable.ts:1019

groupJoin

groupJoin<TInner, TKey, TResult>(
    inner: Iterable<TInner>,
    outerKeySelector: (item: TSource) => TKey,
    innerKeySelector: (item: TInner) => TKey,
    resultSelector: (item: TSource, inner: IEnumerable<TInner>) => TResult,
): IEnumerable<TResult>

Correlates the elements of two sequences based on key equality, and groups the results.

Type Parameters

TInner
TKey
TResult

Parameters

inner: Iterable<TInner>
The sequence to join to the first sequence.
outerKeySelector: (item: TSource) => TKey
A function to extract the join key from each element of the first sequence.
innerKeySelector: (item: TInner) => TKey
A function to extract the join key from each element of the second sequence.
resultSelector: (item: TSource, inner: IEnumerable<TInner>) => TResult
A function to create a result element from an element from the first sequence and a collection of matching elements from the second sequence.

Returns IEnumerable<TResult>

Example

const magnus = { name: 'Magnus' };
const terry = { name: 'Terry' };
const adam = { name: 'Adam' };
const john = { name: 'John' };

const barley = { name: 'Barley', owner: terry };
const boots = { name: 'Boots', owner: terry };
const whiskers = { name: 'Whiskers', owner: adam };
const daisy = { name: 'Daisy', owner: magnus };
const scratchy = { name: 'Scratchy', owner: { name: 'Bob' } };

const people = from([magnus, terry, adam, john]);
const pets = from([barley, boots, whiskers, daisy, scratchy]);

const result = people
  .groupJoin(
    pets,
    person => person,
    pet => pet.owner,
    (person, petCollection) => ({ ownerName: person.name, pets: petCollection.select(p => p.name).toArray() })
  )
  .toArray();

expect(result).toEqual([
  { ownerName: 'Magnus', pets: ['Daisy'] },
  { ownerName: 'Terry', pets: ['Barley', 'Boots'] },
  { ownerName: 'Adam', pets: ['Whiskers'] },
  { ownerName: 'John', pets: [] }
]);

Typeparam

TInner The type of the elements of the second sequence.

Typeparam

TKey The type of the keys returned by the key selector functions.

Typeparam

TResult The type of the result elements.

groupJoin<TInner, TKey, TResult>(
    inner: Iterable<TInner>,
    outerKeySelector: (item: TSource) => TKey,
    innerKeySelector: (item: TInner) => TKey,
    resultSelector: (item: TSource, inner: IEnumerable<TInner>) => TResult,
    equalityComparer: EqualityComparer<TKey>,
): IEnumerable<TResult>
Correlates the elements of two sequences based on key equality, and groups the results.
Type Parameters
- TInner
- TKey
- TResult
Parameters
- inner: Iterable<TInner>
  The sequence to join to the first sequence.
- outerKeySelector: (item: TSource) => TKey
  A function to extract the join key from each element of the first sequence.
- innerKeySelector: (item: TInner) => TKey
  A function to extract the join key from each element of the second sequence.
- resultSelector: (item: TSource, inner: IEnumerable<TInner>) => TResult
  A function to create a result element from an element from the first sequence and a collection of matching elements from the second sequence.
- equalityComparer: EqualityComparer<TKey>
  An IEnumerable that contains elements of type TResult that are obtained by performing a grouped join on two sequences.
Returns IEnumerable<TResult>
Example
```
const magnus = { name: 'Magnus' };
const terry = { name: 'Terry' };
const adam = { name: 'Adam' };
const john = { name: 'John' };

const barley = { name: 'Barley', owner: terry };
const boots = { name: 'Boots', owner: terry };
const whiskers = { name: 'Whiskers', owner: adam };
const daisy = { name: 'Daisy', owner: magnus };
const scratchy = { name: 'Scratchy', owner: { name: 'Bob' } };

const people = from([magnus, terry, adam, john]);
const pets = from([barley, boots, whiskers, daisy, scratchy]);

const result = people
  .groupJoin(
    pets,
    person => person,
    pet => pet.owner,
    (person, petCollection) => ({ ownerName: person.name, pets: petCollection.select(p => p.name).toArray() }),
    (person, pet) => person.name === pet.owner.name
  )
  .toArray();

expect(result).toEqual([
  { ownerName: 'Magnus', pets: ['Daisy'] },
  { ownerName: 'Terry', pets: ['Barley', 'Boots'] },
  { ownerName: 'Adam', pets: ['Whiskers'] },
  { ownerName: 'John', pets: [] }
]);
```
Typeparam
TInner The type of the elements of the second sequence.

Typeparam
TKey The type of the keys returned by the key selector functions.

Typeparam
TResult The type of the result elements.
Implementation of IList.groupJoin
Inherited from ArrayEnumerable.groupJoin
- Defined in enumerables/BasicEnumerable.ts:1124

indexOf

indexOf(item: TSource): number
Parameters
- item: TSource
Returns number
Implementation of IList.indexOf
- Defined in collections/List.ts:147
indexOf(item: TSource, index: number): number
Parameters
- item: TSource
- index: number
Returns number
Implementation of IList.indexOf
- Defined in collections/List.ts:149
indexOf(item: TSource, index: number, count: number): number
Parameters
- item: TSource
- index: number
- count: number
Returns number
Implementation of IList.indexOf
- Defined in collections/List.ts:151

innerJoin

innerJoin<TInner, TKey, TResult>(
    inner: Iterable<TInner>,
    outerKeySelector: (item: TSource) => TKey,
    innerKeySelector: (item: TInner) => TKey,
    resultSelector: (item: TSource, inner: TInner) => TResult,
): IEnumerable<TResult>
Performs an inner join by correlating the elements of two sequences based on matching keys.
Type Parameters
- TInner
- TKey
- TResult
Parameters
- inner: Iterable<TInner>
  The second sequence to join to the first.
- outerKeySelector: (item: TSource) => TKey
  A function to extract the join key from each element of the first sequence.
- innerKeySelector: (item: TInner) => TKey
  A function to extract the join key from each element of the second sequence.
- resultSelector: (item: TSource, inner: TInner) => TResult
  A function to create a result element from two matching elements.
Returns IEnumerable<TResult>
An IEnumerable that has elements of type TResult that are obtained by performing an inner join on two sequences.
Example
```
const magnus = { name: 'Magnus' };
const terry = { name: 'Terry' };
const adam = { name: 'Adam' };
const john = { name: 'John' };

const barley = { name: 'Barley', owner: terry };
const boots = { name: 'Boots', owner: terry };
const whiskers = { name: 'Whiskers', owner: adam };
const daisy = { name: 'Daisy', owner: magnus };
const scratchy = { name: 'Scratchy', owner: { name: 'Bob' } };

const people = from([magnus, terry, adam, john]);
const pets = from([barley, boots, whiskers, daisy, scratchy]);

const result = people.innerJoin(
    pets,
    person => person,
    pet => pet.owner,
    (person, pet) => ({ ownerName: person.name, pet: pet.name })
  )
  .toArray();

expect(result).toEqual([
  { ownerName: 'Magnus', pet: 'Daisy' },
  { ownerName: 'Terry', pet: 'Barley' },
  { ownerName: 'Terry', pet: 'Boots' },
  { ownerName: 'Adam', pet: 'Whiskers' }
]);
```
Typeparam
TInner The type of the elements of the second sequence.

Typeparam
TKey The type of the keys returned by the key selector functions.

Typeparam
TResult The type of the result elements.
Implementation of IList.innerJoin
Inherited from ArrayEnumerable.innerJoin
- Defined in enumerables/BasicEnumerable.ts:1192
innerJoin<TInner, TKey, TResult>(
    inner: Iterable<TInner>,
    outerKeySelector: (item: TSource) => TKey,
    innerKeySelector: (item: TInner) => TKey,
    resultSelector: (item: TSource, inner: TInner) => TResult,
    equalityComparer: EqualityComparer<TKey>,
): IEnumerable<TResult>
Performs an inner join by correlating the elements of two sequences based on matching keys.
Type Parameters
- TInner
- TKey
- TResult
Parameters
- inner: Iterable<TInner>
  The second sequence to join to the first.
- outerKeySelector: (item: TSource) => TKey
  A function to extract the join key from each element of the first sequence.
- innerKeySelector: (item: TInner) => TKey
  A function to extract the join key from each element of the second sequence.
- resultSelector: (item: TSource, inner: TInner) => TResult
  A function to create a result element from two matching elements.
- equalityComparer: EqualityComparer<TKey>
  A function to compare keys.
Returns IEnumerable<TResult>
An IEnumerable that has elements of type TResult that are obtained by performing an inner join on two sequences.
Example
```
const magnus = { name: 'Magnus' };
const terry = { name: 'Terry' };
const adam = { name: 'Adam' };
const john = { name: 'John' };

const barley = { name: 'Barley', owner: terry };
const boots = { name: 'Boots', owner: terry };
const whiskers = { name: 'Whiskers', owner: adam };
const daisy = { name: 'Daisy', owner: magnus };
const scratchy = { name: 'Scratchy', owner: { name: 'Bob' } };

const people = from([magnus, terry, adam, john]);
const pets = from([barley, boots, whiskers, daisy, scratchy]);

const result = people.innerJoin(
    pets,
    person => person,
    pet => pet.owner,
    (person, pet) => ({ ownerName: person.name, pet: pet.name }),
    (person, pet) => person.name === pet.owner.name
  )
  .toArray();

expect(result).toEqual([
  { ownerName: 'Magnus', pet: 'Daisy' },
  { ownerName: 'Terry', pet: 'Barley' },
  { ownerName: 'Terry', pet: 'Boots' },
  { ownerName: 'Adam', pet: 'Whiskers' }
]);
```
Typeparam
TInner The type of the elements of the second sequence.

Typeparam
TKey The type of the keys returned by the key selector functions.

Typeparam
TResult The type of the result elements.
Implementation of IList.innerJoin
Inherited from ArrayEnumerable.innerJoin
- Defined in enumerables/BasicEnumerable.ts:1243

insert

insert(index: number, item: TSource): void
Parameters
- index: number
- item: TSource
Returns void
Implementation of IList.insert
- Defined in collections/List.ts:166

insertRange

insertRange(index: number, collection: Iterable<TSource>): void
Parameters
- index: number
- collection: Iterable<TSource>
Returns void
Implementation of IList.insertRange
- Defined in collections/List.ts:174

intersect

intersect(second: Iterable<TSource>): IEnumerable<TSource>
Produces the set intersection of two sequences.
Parameters
- second: Iterable<TSource>
  An IEnumerable whose distinct elements that also appear in the first sequence will be returned.
Returns IEnumerable<TSource>
A sequence that contains the elements that form the set intersection of two sequences.
Implementation of IList.intersect
Inherited from ArrayEnumerable.intersect
- Defined in enumerables/BasicEnumerable.ts:1274
intersect(...second: Iterable<TSource>[]): IEnumerable<TSource>
Produces the set intersection of two sequences.
Parameters
- ...second: Iterable<TSource>[]
  An IEnumerable whose distinct elements that also appear in the first sequence will be returned.
Returns IEnumerable<TSource>
A sequence that contains the elements that form the set intersection of two sequences.
Implementation of IList.intersect
Inherited from ArrayEnumerable.intersect
- Defined in enumerables/BasicEnumerable.ts:1281
intersect(
second: Iterable<TSource>,
equalityComparer: EqualityComparer<TSource>,
): IEnumerable<TSource>
Produces the set intersection of two sequences.
Parameters
- second: Iterable<TSource>
  An IEnumerable whose distinct elements that also appear in the first sequence will be returned.
- equalityComparer: EqualityComparer<TSource>
  A function to compare keys.
Returns IEnumerable<TSource>
A sequence that contains the elements that form the set intersection of two sequences.
Implementation of IList.intersect
Inherited from ArrayEnumerable.intersect
- Defined in enumerables/BasicEnumerable.ts:1289
intersect(
    second: Iterable<TSource>,
    third: Iterable<TSource>,
    equalityComparer: EqualityComparer<TSource>,
): IEnumerable<TSource>
Produces the set intersection of two sequences.
Parameters
- second: Iterable<TSource>
  An IEnumerable whose distinct elements that also appear in the first sequence will be returned.
- third: Iterable<TSource>
  An IEnumerable whose distinct elements that also appear in the first sequence will be returned.
- equalityComparer: EqualityComparer<TSource>
  A function to compare keys.
Returns IEnumerable<TSource>
A sequence that contains the elements that form the set intersection of two sequences.
Implementation of IList.intersect
Inherited from ArrayEnumerable.intersect
- Defined in enumerables/BasicEnumerable.ts:1298
intersect(
    second: Iterable<TSource>,
    third: Iterable<TSource>,
    fourth: Iterable<TSource>,
    equalityComparer: EqualityComparer<TSource>,
): IEnumerable<TSource>
Produces the set intersection of two sequences.
Parameters
- second: Iterable<TSource>
  An IEnumerable whose distinct elements that also appear in the first sequence will be returned.
- third: Iterable<TSource>
  An IEnumerable whose distinct elements that also appear in the first sequence will be returned.
- fourth: Iterable<TSource>
  An IEnumerable whose distinct elements that also appear in the first sequence will be returned.
- equalityComparer: EqualityComparer<TSource>
  A function to compare keys.
Returns IEnumerable<TSource>
A sequence that contains the elements that form the set intersection of two sequences.
Implementation of IList.intersect
Inherited from ArrayEnumerable.intersect
- Defined in enumerables/BasicEnumerable.ts:1312

intersectBy

intersectBy<TKey>(
second: Iterable<TKey>,
keySelector: (item: TSource) => TKey,
): IEnumerable<TSource>
Produces the set intersection of two sequences according to a specified key selector function.
Type Parameters
- TKey
Parameters
- second: Iterable<TKey>
  An IEnumerable whose distinct elements that also appear in the first sequence will be returned.
- keySelector: (item: TSource) => TKey
  A function to extract the key for each element.
Returns IEnumerable<TSource>
A sequence that contains the elements that form the set intersection of two sequences.

Typeparam
TKey The type of key to identify elements by.
Implementation of IList.intersectBy
Inherited from ArrayEnumerable.intersectBy
- Defined in enumerables/BasicEnumerable.ts:1330
intersectBy<TKey>(
    second: Iterable<TKey>,
    third: Iterable<TSource>,
    keySelector: (item: TSource) => TKey,
): IEnumerable<TSource>
Produces the set intersection of two sequences according to a specified key selector function.
Type Parameters
- TKey
Parameters
- second: Iterable<TKey>
  An IEnumerable whose distinct elements that also appear in the first sequence will be returned.
- third: Iterable<TSource>
  An IEnumerable whose distinct elements that also appear in the first sequence will be returned.
- keySelector: (item: TSource) => TKey
  A function to extract the key for each element.
Returns IEnumerable<TSource>
A sequence that contains the elements that form the set intersection of two sequences.

Typeparam
TKey The type of key to identify elements by.
Implementation of IList.intersectBy
Inherited from ArrayEnumerable.intersectBy
- Defined in enumerables/BasicEnumerable.ts:1340
intersectBy<TKey>(
    second: Iterable<TKey>,
    third: Iterable<TSource>,
    fourth: Iterable<TSource>,
    keySelector: (item: TSource) => TKey,
): IEnumerable<TSource>
Produces the set intersection of two sequences according to a specified key selector function.
Type Parameters
- TKey
Parameters
- second: Iterable<TKey>
  An IEnumerable whose distinct elements that also appear in the first sequence will be returned.
- third: Iterable<TSource>
  An IEnumerable whose distinct elements that also appear in the first sequence will be returned.
- fourth: Iterable<TSource>
  An IEnumerable whose distinct elements that also appear in the first sequence will be returned.
- keySelector: (item: TSource) => TKey
  A function to extract the key for each element.
Returns IEnumerable<TSource>
A sequence that contains the elements that form the set intersection of two sequences.

Typeparam
TKey The type of key to identify elements by.
Implementation of IList.intersectBy
Inherited from ArrayEnumerable.intersectBy
- Defined in enumerables/BasicEnumerable.ts:1355
intersectBy<TKey>(
    second: Iterable<TKey>,
    keySelector: (item: TSource) => TKey,
    equalityComparer: EqualityComparer<TKey>,
): IEnumerable<TSource>
Produces the set intersection of two sequences according to a specified key selector function.
Type Parameters
- TKey
Parameters
- second: Iterable<TKey>
  An IEnumerable whose distinct elements that also appear in the first sequence will be returned.
- keySelector: (item: TSource) => TKey
  A function to extract the key for each element.
- equalityComparer: EqualityComparer<TKey>
  A function to compare keys.
Returns IEnumerable<TSource>
A sequence that contains the elements that form the set intersection of two sequences.

Typeparam
TKey The type of key to identify elements by.
Implementation of IList.intersectBy
Inherited from ArrayEnumerable.intersectBy
- Defined in enumerables/BasicEnumerable.ts:1370
intersectBy<TKey>(
    second: Iterable<TKey>,
    third: Iterable<TSource>,
    keySelector: (item: TSource) => TKey,
    equalityComparer: EqualityComparer<TKey>,
): IEnumerable<TSource>
Produces the set intersection of two sequences according to a specified key selector function.
Type Parameters
- TKey
Parameters
- second: Iterable<TKey>
  An IEnumerable whose distinct elements that also appear in the first sequence will be returned.
- third: Iterable<TSource>
  An IEnumerable whose distinct elements that also appear in the first sequence will be returned.
- keySelector: (item: TSource) => TKey
  A function to extract the key for each element.
- equalityComparer: EqualityComparer<TKey>
  A function to compare keys.
Returns IEnumerable<TSource>
A sequence that contains the elements that form the set intersection of two sequences.

Typeparam
TKey The type of key to identify elements by.
Implementation of IList.intersectBy
Inherited from ArrayEnumerable.intersectBy
- Defined in enumerables/BasicEnumerable.ts:1385
intersectBy<TKey>(
    second: Iterable<TKey>,
    third: Iterable<TSource>,
    fourth: Iterable<TSource>,
    keySelector: (item: TSource) => TKey,
    equalityComparer: EqualityComparer<TKey>,
): IEnumerable<TSource>
Produces the set intersection of two sequences according to a specified key selector function.
Type Parameters
- TKey
Parameters
- second: Iterable<TKey>
  An IEnumerable whose distinct elements that also appear in the first sequence will be returned.
- third: Iterable<TSource>
  An IEnumerable whose distinct elements that also appear in the first sequence will be returned.
- fourth: Iterable<TSource>
  An IEnumerable whose distinct elements that also appear in the first sequence will be returned.
- keySelector: (item: TSource) => TKey
  A function to extract the key for each element.
- equalityComparer: EqualityComparer<TKey>
  A function to compare keys.
Returns IEnumerable<TSource>
A sequence that contains the elements that form the set intersection of two sequences.

Typeparam
TKey The type of key to identify elements by.
Implementation of IList.intersectBy
Inherited from ArrayEnumerable.intersectBy
- Defined in enumerables/BasicEnumerable.ts:1402

interweave

interweave(collection: Iterable<TSource>): IEnumerable<TSource>
Interweaves two sequences.
Parameters
- collection: Iterable<TSource>
  The sequence to interweave to the first sequence.
Returns IEnumerable<TSource>
An IEnumerable that contains the interweaved elements of the two input sequences.
Example
```
const numbers = [1, 2];
const moreNumbers = from(numbers).interweave([3, 4, 5]); // [1, 3, 2, 4, 5]
```
Implementation of IList.interweave
Inherited from ArrayEnumerable.interweave
- Defined in enumerables/BasicEnumerable.ts:1426
interweave(...collections: Iterable<TSource>[]): IEnumerable<TSource>
Interweaves multiple sequences.
Parameters
- ...collections: Iterable<TSource>[]
  The sequences to interweave to the first sequence.
Returns IEnumerable<TSource>
An IEnumerable that contains the interweaved elements of the two or more input sequences.
Example
```
const numbers = [1, 2];
const evenMoreNumbers = from(numbers).interweave([3, 4], [5, 6]); // [1, 3, 5, 2, 4, 6]
```
Implementation of IList.interweave
Inherited from ArrayEnumerable.interweave
- Defined in enumerables/BasicEnumerable.ts:1438

last

last(): TSource
Returns the last element of a sequence. Throws if sequence is empty.

Returns TSource
The value at the last position in the source sequence.
Implementation of IList.last
Inherited from ArrayEnumerable.last
- Defined in enumerables/BasicEnumerable.ts:1448
last(predicate: (item: TSource, index: number) => boolean): TSource
Returns the last element of a sequence that satisfies a specified condition.
Parameters
- predicate: (item: TSource, index: number) => boolean
  A function to test each element for a condition.
Returns TSource
The last element in the sequence that passes the test in the specified predicate function.
Implementation of IList.last
Inherited from ArrayEnumerable.last
- Defined in enumerables/BasicEnumerable.ts:1455

lastOrDefault

lastOrDefault(): null | TSource
Returns the last element of a sequence, or null if the sequence contains no elements.

Returns null | TSource
null if the source sequence is empty; otherwise, the last element in the IEnumerable
Implementation of IList.lastOrDefault
Inherited from ArrayEnumerable.lastOrDefault
- Defined in enumerables/ArrayEnumerable.ts:123
lastOrDefault(
predicate: (item: TSource, index: number) => boolean,
): null | TSource
Returns the last element of a sequence that satisfies a condition or null if no such element is found.
Parameters
- predicate: (item: TSource, index: number) => boolean
  A function to test each element for a condition.
Returns null | TSource
null if the sequence is empty or if no elements pass the test in the predicate function; otherwise, the last element that passes the test in the predicate function.
Implementation of IList.lastOrDefault
Inherited from ArrayEnumerable.lastOrDefault
- Defined in enumerables/ArrayEnumerable.ts:130

leftJoinHeterogeneous

leftJoinHeterogeneous<TSecond, TKey, TResult>(
    second: Iterable<TSecond>,
    firstKeySelector: (item: TSource) => TKey,
    secondKeySelector: (item: TSecond) => TKey,
    firstSelector: (item: TSource) => TResult,
    bothSelector: (a: TSource, b: TSecond) => TResult,
): IEnumerable<TResult>
Performs a left outer join on two heterogeneous sequences. Additional arguments specify key selection functions and result projection functions.
Type Parameters
- TSecond
- TKey
- TResult
Parameters
- second: Iterable<TSecond>
  The second sequence of the join operation.
- firstKeySelector: (item: TSource) => TKey
  Function that projects the key given an element from first.
- secondKeySelector: (item: TSecond) => TKey
  Function that projects the key given an element from second.
- firstSelector: (item: TSource) => TResult
  Function that projects the result given just an element from first where there is no corresponding element in second.
- bothSelector: (a: TSource, b: TSecond) => TResult
  Function that projects the result given an element from first and an element from second that match on a common key.
Returns IEnumerable<TResult>
A sequence containing results projected from a left outer join of the two input sequences.
Implementation of IList.leftJoinHeterogeneous
Inherited from ArrayEnumerable.leftJoinHeterogeneous
- Defined in enumerables/BasicEnumerable.ts:1487
leftJoinHeterogeneous<TSecond, TKey, TResult>(
    second: Iterable<TSecond>,
    firstKeySelector: (item: TSource) => TKey,
    secondKeySelector: (item: TSecond) => TKey,
    firstSelector: (item: TSource) => TResult,
    bothSelector: (a: TSource, b: TSecond) => TResult,
    equalityComparer: EqualityComparer<TKey>,
): IEnumerable<TResult>
Performs a left outer join on two heterogeneous sequences. Additional arguments specify key selection functions and result projection functions.
Type Parameters
- TSecond
- TKey
- TResult
Parameters
- second: Iterable<TSecond>
  The second sequence of the join operation.
- firstKeySelector: (item: TSource) => TKey
  Function that projects the key given an element from first.
- secondKeySelector: (item: TSecond) => TKey
  Function that projects the key given an element from second.
- firstSelector: (item: TSource) => TResult
  Function that projects the result given just an element from first where there is no corresponding element in second.
- bothSelector: (a: TSource, b: TSecond) => TResult
  Function that projects the result given an element from first and an element from second that match on a common key.
- equalityComparer: EqualityComparer<TKey>
  A function to compare keys.
Returns IEnumerable<TResult>
A sequence containing results projected from a left outer join of the two input sequences.
Implementation of IList.leftJoinHeterogeneous
Inherited from ArrayEnumerable.leftJoinHeterogeneous
- Defined in enumerables/BasicEnumerable.ts:1505

leftJoinHomogeneous

leftJoinHomogeneous<TKey, TResult>(
    second: Iterable<TSource>,
    keySelector: (item: TSource) => TKey,
    firstSelector: (item: TSource) => TResult,
    bothSelector: (a: TSource, b: TSource) => TResult,
): IEnumerable<TResult>
Performs a left outer join on two homogeneous sequences. Additional arguments specify key selection functions and result projection functions.
Type Parameters
- TKey
- TResult
Parameters
- second: Iterable<TSource>
  The second sequence of the join operation.
- keySelector: (item: TSource) => TKey
  Function that projects the key given an element of one of the sequences to join.
- firstSelector: (item: TSource) => TResult
  Function that projects the result given just an element from first where there is no corresponding element in second.
- bothSelector: (a: TSource, b: TSource) => TResult
  Function that projects the result given an element from first and an element from second that match on a common key.
Returns IEnumerable<TResult>
A sequence containing results projected from a left outer join of the two input sequences.
Implementation of IList.leftJoinHomogeneous
Inherited from ArrayEnumerable.leftJoinHomogeneous
- Defined in enumerables/BasicEnumerable.ts:1542
leftJoinHomogeneous<TKey, TResult>(
    second: Iterable<TSource>,
    keySelector: (item: TSource) => TKey,
    firstSelector: (item: TSource) => TResult,
    bothSelector: (a: TSource, b: TSource) => TResult,
    equalityComparer: EqualityComparer<TKey>,
): IEnumerable<TResult>
Performs a left outer join on two homogeneous sequences. Additional arguments specify key selection functions and result projection functions.
Type Parameters
- TKey
- TResult
Parameters
- second: Iterable<TSource>
  The second sequence of the join operation.
- keySelector: (item: TSource) => TKey
  Function that projects the key given an element of one of the sequences to join.
- firstSelector: (item: TSource) => TResult
  Function that projects the result given just an element from first where there is no corresponding element in second.
- bothSelector: (a: TSource, b: TSource) => TResult
  Function that projects the result given an element from first and an element from second that match on a common key.
- equalityComparer: EqualityComparer<TKey>
  A function to compare keys.
Returns IEnumerable<TResult>
A sequence containing results projected from a left outer join of the two input sequences.
Implementation of IList.leftJoinHomogeneous
Inherited from ArrayEnumerable.leftJoinHomogeneous
- Defined in enumerables/BasicEnumerable.ts:1558

max

max(): TSource
Returns the maximum value in a sequence of values.

Returns TSource
The max value in the sequence.
Implementation of IList.max
Inherited from ArrayEnumerable.max
- Defined in enumerables/BasicEnumerable.ts:1588
max<TResult>(selector: (item: TSource) => TResult): TResult
Invokes a transform function on each element of a generic sequence and returns the maximum resulting value.
Type Parameters
- TResult
Parameters
- selector: (item: TSource) => TResult
  A transform function to apply to each element.
Returns TResult
The maximum value in the sequence.

Typeparam
TResult The type of the value returned by selector.
Implementation of IList.max
Inherited from ArrayEnumerable.max
- Defined in enumerables/BasicEnumerable.ts:1596

maxBy

maxBy<TKey>(keySelector: (item: TSource) => TKey): TSource
Returns the maximum value in a generic sequence according to a specified key selector function.
Type Parameters
- TKey
Parameters
- keySelector: (item: TSource) => TKey
  A function to extract the key for each element.
Returns TSource
The value with the maximum key in the sequence.

Typeparam
TKey The type of key to compare elements by.
Implementation of IList.maxBy
Inherited from ArrayEnumerable.maxBy
- Defined in enumerables/BasicEnumerable.ts:1608

min

min(): TSource
Returns the min value in a sequence of values.

Returns TSource
The min value in the sequence.
Implementation of IList.min
Inherited from ArrayEnumerable.min
- Defined in enumerables/BasicEnumerable.ts:1616
min<TResult>(selector: (item: TSource) => TResult): TResult
Invokes a transform function on each element of a generic sequence and returns the min resulting value.
Type Parameters
- TResult
Parameters
- selector: (item: TSource) => TResult
  A transform function to apply to each element.
Returns TResult
The min value in the sequence.

Typeparam
TResult The type of the value returned by selector.
Implementation of IList.min
Inherited from ArrayEnumerable.min
- Defined in enumerables/BasicEnumerable.ts:1624

minBy

minBy<TKey>(keySelector: (item: TSource) => TKey): TSource
Returns the min value in a generic sequence according to a specified key selector function.
Type Parameters
- TKey
Parameters
- keySelector: (item: TSource) => TKey
  A function to extract the key for each element.
Returns TSource
The value with the min key in the sequence.

Typeparam
TKey The type of key to compare elements by.
Implementation of IList.minBy
Inherited from ArrayEnumerable.minBy
- Defined in enumerables/BasicEnumerable.ts:1636

ofType

ofType<TResult>(
type: new (...params: unknown[]) => TResult,
): IEnumerable<TResult>
Filters the elements of an IEnumerable based on a specified type.
Type Parameters
- TResult
Parameters
- type: new (...params: unknown[]) => TResult
  The type to filter the elements of the sequence on.
Returns IEnumerable<TResult>
An IEnumerable that contains elements from the input sequence of type TResult.

Typeparam
TResult The type to filter the elements of the sequence on.
Implementation of IList.ofType
Inherited from ArrayEnumerable.ofType
- Defined in enumerables/BasicEnumerable.ts:1646

order

order(): IOrderedEnumerable<TSource>
Sorts the elements of a sequence in ascending order.

Returns IOrderedEnumerable<TSource>
An IOrderedEnumerable whose elements are sorted.
Example
```
const items = [1, 3, 2];
const ordered = from(items).order().toArray(); // Will be [1, 2, 3]
```
Implementation of IList.order
Inherited from ArrayEnumerable.order
- Defined in enumerables/BasicEnumerable.ts:1659
order(comparer: Comparer<TSource>): IOrderedEnumerable<TSource>
Sorts the elements of a sequence in ascending order.
Parameters
- comparer: Comparer<TSource>
  An Comparer to compare keys.
Returns IOrderedEnumerable<TSource>
An IOrderedEnumerable whose elements are sorted.
Example
```
const items = [1, 3, 2];
const ordered = from(items).order().toArray(); // Will be [1, 2, 3]
```
Implementation of IList.order
Inherited from ArrayEnumerable.order
- Defined in enumerables/BasicEnumerable.ts:1671

orderBy

orderBy<TKey>(keySelector: (item: TSource) => TKey): IOrderedEnumerable<TSource>
Sorts the elements of a sequence in ascending order.
Type Parameters
- TKey
Parameters
- keySelector: (item: TSource) => TKey
  A function to extract the key for each element.
Returns IOrderedEnumerable<TSource>
An IOrderedEnumerable whose elements are sorted according to a key.
Example
```
const items = [{ id: 1 }, { id: 3 }, { id: 2 }];
const ordered = from(items).orderBy(x => x.id).toArray(); // Will be [{ id: 1 }, { id: 2 }, { id: 3 }]
```
Typeparam
TKey The type of the key returned by keySelector.
Implementation of IList.orderBy
Inherited from ArrayEnumerable.orderBy
- Defined in enumerables/BasicEnumerable.ts:1715
orderBy<TKey>(
keySelector: (item: TSource) => TKey,
comparer: Comparer<TKey>,
): IOrderedEnumerable<TSource>
Sorts the elements of a sequence in ascending order.
Type Parameters
- TKey
Parameters
- keySelector: (item: TSource) => TKey
  A function to extract the key for each element.
- comparer: Comparer<TKey>
  An Comparer to compare keys.
Returns IOrderedEnumerable<TSource>
An IOrderedEnumerable whose elements are sorted according to a key.
Example
```
const items = [{ id: 1 }, { id: 3 }, { id: 2 }];
const ordered = from(items).orderBy(x => x.id).toArray(); // Will be [{ id: 1 }, { id: 2 }, { id: 3 }]
```
Typeparam
TKey The type of the key returned by keySelector.
Implementation of IList.orderBy
Inherited from ArrayEnumerable.orderBy
- Defined in enumerables/BasicEnumerable.ts:1729

orderByDescending

orderByDescending<TKey>(
keySelector: (item: TSource) => TKey,
): IOrderedEnumerable<TSource>
Sorts the elements of a sequence in descending order.
Type Parameters
- TKey
Parameters
- keySelector: (item: TSource) => TKey
  A function to extract the key for each element.
Returns IOrderedEnumerable<TSource>
An IOrderedEnumerable whose elements are sorted according to a key.
Example
```
const items = [{ id: 1 }, { id: 3 }, { id: 2 }];
const ordered = from(items).orderByDescending(x => x.id).toArray(); // Will be [{ id: 3 }, { id: 2 }, { id: 1 }]
```
Typeparam
TKey The type of the key returned by keySelector.
Implementation of IList.orderByDescending
Inherited from ArrayEnumerable.orderByDescending
- Defined in enumerables/BasicEnumerable.ts:1746
orderByDescending<TKey>(
keySelector: (item: TSource) => TKey,
comparer: Comparer<TKey>,
): IOrderedEnumerable<TSource>
Sorts the elements of a sequence in descending order.
Type Parameters
- TKey
Parameters
- keySelector: (item: TSource) => TKey
  A function to extract the key for each element.
- comparer: Comparer<TKey>
  An Comparer to compare keys.
Returns IOrderedEnumerable<TSource>
An IOrderedEnumerable whose elements are sorted according to a key.
Example
```
const items = [{ id: 1 }, { id: 3 }, { id: 2 }];
const ordered = from(items).orderByDescending(x => x.id).toArray(); // Will be [{ id: 3 }, { id: 2 }, { id: 1 }]
```
Typeparam
TKey The type of the key returned by keySelector.
Implementation of IList.orderByDescending
Inherited from ArrayEnumerable.orderByDescending
- Defined in enumerables/BasicEnumerable.ts:1760

orderDescending

orderDescending(): IOrderedEnumerable<TSource>
Sorts the elements of a sequence in descending order.

Returns IOrderedEnumerable<TSource>
An IOrderedEnumerable whose elements are sorted.
Example
```
const items = [1, 3, 2];
const ordered = from(items).orderDescending().toArray(); // Will be [3, 2, 1]
```
Implementation of IList.orderDescending
Inherited from ArrayEnumerable.orderDescending
- Defined in enumerables/BasicEnumerable.ts:1686
orderDescending(comparer: Comparer<TSource>): IOrderedEnumerable<TSource>
Sorts the elements of a sequence in descending order.
Parameters
- comparer: Comparer<TSource>
  An Comparer to compare keys.
Returns IOrderedEnumerable<TSource>
An IOrderedEnumerable whose elements are sorted.
Example
```
const items = [1, 3, 2];
const ordered = from(items).orderDescending().toArray(); // Will be [3, 2, 1]
```
Implementation of IList.orderDescending
Inherited from ArrayEnumerable.orderDescending
- Defined in enumerables/BasicEnumerable.ts:1698

pipe

pipe(action: (item: TSource, index: number) => void): IEnumerable<TSource>
Executes the given action on each element in the source sequence and yields it.
Parameters
- action: (item: TSource, index: number) => void
  The action to execute on each element.
Returns IEnumerable<TSource>
A sequence with source elements in their original order.
Implementation of IList.pipe
Inherited from ArrayEnumerable.pipe
- Defined in enumerables/BasicEnumerable.ts:1777

prepend

prepend(item: TSource): IEnumerable<TSource>
Adds a value to the beginning of the sequence.
Parameters
- item: TSource
  The value to prepend to source.
Returns IEnumerable<TSource>
A new sequence that begins with item.
Implementation of IList.prepend
Inherited from ArrayEnumerable.prepend
- Defined in enumerables/BasicEnumerable.ts:1786

quantile

quantile(q: number): number
Computes the quantile of a sequence of numbers. Note this will throw an exception if sequence has something other than numbers.
Parameters
- q: number
  The percentile to compute (25, 50, etc.)
Returns number
The percentile of the sequence.
Exmaple
```
const items = [1, 2, 2, 3, 4];
const q = from(items).quantile(50); // Will be 2
```
Implementation of IList.quantile
Inherited from ArrayEnumerable.quantile
- Defined in enumerables/BasicEnumerable.ts:1801
quantile(selector: (item: TSource) => number, q: number): number
Computes the quantile of a sequence.
Parameters
- selector: (item: TSource) => number
  A function to extract a value from each element.
- q: number
  The percentile to compute (25, 50, etc.)
Returns number
The percentile of the sequence.
Exmaple
```
const items = [{ age: 1 }, { age: 2 }, { age: 2 }, { age: 3 }, { age: 4 }];
const q = from(items).quantile(x => x.age, 50); // Will be 2
```
Implementation of IList.quantile
Inherited from ArrayEnumerable.quantile
- Defined in enumerables/BasicEnumerable.ts:1814

remove

remove(item: TSource): boolean
Parameters
- item: TSource
Returns boolean
Implementation of IList.remove
- Defined in collections/List.ts:187

removeAll

removeAll(predicate: (item: TSource, index: number) => boolean): number
Parameters
- predicate: (item: TSource, index: number) => boolean
Returns number
Implementation of IList.removeAll
- Defined in collections/List.ts:199

removeAt

removeAt(index: number): void
Parameters
- index: number
Returns void
Implementation of IList.removeAt
- Defined in collections/List.ts:217

removeRange

removeRange(index: number, count: number): void
Parameters
- index: number
- count: number
Returns void
Implementation of IList.removeRange
- Defined in collections/List.ts:225

reverseImmutable

reverseImmutable(): IEnumerable<TSource>
Inverts the order of the elements in a sequence.

Returns IEnumerable<TSource>
A sequence whose elements correspond to those of the input sequence in reverse order.
Implementation of IList.reverseImmutable
Inherited from ArrayEnumerable.reverseImmutable
- Defined in enumerables/BasicEnumerable.ts:1824

reverseInPlace

reverseInPlace(): void
Returns void
Implementation of IList.reverseInPlace
- Defined in collections/List.ts:233
reverseInPlace(index: number, count: number): void
Parameters
- index: number
- count: number
Returns void
Implementation of IList.reverseInPlace
- Defined in collections/List.ts:235

rightJoinHeterogeneous

rightJoinHeterogeneous<TSecond, TKey, TResult>(
    second: Iterable<TSecond>,
    firstKeySelector: (item: TSource) => TKey,
    secondKeySelector: (item: TSecond) => TKey,
    secondSelector: (item: TSecond) => TResult,
    bothSelector: (a: TSource, b: TSecond) => TResult,
): IEnumerable<TResult>

Performs a right outer join on two heterogeneous sequences.

Type Parameters

TSecond
TKey
TResult

Parameters

second: Iterable<TSecond>
The second sequence of the join operation.
firstKeySelector: (item: TSource) => TKey
Function that projects the key given an element from first.
secondKeySelector: (item: TSecond) => TKey
Function that projects the key given an element from second.
secondSelector: (item: TSecond) => TResult
Function that projects the result given just an element from second where there is no corresponding element in first.
bothSelector: (a: TSource, b: TSecond) => TResult
Function that projects the result given an element from first and an element from second that match on a common key.

Returns IEnumerable<TResult>

A sequence containing results projected from a right outer join of the two input sequences.

Example

const right = 'right';
const both = 'both';
const missing = null;

type Side = typeof right | typeof both;
type Person = { name: string };
type Pet = { name: string; owner: Person };

const magnus: Person = { name: 'Magnus' };
const terry: Person = { name: 'Terry' };
const adam: Person = { name: 'Adam' };
const john: Person = { name: 'John' };

const barley: Pet = { name: 'Barley', owner: terry };
const boots: Pet = { name: 'Boots', owner: terry };
const whiskers: Pet = { name: 'Whiskers', owner: adam };
const daisy: Pet = { name: 'Daisy', owner: magnus };
const scratchy: Pet = { name: 'Scratchy', owner: { name: 'Bob' } };

const people = from([magnus, terry, adam, john]);
const pets = from([barley, boots, whiskers, daisy, scratchy]);

const result = people.rightJoinHeterogeneous<Pet, Person, { side: Side; left: Person | null; right: Pet }>(
    pets,
    person => person,
    pet => pet.owner,
    pet => ({ side: right, left: missing, right: pet }),
    (person, pet) => ({ side: both, left: person, right: pet })
  )
  .toArray();

expect(result).toEqual([
  { side: both, left: terry, right: barley },
  { side: both, left: terry, right: boots },
  { side: both, left: adam, right: whiskers },
  { side: both, left: magnus, right: daisy },
  { side: right, left: missing, right: scratchy } // Scratchy has an owner, Bob, but Bob is not in the calling collection, hence the 'missing'.
]);

Typeparam

TSecond The type of elements in the second sequence.

Typeparam

TKey The type of the key returned by the key selector functions.

Typeparam

TResult The type of the result elements.

rightJoinHeterogeneous<TSecond, TKey, TResult>(
    second: Iterable<TSecond>,
    firstKeySelector: (item: TSource) => TKey,
    secondKeySelector: (item: TSecond) => TKey,
    secondSelector: (item: TSecond) => TResult,
    bothSelector: (a: TSource, b: TSecond) => TResult,
    equalityComparer: EqualityComparer<TKey>,
): IEnumerable<TResult>

Performs a right outer join on two heterogeneous sequences.

Type Parameters

TSecond
TKey
TResult

Parameters

second: Iterable<TSecond>
The second sequence of the join operation.
firstKeySelector: (item: TSource) => TKey
Function that projects the key given an element from first.
secondKeySelector: (item: TSecond) => TKey
Function that projects the key given an element from second.
secondSelector: (item: TSecond) => TResult
Function that projects the result given just an element from second where there is no corresponding element in first.
bothSelector: (a: TSource, b: TSecond) => TResult
Function that projects the result given an element from first and an element from second that match on a common key.
equalityComparer: EqualityComparer<TKey>
A function to compare keys.

Returns IEnumerable<TResult>

A sequence containing results projected from a right outer join of the two input sequences.

Example

const right = 'right';
const both = 'both';
const missing = null;

type Side = typeof right | typeof both;
type Person = { name: string };
type Pet = { name: string; owner: Person };

const magnus: Person = { name: 'Magnus' };
const terry: Person = { name: 'Terry' };
const adam: Person = { name: 'Adam' };
const john: Person = { name: 'John' };

const barley: Pet = { name: 'Barley', owner: terry };
const boots: Pet = { name: 'Boots', owner: terry };
const whiskers: Pet = { name: 'Whiskers', owner: adam };
const daisy: Pet = { name: 'Daisy', owner: magnus };
const scratchy: Pet = { name: 'Scratchy', owner: { name: 'Bob' } };

const people = from([magnus, terry, adam, john]);
const pets = from([barley, boots, whiskers, daisy, scratchy]);

const result = people.rightJoinHeterogeneous<Pet, Person, { side: Side; left: Person | null; right: Pet }>(
    pets,
    person => person,
    pet => pet.owner,
    pet => ({ side: right, left: missing, right: pet }),
    (person, pet) => ({ side: both, left: person, right: pet }),
    (person, pet) => person.name === pet.owner.name
  )
  .toArray();

expect(result).toEqual([
  { side: both, left: terry, right: barley },
  { side: both, left: terry, right: boots },
  { side: both, left: adam, right: whiskers },
  { side: both, left: magnus, right: daisy },
  { side: right, left: missing, right: scratchy } // Scratchy has an owner, Bob, but Bob is not in the calling collection, hence the 'missing'.
]);

Typeparam

TSecond The type of elements in the second sequence.

Typeparam

TKey The type of the key returned by the key selector functions.

Typeparam

TResult The type of the result elements.

rightJoinHomogeneous

rightJoinHomogeneous<TKey, TResult>(
    second: Iterable<TSource>,
    keySelector: (item: TSource) => TKey,
    secondSelector: (item: TSource) => TResult,
    bothSelector: (a: TSource, b: TSource) => TResult,
): IEnumerable<TResult>

Performs a right outer join on two homogeneous sequences.

Type Parameters

TKey
TResult

Parameters

second: Iterable<TSource>
The second sequence of the join operation.
keySelector: (item: TSource) => TKey
Function that projects the key given an element of one of the sequences to join.
secondSelector: (item: TSource) => TResult
Function that projects the result given just an element from second where there is no corresponding element in first.
bothSelector: (a: TSource, b: TSource) => TResult
Function that projects the result given an element from first and an element from second that match on a common key.

Returns IEnumerable<TResult>

A sequence containing results projected from a right outer join of the two input sequences.

Example

const right = 'right';
const both = 'both';
const missing = null;

type Side = typeof right | typeof both;
type Person = { id: number; name: string };

const magnus: Person = { id: 1, name: 'Magnus' };
const terry1: Person = { id: 2, name: 'Terry' };
const adam: Person = { id: 3, name: 'Adam' };
const john1: Person = { id: 4, name: 'John' };
const john4: Person = { id: 9, name: 'John' };

const john2: Person = { id: 5, name: 'John' };
const jane: Person = { id: 6, name: 'Jane' };
const terry2: Person = { id: 7, name: 'Terry' };
const john3: Person = { id: 8, name: 'John' };

const people1 = from([magnus, terry1, adam, john1, john4]);
const people2 = from([john2, jane, terry2, john3]);

const result = people1.rightJoinHomogeneous<string, { side: Side; left: Person | null; right: Person }>(
    people2,
    person => person.name,
    person => ({ side: right, left: missing, right: person }),
    (personLeft, personRight) => ({ side: both, left: personLeft, right: personRight })
  )
  .toArray();

expect(result).toEqual([
  { side: both, left: john1, right: john2 },
  { side: both, left: john4, right: john2 },
  { side: right, left: missing, right: jane },
  { side: both, left: terry1, right: terry2 },
  { side: both, left: john1, right: john3 },
  { side: both, left: john4, right: john3 }
]);

Typeparam

TSecond The type of elements in the second sequence.

Typeparam

TKey The type of the key returned by the key selector functions.

Typeparam

TResult The type of the result elements.

rightJoinHomogeneous<TKey, TResult>(
    second: Iterable<TSource>,
    keySelector: (item: TSource) => TKey,
    secondSelector: (item: TSource) => TResult,
    bothSelector: (a: TSource, b: TSource) => TResult,
    equalityComparer: EqualityComparer<TKey>,
): IEnumerable<TResult>

Performs a right outer join on two homogeneous sequences.

Type Parameters

TKey
TResult

Parameters

second: Iterable<TSource>
The second sequence of the join operation.
keySelector: (item: TSource) => TKey
Function that projects the key given an element of one of the sequences to join.
secondSelector: (item: TSource) => TResult
Function that projects the result given just an element from second where there is no corresponding element in first.
bothSelector: (a: TSource, b: TSource) => TResult
Function that projects the result given an element from first and an element from second that match on a common key.
equalityComparer: EqualityComparer<TKey>
A function to compare keys.

Returns IEnumerable<TResult>

A sequence containing results projected from a right outer join of the two input sequences.

Example

const right = 'right';
const both = 'both';
const missing = null;

type Side = typeof right | typeof both;
type Person = { id: number; name: string };

const magnus: Person = { id: 1, name: 'Magnus' };
const terry1: Person = { id: 2, name: 'Terry' };
const adam: Person = { id: 3, name: 'Adam' };
const john1: Person = { id: 4, name: 'John' };
const john4: Person = { id: 9, name: 'John' };

const john2: Person = { id: 5, name: 'John' };
const jane: Person = { id: 6, name: 'Jane' };
const terry2: Person = { id: 7, name: 'Terry' };
const john3: Person = { id: 8, name: 'John' };

const people1 = from([magnus, terry1, adam, john1, john4]);
const people2 = from([john2, jane, terry2, john3]);

const result = people1.rightJoinHomogeneous<string, { side: Side; left: Person | null; right: Person }>(
    people2,
    person => person.name,
    person => ({ side: right, left: missing, right: person }),
    (personLeft, personRight) => ({ side: both, left: personLeft, right: personRight }),
    (keyLeft, keyRight) => keyLeft.toUpperCase() === keyRight.toUpperCase()
  )
  .toArray();

expect(result).toEqual([
  { side: both, left: john1, right: john2 },
  { side: both, left: john4, right: john2 },
  { side: right, left: missing, right: jane },
  { side: both, left: terry1, right: terry2 },
  { side: both, left: john1, right: john3 },
  { side: both, left: john4, right: john3 }
]);

Typeparam

TSecond The type of elements in the second sequence.

Typeparam

TKey The type of the key returned by the key selector functions.

Typeparam

TResult The type of the result elements.

select

select<TResult>(
selector: (item: TSource, index: number) => TResult,
): IEnumerable<TResult>
Projects each element of a sequence into a new form.
Type Parameters
- TResult
Parameters
- selector: (item: TSource, index: number) => TResult
  A transform function to apply to each element.
Returns IEnumerable<TResult>
An IEnumerable whose elements are the result of invoking the transform function on each element of source.

Typeparam
TResult The type of the value returned by selector.
Implementation of IList.select
Inherited from ArrayEnumerable.select
- Defined in enumerables/BasicEnumerable.ts:2116

selectMany

selectMany<TResult>(
selector: (item: TSource, index: number) => Iterable<TResult>,
): IEnumerable<TResult>
Projects each element of a sequence to an IEnumerable and flattens the resulting sequences into one sequence.
Type Parameters
- TResult
Parameters
- selector: (item: TSource, index: number) => Iterable<TResult>
  A transform function to apply to each source element; the second parameter of the function represents the index of the source element.
Returns IEnumerable<TResult>
An IEnumerable whose elements are the result of invoking the one-to-many transform function on each element of an input sequence.

Typeparam
TResult The type of the value returned by selector.
Implementation of IList.selectMany
Inherited from ArrayEnumerable.selectMany
- Defined in enumerables/BasicEnumerable.ts:2126

sequenceEqual

sequenceEqual(second: Iterable<TSource>): boolean
Determines whether two sequences are equal by comparing the elements.
Parameters
- second: Iterable<TSource>
  An IEnumerable to compare to the first sequence.
Returns boolean
true if the two source sequences are of equal length and their corresponding elements are equal; otherwise, false.
Implementation of IList.sequenceEqual
Inherited from ArrayEnumerable.sequenceEqual
- Defined in enumerables/BasicEnumerable.ts:2135
sequenceEqual(
second: Iterable<TSource>,
equalityComparer: EqualityComparer<TSource>,
): boolean
Determines whether two sequences are equal by comparing their elements by using a specified EqualityComparer.
Parameters
- second: Iterable<TSource>
  An IEnumerable to compare to the first sequence.
- equalityComparer: EqualityComparer<TSource>
  An EqualityComparer to use to compare elements.
Returns boolean
true if the two source sequences are of equal length and their corresponding elements compare equal according to equalityComparer; otherwise, false.
Implementation of IList.sequenceEqual
Inherited from ArrayEnumerable.sequenceEqual
- Defined in enumerables/BasicEnumerable.ts:2143

shuffle

shuffle(): IEnumerable<TSource>
Returns a new IEnumerable of the input sequence in random order.

Returns IEnumerable<TSource>
A new IEnumerable of the input sequence in random order.
Implementation of IList.shuffle
Inherited from ArrayEnumerable.shuffle
- Defined in enumerables/BasicEnumerable.ts:2153

single

single(): TSource
Returns the first element of a sequence, and throws an exception if more than one element exists.

Returns TSource
The single element of the input sequence that satisfies a condition.
Implementation of IList.single
Inherited from ArrayEnumerable.single
- Defined in enumerables/BasicEnumerable.ts:2161
single(predicate: (item: TSource, index: number) => boolean): TSource
Returns the only element of a sequence that satisfies a specified condition, and throws an exception if more than one such element exists.
Parameters
- predicate: (item: TSource, index: number) => boolean
  A function to test an element for a condition.
Returns TSource
The single element of the input sequence that satisfies a condition.
Implementation of IList.single
Inherited from ArrayEnumerable.single
- Defined in enumerables/BasicEnumerable.ts:2168

singleOrDefault

singleOrDefault(): null | TSource
Returns a single, specific element of a sequence, or null if that element is not found.

Returns null | TSource
The single element of the input sequence, or null if the sequence contains no elements.
Implementation of IList.singleOrDefault
Inherited from ArrayEnumerable.singleOrDefault
- Defined in enumerables/BasicEnumerable.ts:2178
singleOrDefault(
predicate: (item: TSource, index: number) => boolean,
): null | TSource
Returns the only element of a sequence that satisfies a specified condition or null if no such element exists; this method throws an exception if more than one element satisfies the condition.
Parameters
- predicate: (item: TSource, index: number) => boolean
  A function to test an element for a condition.
Returns null | TSource
The single element of the input sequence that satisfies the condition, or null if no such element is found.
Implementation of IList.singleOrDefault
Inherited from ArrayEnumerable.singleOrDefault
- Defined in enumerables/BasicEnumerable.ts:2185

skip

skip(count: number): IEnumerable<TSource>
Bypasses a specified number of elements in a sequence and then returns the remaining elements.
Parameters
- count: number
  The number of elements to skip before returning the remaining elements.
Returns IEnumerable<TSource>
An IEnumerable that contains the elements that occur after the specified index in the input sequence.
Implementation of IList.skip
Inherited from ArrayEnumerable.skip
- Defined in enumerables/BasicEnumerable.ts:2196

skipLast

skipLast(count: number): IEnumerable<TSource>
Returns a new enumerable collection that contains the elements from source with the last count elements of the source collection omitted.
Parameters
- count: number
  The number of elements to omit from the end of the collection.
Returns IEnumerable<TSource>
A new enumerable collection that contains the elements from source minus count elements from the end of the collection.
Implementation of IList.skipLast
Inherited from ArrayEnumerable.skipLast
- Defined in enumerables/BasicEnumerable.ts:2205

skipWhile

skipWhile(
predicate: (item: TSource, index: number) => boolean,
): IEnumerable<TSource>
Bypasses elements in a sequence as long as a specified condition is true and then returns the remaining elements.
Parameters
- predicate: (item: TSource, index: number) => boolean
  A function to test each source element for a condition; the second parameter of the function represents the index of the source element.
Returns IEnumerable<TSource>
An IEnumerable that contains the elements from the input sequence starting at the first element in the linear series that does not pass the test specified by predicate.
Implementation of IList.skipWhile
Inherited from ArrayEnumerable.skipWhile
- Defined in enumerables/BasicEnumerable.ts:2214

sort

sort(): void
Returns void
Implementation of IList.sort
- Defined in collections/List.ts:252

split

split(separator: TSource): IEnumerable<IEnumerable<TSource>>
Splits the source sequence by a separator.
Parameters
- separator: TSource
  Separator element.
Returns IEnumerable<IEnumerable<TSource>>
A sequence of splits of elements.
Implementation of IList.split
Inherited from ArrayEnumerable.split
- Defined in enumerables/BasicEnumerable.ts:2223
split(
predicate: (item: TSource, index: number) => boolean,
): IEnumerable<IEnumerable<TSource>>
Splits the source sequence by a predicate.
Parameters
- predicate: (item: TSource, index: number) => boolean
  A function to test an element for a condition.
Returns IEnumerable<IEnumerable<TSource>>
A sequence of splits of elements.
Implementation of IList.split
Inherited from ArrayEnumerable.split
- Defined in enumerables/BasicEnumerable.ts:2230

startsWith

startsWith(second: Iterable<TSource>): boolean
Determines whether the beginning of the first sequence is equivalent to the second sequence.
Parameters
- second: Iterable<TSource>
  The sequence to compare to.
Returns boolean
true if first begins with elements equivalent to second.
Implementation of IList.startsWith
Inherited from ArrayEnumerable.startsWith
- Defined in enumerables/BasicEnumerable.ts:2243
startsWith(
second: Iterable<TSource>,
equalityComparer: EqualityComparer<TSource>,
): boolean
Determines whether the beginning of the first sequence is equivalent to the second sequence, using the specified element equality comparer.
Parameters
- second: Iterable<TSource>
  The sequence to compare to.
- equalityComparer: EqualityComparer<TSource>
  Equality comparer to use.
Returns boolean
true if first begins with elements equivalent to second.
Implementation of IList.startsWith
Inherited from ArrayEnumerable.startsWith
- Defined in enumerables/BasicEnumerable.ts:2251

sum

sum(): number
Computes the sum of a sequence of numeric values.

Returns number
The sum of the values in the sequence.
Implementation of IList.sum
Inherited from ArrayEnumerable.sum
- Defined in enumerables/BasicEnumerable.ts:2261
sum(selector: (item: TSource) => number): number
Computes the sum of the sequence of values that are obtained by invoking a transform function on each element of the input sequence.
Parameters
- selector: (item: TSource) => number
  A transform function to apply to each element.
Returns number
The sum of the projected values.
Implementation of IList.sum
Inherited from ArrayEnumerable.sum
- Defined in enumerables/BasicEnumerable.ts:2268

take

take(count: number): IEnumerable<TSource>
Returns a specified number of contiguous elements from the start of a sequence.
Parameters
- count: number
Returns IEnumerable<TSource>
An IEnumerable that contains the specified number of elements from the start of the input sequence.
Implementation of IList.take
Inherited from ArrayEnumerable.take
- Defined in enumerables/BasicEnumerable.ts:2278

takeEvery

takeEvery(step: number): IEnumerable<TSource>
Returns every N-th element of a sequence.
Parameters
- step: number
  Number of elements to bypass before returning the next element.
Returns IEnumerable<TSource>
A sequence with every N-th element of the input sequence.
Implementation of IList.takeEvery
Inherited from ArrayEnumerable.takeEvery
- Defined in enumerables/BasicEnumerable.ts:2287

takeLast

takeLast(count: number): IEnumerable<TSource>
Returns a new enumerable collection that contains the last count elements from source.
Parameters
- count: number
  The number of elements to take from the end of the collection.
Returns IEnumerable<TSource>
A new enumerable collection that contains the last count elements from source.
Implementation of IList.takeLast
Inherited from ArrayEnumerable.takeLast
- Defined in enumerables/BasicEnumerable.ts:2296

takeWhile

takeWhile(
predicate: (item: TSource, index: number) => boolean,
): IEnumerable<TSource>
Returns elements from a sequence as long as a specified condition is true, and then skips the remaining elements.
Parameters
- predicate: (item: TSource, index: number) => boolean
  A function to test each source element for a condition; the second parameter of the function represents the index of the source element.
Returns IEnumerable<TSource>
An IEnumerable that contains elements from the input sequence that occur before the element at which the test no longer passes.
Implementation of IList.takeWhile
Inherited from ArrayEnumerable.takeWhile
- Defined in enumerables/BasicEnumerable.ts:2305

to

to<TResult>(ctor: new (src: Iterable<TSource>) => TResult): TResult
Creates a new instance of the passed in ctor with the Enumerable as input. Useful for custom iterables.
Type Parameters
- TResult
Parameters
- ctor: new (src: Iterable<TSource>) => TResult
  The constructor function to create the result.
Returns TResult
A new instance of the passed in ctor with the enumerable passed as input.
Example
```
class MyCustomEnumerable<T> extends Enumerable<T> {
  public foo(): void {
    console.log('hello');
  }
}

const items = [1, 2, 3];

const asCustom = from(items).to(MyCustomEnumerable); // asCustom is now a MyCustomEnumerable instance.
```
Typeparam
TResult The type of the returned object.
Implementation of IList.to
Inherited from ArrayEnumerable.to
- Defined in enumerables/BasicEnumerable.ts:2328

toArray

toArray(): TSource[]
Converts the source sequence into an array.

Returns TSource[]
A new array containing the elements of the source sequence.
Implementation of IList.toArray
Inherited from ArrayEnumerable.toArray
- Defined in enumerables/BasicEnumerable.ts:2336

toJSON

toJSON(): string
Returns a JSON string representation of the enumerable.

Returns string
A JSON string representation of the enumerable.
Implementation of IList.toJSON
Inherited from ArrayEnumerable.toJSON
- Defined in enumerables/BasicEnumerable.ts:2344

toList

toList(): IList<TSource>
Converts the source sequence into list.

Returns IList<TSource>
A new list containing the elements of the source sequence.
Implementation of IList.toList
Inherited from ArrayEnumerable.toList
- Defined in enumerables/BasicEnumerable.ts:2352

toLookup

toLookup(): unknown
Returns unknown
Deprecated
Not yet implemented. Do not use.
Implementation of IList.toLookup
Inherited from ArrayEnumerable.toLookup
- Defined in enumerables/BasicEnumerable.ts:2359

toMap

toMap<TKey>(keySelector: (item: TSource) => TKey): Map<TKey, TSource>
Creates a Map<TKey, TValue> from an IEnumerable according to specified key selector.
Type Parameters
- TKey
Parameters
- keySelector: (item: TSource) => TKey
  A function to extract a key from each element.
Returns Map<TKey, TSource>
A Map<TKey, TSource> that contains keys and values.

Typeparam
TKey The type of the key returned by keySelector.
Implementation of IList.toMap
Inherited from ArrayEnumerable.toMap
- Defined in enumerables/BasicEnumerable.ts:2369
toMap<TKey, TValue>(
keySelector: (item: TSource) => TKey,
valueSelector: (item: TSource) => TValue,
): Map<TKey, TValue>
Creates a Map<TKey, TValue> from an IEnumerable according to specified key selector and element selector functions.
Type Parameters
- TKey
- TValue
Parameters
- keySelector: (item: TSource) => TKey
  A function to extract a key from each element.
- valueSelector: (item: TSource) => TValue
  A transform function to produce a result element value from each element.
Returns Map<TKey, TValue>
A Map<TKey, TValue> that contains keys and values.

Typeparam
TKey The type of the key returned by keySelector.

Typeparam
TValue The type of the value returned by valueSelector.
Implementation of IList.toMap
Inherited from ArrayEnumerable.toMap
- Defined in enumerables/BasicEnumerable.ts:2379

toObject

toObject(keySelector: (item: TSource) => string): Record<string, TSource>
Returns an object with keys selected by keySelector and values of TSource.
Parameters
- keySelector: (item: TSource) => string
  A function to extract a key from each element.
Returns Record<string, TSource>
An object with keys selected by keySelector and values of TSource
Implementation of IList.toObject
Inherited from ArrayEnumerable.toObject
- Defined in enumerables/BasicEnumerable.ts:2396
toObject<TValue>(
keySelector: (item: TSource) => string,
valueSelector: (item: TSource) => TValue,
): Record<string, TValue>
Returns an object with keys selected by keySelector and values of TSource.
Type Parameters
- TValue
Parameters
- keySelector: (item: TSource) => string
  A function to extract a key from each element.
- valueSelector: (item: TSource) => TValue
  A transform function to produce a result element value from each element.
Returns Record<string, TValue>
An object with keys selected by keySelector and values of TSource

Typeparam
TValue The type of the value returned by valueSelector.
Implementation of IList.toObject
Inherited from ArrayEnumerable.toObject
- Defined in enumerables/BasicEnumerable.ts:2405

toSet

toSet(): Set<TSource>
Creates a Set from an IEnumerable.

Returns Set<TSource>
A Set that contains values of type TSource selected from the input sequence.
Implementation of IList.toSet
Inherited from ArrayEnumerable.toSet
- Defined in enumerables/BasicEnumerable.ts:2421

toString

toString(): string
Returns a string representation of the enumerable.

Returns string
A string representation of the enumerable.
Implementation of IList.toString
Inherited from ArrayEnumerable.toString
- Defined in enumerables/BasicEnumerable.ts:2429

union

union(second: Iterable<TSource>): IEnumerable<TSource>
Produces the set union of two sequences.
Parameters
- second: Iterable<TSource>
  An Iterable whose distinct elements form the second set for the union.
Returns IEnumerable<TSource>
An IEnumerable that contains the elements from both input sequences, excluding duplicates.
Implementation of IList.union
Inherited from ArrayEnumerable.union
- Defined in enumerables/BasicEnumerable.ts:2438
union(...second: Iterable<TSource>[]): IEnumerable<TSource>
Produces the set union of two sequences.
Parameters
- ...second: Iterable<TSource>[]
  One or more Iterable whose distinct elements form the second set for the union.
Returns IEnumerable<TSource>
An IEnumerable that contains the elements from both input sequences, excluding duplicates.
Implementation of IList.union
Inherited from ArrayEnumerable.union
- Defined in enumerables/BasicEnumerable.ts:2445
union(
second: Iterable<TSource>,
equalityComparer: EqualityComparer<TSource>,
): IEnumerable<TSource>
Produces the set union of two sequences.
Parameters
- second: Iterable<TSource>
  An IEnumerable whose distinct elements form the second set for the union.
- equalityComparer: EqualityComparer<TSource>
  The EqualityComparer to compare values.
Returns IEnumerable<TSource>
An IEnumerable that contains the elements from both input sequences, excluding duplicates.
Implementation of IList.union
Inherited from ArrayEnumerable.union
- Defined in enumerables/BasicEnumerable.ts:2453
union(
    second: Iterable<TSource>,
    third: Iterable<TSource>,
    equalityComparer: EqualityComparer<TSource>,
): IEnumerable<TSource>
Produces the set union of two sequences.
Parameters
- second: Iterable<TSource>
  An IEnumerable whose distinct elements form the second set for the union.
- third: Iterable<TSource>
  An IEnumerable whose distinct elements form the third set for the union.
- equalityComparer: EqualityComparer<TSource>
  The EqualityComparer to compare values.
Returns IEnumerable<TSource>
An IEnumerable that contains the elements from both input sequences, excluding duplicates.
Implementation of IList.union
Inherited from ArrayEnumerable.union
- Defined in enumerables/BasicEnumerable.ts:2462
union(
    second: Iterable<TSource>,
    third: Iterable<TSource>,
    fourth: Iterable<TSource>,
    equalityComparer: EqualityComparer<TSource>,
): IEnumerable<TSource>
Produces the set union of two sequences.
Parameters
- second: Iterable<TSource>
  An IEnumerable whose distinct elements form the second set for the union.
- third: Iterable<TSource>
  An IEnumerable whose distinct elements form the third set for the union.
- fourth: Iterable<TSource>
  An IEnumerable whose distinct elements form the fourth set for the union.
- equalityComparer: EqualityComparer<TSource>
  The EqualityComparer to compare values.
Returns IEnumerable<TSource>
An IEnumerable that contains the elements from both input sequences, excluding duplicates.
Implementation of IList.union
Inherited from ArrayEnumerable.union
- Defined in enumerables/BasicEnumerable.ts:2476

unionBy

unionBy<TKey>(
second: Iterable<TSource>,
keySelector: (item: TSource) => TKey,
): IEnumerable<TSource>
Produces the set union of two sequences according to a specified key selector function.
Type Parameters
- TKey
Parameters
- second: Iterable<TSource>
  An IEnumerable whose distinct elements form the second set for the union.
- keySelector: (item: TSource) => TKey
  A function to extract the key for each element.
Returns IEnumerable<TSource>
An IEnumerable that contains the elements from both input sequences, excluding duplicates.

Typeparam
TKey The type of key to identify elements by.
Implementation of IList.unionBy
Inherited from ArrayEnumerable.unionBy
- Defined in enumerables/BasicEnumerable.ts:2494
unionBy<TKey>(
    second: Iterable<TSource>,
    third: Iterable<TSource>,
    keySelector: (item: TSource) => TKey,
): IEnumerable<TSource>
Produces the set union of two sequences according to a specified key selector function.
Type Parameters
- TKey
Parameters
- second: Iterable<TSource>
  An IEnumerable whose distinct elements form the second set for the union.
- third: Iterable<TSource>
  An IEnumerable whose distinct elements form the third set for the union.
- keySelector: (item: TSource) => TKey
  A function to extract the key for each element.
Returns IEnumerable<TSource>
An IEnumerable that contains the elements from both input sequences, excluding duplicates.

Typeparam
TKey The type of key to identify elements by.
Implementation of IList.unionBy
Inherited from ArrayEnumerable.unionBy
- Defined in enumerables/BasicEnumerable.ts:2504
unionBy<TKey>(
    second: Iterable<TSource>,
    third: Iterable<TSource>,
    fourth: Iterable<TSource>,
    keySelector: (item: TSource) => TKey,
): IEnumerable<TSource>
Produces the set union of two sequences according to a specified key selector function.
Type Parameters
- TKey
Parameters
- second: Iterable<TSource>
  An IEnumerable whose distinct elements form the second set for the union.
- third: Iterable<TSource>
  An IEnumerable whose distinct elements form the third set for the union.
- fourth: Iterable<TSource>
  An IEnumerable whose distinct elements form the fourth set for the union.
- keySelector: (item: TSource) => TKey
  A function to extract the key for each element.
Returns IEnumerable<TSource>
An IEnumerable that contains the elements from both input sequences, excluding duplicates.

Typeparam
TKey The type of key to identify elements by.
Implementation of IList.unionBy
Inherited from ArrayEnumerable.unionBy
- Defined in enumerables/BasicEnumerable.ts:2519
unionBy<TKey>(
    second: Iterable<TSource>,
    keySelector: (item: TSource) => TKey,
    equalityComparer: EqualityComparer<TKey>,
): IEnumerable<TSource>
Produces the set union of two sequences according to a specified key selector function.
Type Parameters
- TKey
Parameters
- second: Iterable<TSource>
  An IEnumerable whose distinct elements form the second set for the union.
- keySelector: (item: TSource) => TKey
  A function to extract the key for each element.
- equalityComparer: EqualityComparer<TKey>
  The EqualityComparer to compare values.
Returns IEnumerable<TSource>
An IEnumerable that contains the elements from both input sequences, excluding duplicates.

Typeparam
TKey The type of key to identify elements by.
Implementation of IList.unionBy
Inherited from ArrayEnumerable.unionBy
- Defined in enumerables/BasicEnumerable.ts:2534
unionBy<TKey>(
    second: Iterable<TSource>,
    third: Iterable<TSource>,
    keySelector: (item: TSource) => TKey,
    equalityComparer: EqualityComparer<TKey>,
): IEnumerable<TSource>
Produces the set union of two sequences according to a specified key selector function.
Type Parameters
- TKey
Parameters
- second: Iterable<TSource>
  An IEnumerable whose distinct elements form the second set for the union.
- third: Iterable<TSource>
  An IEnumerable whose distinct elements form the third set for the union.
- keySelector: (item: TSource) => TKey
  A function to extract the key for each element.
- equalityComparer: EqualityComparer<TKey>
  The EqualityComparer to compare values.
Returns IEnumerable<TSource>
An IEnumerable that contains the elements from both input sequences, excluding duplicates.

Typeparam
TKey The type of key to identify elements by.
Implementation of IList.unionBy
Inherited from ArrayEnumerable.unionBy
- Defined in enumerables/BasicEnumerable.ts:2549
unionBy<TKey>(
    second: Iterable<TSource>,
    third: Iterable<TSource>,
    fourth: Iterable<TSource>,
    keySelector: (item: TSource) => TKey,
    equalityComparer: EqualityComparer<TKey>,
): IEnumerable<TSource>
Produces the set union of two sequences according to a specified key selector function.
Type Parameters
- TKey
Parameters
- second: Iterable<TSource>
  An IEnumerable whose distinct elements form the second set for the union.
- third: Iterable<TSource>
  An IEnumerable whose distinct elements form the third set for the union.
- fourth: Iterable<TSource>
  An IEnumerable whose distinct elements form the fourth set for the union.
- keySelector: (item: TSource) => TKey
  A function to extract the key for each element.
- equalityComparer: EqualityComparer<TKey>
  The EqualityComparer to compare values.
Returns IEnumerable<TSource>
An IEnumerable that contains the elements from both input sequences, excluding duplicates.

Typeparam
TKey The type of key to identify elements by.
Implementation of IList.unionBy
Inherited from ArrayEnumerable.unionBy
- Defined in enumerables/BasicEnumerable.ts:2566

where

where(
predicate: (item: TSource, index: number) => boolean,
): IEnumerable<TSource>
Filters a sequence of values based on a predicate.
Parameters
- predicate: (item: TSource, index: number) => boolean
  A function to test each source element for a condition; the second parameter of the function represents the index of the source element.
Returns IEnumerable<TSource>
An IEnumerable that contains elements from the input sequence that satisfy the condition.
Example
```
const items = [1, 2, 3, 4, 5];
const greaterThanTwo = from(items).where(x => x > 2); // Will be [3, 4, 5]
```
Implementation of IList.where
Inherited from ArrayEnumerable.where
- Defined in enumerables/BasicEnumerable.ts:2590

window

window(size: number): IEnumerable<IEnumerable<TSource>>
Processes a sequence into a series of subsequences representing a windowed subset of the original. If size is greater than source.length, no subsequences will be returned.
Parameters
- size: number
  The size (number of elements) in each window.
Returns IEnumerable<IEnumerable<TSource>>
A series of sequences representing each sliding window subsequence.
Implementation of IList.window
Inherited from ArrayEnumerable.window
- Defined in enumerables/BasicEnumerable.ts:2600

xor

xor(second: Iterable<TSource>): IEnumerable<TSource>
Produces the set union of two sequences.
Parameters
- second: Iterable<TSource>
  One or more Iterable whose distinct elements form the second set for the union.
Returns IEnumerable<TSource>
An IEnumerable that contains the symmetric difference from all input sequences, excluding duplicates.
Implementation of IList.xor
Inherited from ArrayEnumerable.xor
- Defined in enumerables/BasicEnumerable.ts:2609
xor(...second: Iterable<TSource>[]): IEnumerable<TSource>
Produces the symmetric difference of two or more sequences.
Parameters
- ...second: Iterable<TSource>[]
  One or more Iterable whose distinct elements form the second or more set for the symmetric difference.
Returns IEnumerable<TSource>
An IEnumerable that contains the symmetric difference from all input sequences, excluding duplicates.
Implementation of IList.xor
Inherited from ArrayEnumerable.xor
- Defined in enumerables/BasicEnumerable.ts:2616
xor(
second: Iterable<TSource>,
equalityComparer: EqualityComparer<TSource>,
): IEnumerable<TSource>
Produces the symmetric difference of two sequences using a provided equality comparer.
Parameters
- second: Iterable<TSource>
  An Iterable whose distinct elements form the second set for the symmetric difference.
- equalityComparer: EqualityComparer<TSource>
  The EqualityComparer to compare values.
Returns IEnumerable<TSource>
An IEnumerable that contains the symmetric difference from all input sequences, excluding duplicates.
Implementation of IList.xor
Inherited from ArrayEnumerable.xor
- Defined in enumerables/BasicEnumerable.ts:2624
xor(
    second: Iterable<TSource>,
    third: Iterable<TSource>,
    equalityComparer: EqualityComparer<TSource>,
): IEnumerable<TSource>
Produces the symmetric difference of three sequences using a provided equality comparer.
Parameters
- second: Iterable<TSource>
  An Iterable whose distinct elements form the second set for the symmetric difference.
- third: Iterable<TSource>
  An Iterable whose distinct elements form the third set for the symmetric difference.
- equalityComparer: EqualityComparer<TSource>
  The EqualityComparer to compare values.
Returns IEnumerable<TSource>
An IEnumerable that contains the symmetric difference from all input sequences, excluding duplicates.
Implementation of IList.xor
Inherited from ArrayEnumerable.xor
- Defined in enumerables/BasicEnumerable.ts:2633
xor(
    second: Iterable<TSource>,
    third: Iterable<TSource>,
    fourth: Iterable<TSource>,
    equalityComparer: EqualityComparer<TSource>,
): IEnumerable<TSource>
Produces the symmetric difference of four sequences using a provided equality comparer.
Parameters
- second: Iterable<TSource>
  An Iterable whose distinct elements form the second set for the symmetric difference.
- third: Iterable<TSource>
  An Iterable whose distinct elements form the third set for the symmetric difference.
- fourth: Iterable<TSource>
  An Iterable whose distinct elements form the fourth set for the symmetric difference.
- equalityComparer: EqualityComparer<TSource>
  The EqualityComparer to compare values.
Returns IEnumerable<TSource>
An IEnumerable that contains the symmetric difference from all input sequences, excluding duplicates.
Implementation of IList.xor
Inherited from ArrayEnumerable.xor
- Defined in enumerables/BasicEnumerable.ts:2647

xorBy

xorBy<TKey>(
second: Iterable<TSource>,
keySelector: (item: TSource) => TKey,
): IEnumerable<TSource>
Produces the symmetric difference of two sequences according to a specified key selector function.
Type Parameters
- TKey
Parameters
- second: Iterable<TSource>
  An Iterable whose distinct elements form the second set for the symmetric difference.
- keySelector: (item: TSource) => TKey
  A function to extract the key for each element.
Returns IEnumerable<TSource>
An IEnumerable that contains the symmetric difference from all input sequences, excluding duplicates.

Typeparam
TKey The type of key to identify elements by.
Implementation of IList.xorBy
Inherited from ArrayEnumerable.xorBy
- Defined in enumerables/BasicEnumerable.ts:2665
xorBy<TKey>(
    second: Iterable<TSource>,
    third: Iterable<TSource>,
    keySelector: (item: TSource) => TKey,
): IEnumerable<TSource>
Produces the symmetric difference of three sequences according to a specified key selector function.
Type Parameters
- TKey
Parameters
- second: Iterable<TSource>
  An Iterable whose distinct elements form the second set for the symmetric difference.
- third: Iterable<TSource>
  An Iterable whose distinct elements form the third set for the symmetric difference.
- keySelector: (item: TSource) => TKey
  A function to extract the key for each element.
Returns IEnumerable<TSource>
An IEnumerable that contains the symmetric difference from all input sequences, excluding duplicates.

Typeparam
TKey The type of key to identify elements by.
Implementation of IList.xorBy
Inherited from ArrayEnumerable.xorBy
- Defined in enumerables/BasicEnumerable.ts:2675
xorBy<TKey>(
    second: Iterable<TSource>,
    third: Iterable<TSource>,
    fourth: Iterable<TSource>,
    keySelector: (item: TSource) => TKey,
): IEnumerable<TSource>
Produces the symmetric difference of four sequences according to a specified key selector function.
Type Parameters
- TKey
Parameters
- second: Iterable<TSource>
  An Iterable whose distinct elements form the second set for the symmetric difference.
- third: Iterable<TSource>
  An Iterable whose distinct elements form the third set for the symmetric difference.
- fourth: Iterable<TSource>
  An Iterable whose distinct elements form the fourth set for the symmetric difference.
- keySelector: (item: TSource) => TKey
  A function to extract the key for each element.
Returns IEnumerable<TSource>
An IEnumerable that contains the symmetric difference from all input sequences, excluding duplicates.

Typeparam
TKey The type of key to identify elements by.
Implementation of IList.xorBy
Inherited from ArrayEnumerable.xorBy
- Defined in enumerables/BasicEnumerable.ts:2690
xorBy<TKey>(
    second: Iterable<TSource>,
    keySelector: (item: TSource) => TKey,
    equalityComparer: EqualityComparer<TKey>,
): IEnumerable<TSource>
Produces the symmetric difference of two sequences according to a specified key selector function using a provided equality comparer.
Type Parameters
- TKey
Parameters
- second: Iterable<TSource>
  An Iterable whose distinct elements form the second set for the symmetric difference.
- keySelector: (item: TSource) => TKey
  A function to extract the key for each element.
- equalityComparer: EqualityComparer<TKey>
  The EqualityComparer to compare values.
Returns IEnumerable<TSource>
An IEnumerable that contains the symmetric difference from all input sequences, excluding duplicates.

Typeparam
TKey The type of key to identify elements by.
Implementation of IList.xorBy
Inherited from ArrayEnumerable.xorBy
- Defined in enumerables/BasicEnumerable.ts:2705
xorBy<TKey>(
    second: Iterable<TSource>,
    third: Iterable<TSource>,
    keySelector: (item: TSource) => TKey,
    equalityComparer: EqualityComparer<TKey>,
): IEnumerable<TSource>
Produces the symmetric difference of three sequences according to a specified key selector function using a provided equality comparer.
Type Parameters
- TKey
Parameters
- second: Iterable<TSource>
  An Iterable whose distinct elements form the second set for the symmetric difference.
- third: Iterable<TSource>
  An Iterable whose distinct elements form the third set for the symmetric difference.
- keySelector: (item: TSource) => TKey
  A function to extract the key for each element.
- equalityComparer: EqualityComparer<TKey>
  The EqualityComparer to compare values.
Returns IEnumerable<TSource>
An IEnumerable that contains the symmetric difference from all input sequences, excluding duplicates.

Typeparam
TKey The type of key to identify elements by.
Implementation of IList.xorBy
Inherited from ArrayEnumerable.xorBy
- Defined in enumerables/BasicEnumerable.ts:2720
xorBy<TKey>(
    second: Iterable<TSource>,
    third: Iterable<TSource>,
    fourth: Iterable<TSource>,
    keySelector: (item: TSource) => TKey,
    equalityComparer: EqualityComparer<TKey>,
): IEnumerable<TSource>
Produces the symmetric difference of four sequences according to a specified key selector function using a provided equality comparer.
Type Parameters
- TKey
Parameters
- second: Iterable<TSource>
  An Iterable whose distinct elements form the second set for the symmetric difference.
- third: Iterable<TSource>
  An Iterable whose distinct elements form the third set for the symmetric difference.
- fourth: Iterable<TSource>
  An Iterable whose distinct elements form the fourth set for the symmetric difference.
- keySelector: (item: TSource) => TKey
  A function to extract the key for each element.
- equalityComparer: EqualityComparer<TKey>
  The EqualityComparer to compare values.
Returns IEnumerable<TSource>
An IEnumerable that contains the symmetric difference from all input sequences, excluding duplicates.

Typeparam
TKey The type of key to identify elements by.
Implementation of IList.xorBy
Inherited from ArrayEnumerable.xorBy
- Defined in enumerables/BasicEnumerable.ts:2737

zip

zip<TSecond>(second: Iterable<TSecond>): IEnumerable<[TSource, TSecond]>
Produces a sequence of tuples with elements from the two specified sequences.
Type Parameters
- TSecond
Parameters
- second: Iterable<TSecond>
  The second sequence to merge.
Returns IEnumerable<[TSource, TSecond]>
An IEnumerable<[TSource, TSecond]> that contains merged elements of two input sequences.

Typeparam
TSecond The type of the elements of the second input sequence.
Implementation of IList.zip
Inherited from ArrayEnumerable.zip
- Defined in enumerables/BasicEnumerable.ts:2757
zip<TSecond, TResult>(
second: Iterable<TSecond>,
resultSelector: (first: TSource, second: TSecond) => TResult,
): IEnumerable<TResult>
Applies a specified function to the corresponding elements of two sequences, producing a sequence of the results.
Type Parameters
- TSecond
- TResult
Parameters
- second: Iterable<TSecond>
  The second sequence to merge.
- resultSelector: (first: TSource, second: TSecond) => TResult
  A function that specifies how to merge the elements from the two sequences.
Returns IEnumerable<TResult>
An IEnumerable that contains merged elements of two input sequences.

Typeparam
TSecond The type of the elements of the second input sequence.

Typeparam
TResult The type of the elements of the result sequence.
Implementation of IList.zip
Inherited from ArrayEnumerable.zip
- Defined in enumerables/BasicEnumerable.ts:2767

Class List<TSource>

Typeparam

Type Parameters

Hierarchy (View Summary)

Implements

Index

Constructors

Accessors

Methods

Constructors

constructor

Type Parameters

Returns List<TSource>

Type Parameters

Parameters

Returns List<TSource>

Accessors

length

Returns number

Methods

[iterator]

Returns Generator<TSource>

Example

add

Parameters

Returns void

addRange

Parameters

Returns void

aggregate

Parameters

Returns TSource

Example

Type Parameters

Parameters

Returns TAccumulate

Example

Typeparam

Type Parameters

Parameters

Returns TResult

Example

Typeparam

Typeparam

all

Parameters

Returns boolean

Example

any

Returns boolean

Example

Parameters

Returns boolean

Example

append

Parameters

Returns IEnumerable<TSource>

Example

asEnumerable

Returns IEnumerable<TSource>

Example

assert

Parameters

Returns IEnumerable<TSource>

Example

Parameters

Returns IEnumerable<TSource>

Example

Type Parameters

Parameters

Returns IEnumerable<TSource>

Example

Typeparam

Type Parameters

Parameters

Returns IEnumerable<TSource>

Example

Typeparam

atLeast

Parameters