IEnumerable<T>

Defines ways to iterate over the items contained in this type by providing a method to get an IEnumerator<T>.

Inheritance Hierarchy

Remarks

This is a convertible type that can be used in the following alternative ways in parameter lists, parameter objects, and setters.

It is possible to specify an Array or to use the native 'iterable' protocol , iterators, or generators to define the IEnumerable<T>:

// Array
object.property = [item1, item2]

// Iterables
object.property = new Set([item1, item2])
object.property = new Map([
  [key1, item1],
  [key2, item2],
]).entries()

// Generators
function* generator(i: number) {
  yield i
  yield i + 10
}

// via the iterator protocol (with invocation)
object.property = generator(10)

// via the generator function (will be executed immediately to populate the collection)
object.property = function* generateValues() {
  yield 1
  yield 2
}

Note that when using native iterables, the resulting IEnumerables can only be enumerated once and will be empty the second time they are evaluated. Pass the generator function, instead, to cause reevaluation or cache the results in a list or other collection.

Type Parameters

T: The type of the enumerable objects.

Examples

All enumerables automatically implement the EcmaScript "iterable protocol" if the platform supports the Symbol.iterator.

Basic for-of usage

const enumerable = IEnumerable.from([1, 2, 3, 4])

for (const item of enumerable) {
  console.log(item)
}
// 1 2 3 4

They also mimic many of the functions of the Array.prototype, but typically evaluate lazily.

Basic for-of usage

const enumerable = IEnumerable.from([1, 2, 3, 4])

enumerable.forEach((item) => console.log(item)) // 1 2 3 4

// accessing the index
enumerable.forEach((item, index) =>
  console.log(`Item #${index} is ${item}`),
)

Enumerables are very flexible with their various helper methods:

Advanced enumerable usage

const widestNodes = graphComponent.graph.nodes
  // group nodes by their width
  .groupBy(
    (n) => n.layout.width,
    (width, items) => ({ width, items }),
  )
  // and order the groups by their size
  .toSorted((entry1, entry2) =>
    Math.sign(entry2.items.size - entry1.items.size),
  )
  // consider the largest two groups only
  .take(2)
  // and take all their items
  .flatMap((entry) => entry.items)

// check which nodes can be reached from the two largest groups
new Reachability({ startNodes: widestNodes })
  .run(graphComponent.graph)
  // and select all those nodes
  .reachableNodes.forEach((n) => graphComponent.selection.add(n))

Members

No filters for this type

Properties

size

: number

readonly

Returns the number of elements of this enumerable.

readonly

Implemented in

ResultItemMapping.size, ICollection.size, IListEnumerable.size

Methods

append

(items: T): IEnumerable<T>

Creates a wrapped enumerable that has one or several elements appended to it.

In contrast to concat, this method will not treat the items any special if they are array-like or enumerable-like.

Parameters

items: T: The item(s) to prepend to the enumeration

Return Value

IEnumerable<T>: A new live view over the original enumerable that has each of the items appended to it.

Examples

const list = List.fromArray([1, 2, 3, 4])

const appendedEnumerable = list.append(5, 6)
console.log(appendedEnumerable.toArray()) // yields [1,2,3,4,5,6]

// show live updates
list.add(4.5)

console.log(appendedEnumerable.toArray()) // yields [1,2,3,4,4.5,5,6]

Implemented in

List.append, YList.append

at

(index: number): T

Returns the element at the given index in this enumerable.

This is modeled after the Array.prototype.at function, with the important difference, that null will be returned instead of undefined in the case of an invalid index.

Parameters

index: number: The index of the element to return. Supports relative indexing from the end of the enumerable when passed a negative index. In other words, if a negative number is used, the returned element will be found by counting back from the end of the enumerable.

Return Value

T: The element at the given index, or null if the index is not within the valid range of this enumerable.

Examples

const enumerable = IEnumerable.from([1, 2, 3, 4])
console.log(enumerable.at(0)) // yields 1
console.log(enumerable.at(-1)) // yields 4
console.log(enumerable.at(5)) // yields null!

// using ?? for default values
console.log(enumerable.at(10) ?? 0) // yields 0
// use ! when you know that this is valid
console.log(enumerable.at(0)!.toFixed())
// use optional chaining when you are unsure whether the index is valid
console.log(enumerable.at(20)?.toFixed())
// combine optional chaining and null-coalescing operator when you are unsure
console.log(enumerable.at(30)?.toLocaleString() ?? 'no value')

Implemented in

List.at, YList.at

concat

(elements: any): IEnumerable<T>

Concatenates this enumerable with the given other elements in a new dynamic IEnumerable<T>.

The returned enumerable is dynamic, in other words, if elements are added or removed from one of the original enumerables, the returned enumerable changes, too. If you want to store the current state of the concatenation, create a list or array of it.

Parameters

elements: any: Rest arguments to be appended. In case the elements are enumerable-like, too, they will be will be enumerated after the others have been enumerated. But this can also be simple objects of type T in which case they will be appended to the enumerable just like with append

Return Value

IEnumerable<T>: A dynamic composite enumerable.

Examples

const enumerable1 = IEnumerable.from([1, 2])
const enumerable2 = IEnumerable.from([3, 4])

console.log(enumerable1.concat(enumerable2).toArray()) // yields [1,2,3,4]

// single values can be used, too
console.log(enumerable1.concat(3, 4).toArray()) // yields [1,2,3,4]

// arrays are flattened
console.log(enumerable1.concat([5, 6], [7, 8]).toArray()) // now contains [1,2,5,6,7,8]

// works with arrays and array-like collections, too
console.log(enumerable1.concat([3, 4]).toArray()) // yields [1,2,3,4]

The returned enumerable is dynamic

const list1 = List.fromArray([1, 2])
const list2 = List.fromArray([3, 4])

const result = list1.concat(list2)

console.log(result.toArray()) // yields [1,2,3,4]

list1.add(2.5)

// result changed also
console.log(result.toArray()) // yields [1,2,2.5,3,4]

list2.add(5)

// result changed also
console.log(result.toArray()) // yields [1,2,2.5,3,4,5]

Implemented in

List.concat, YList.concat

distinct

(keySelector?: function(T): any): IEnumerable<T>

Creates a wrapped enumerable that yields each element only once.

To determine equality between objects that implement a yFiles type, equals and hashCode methods are used if present.

Parameters

keySelector?: function(T): any: The optional function that determines the key to determine distinctness of the elements. If omitted, the element itself is used.

Return Value

IEnumerable<T>: A new live view over the original enumerable that yields each element with a given key at most once.

Examples

const enumerable = IEnumerable.from([1, 2, 3, 3, 4])

const result = enumerable.distinct()

console.log(result.toArray()) // yields [1,2,3,4]

Implemented in

List.distinct, YList.distinct

drop

(amount: number): IEnumerable<T>

Creates a wrapped view of an enumerable which drops the given amount of elements.

Parameters

amount: number: The number of elements to drop from the beginning. If negative, the elements will be skipped from the end of the enumeration.

Return Value

IEnumerable<T>: A new live view over the original enumerable that drops amount elements.

Examples

const enumerable = IEnumerable.from([1, 2, 3, 4, 5, 6, 7])

const result = enumerable.drop(3)

console.log(result.toArray()) // yields [4,5,6,7]

Implemented in

List.drop, YList.drop

dropWhile

(predicate: function(T, number, IEnumerable<T>): boolean): IEnumerable<T>

Creates a wrapped view of an enumerable which skips a number of elements at the beginning while the given predicate yields true.

While the predicate yields true for the elements of the original enumerable, the elements are skipped. The new enumeration will start with the first element for which the predicate yields false. All subsequent elements will be yielded.

Parameters

predicate: function(T, number, IEnumerable<T>): boolean: The predicate function that determines what elements should be skipped. While the predicate yields true for the provided item, the element will not be yielded.

Return Value

IEnumerable<T>: A new live view over the original enumerable that discards elements at the beginnging of the original enumeration while the predicate yields true.

Examples

const enumerable = IEnumerable.from([
  'a',
  'b',
  'c',
  'd',
  'a',
  'b',
  'c',
  'd',
])

const result = enumerable.dropWhile(
  (element) => element.charCodeAt(0) < 'c'.charCodeAt(0),
)

console.log(result.toArray()) // yields ["c", "d", "a", "b", "c", "d"]

Implemented in

List.dropWhile, YList.dropWhile

every

(predicate: function(T, number, IEnumerable<T>): boolean, thisArg?: any): boolean

Determines whether every element of the enumerable matches the given predicate.

Parameters

predicate: function(T, number, IEnumerable<T>): boolean: A predicate function which returns true if the element matches a condition.
thisArg?: any: The optional object to use for this in the function.

Return Value

boolean: true if all elements of the enumerable match the given predicate, false otherwise.

Throws

Exception ({ name: 'ArgumentError' }): predicate is null.

Examples

const enumerable = IEnumerable.from([1, 2, 3, 4])

console.log(enumerable.every((item) => item < 5)) // true

console.log(enumerable.every((item) => item < 4)) // false

Implemented in

List.every, YList.every

filter

(predicate: function(T, number, IEnumerable<T>): boolean, thisArg?: any): IEnumerable<T>

Returns a dynamic IEnumerable<T> of the elements of this enumerable which match the given predicate.

Parameters

predicate: function(T, number, IEnumerable<T>): boolean: A predicate function which returns true if the given element should be included in the resulting enumerable.
thisArg?: any: The optional object to use for this in the function.

Return Value

IEnumerable<T>: A dynamic enumerable of the elements which match the given predicate.

Examples

const enumerable = IEnumerable.from([10, 2, 30, 4, 5, 6])

const result = enumerable.filter((item) => item < 5)

console.log(result.toArray()) // yields [2,4]

The returned enumerable is dynamic

const list = List.fromArray([10, 2, 30, 4, 5, 6])

const result = list.filter((item) => item < 5)

list.add(1)

// result changed also
console.log(result.toArray()) // yields [2,4,1]

Implemented in

List.filter, YList.filter

filter

<TResult> (predicate: function(T, number, IEnumerable<T>): boolean, thisArg?: any): IEnumerable<TResult>

Returns a dynamic IEnumerable<T> of the elements of this enumerable which match the given type guard.

Parameters

predicate: function(T, number, IEnumerable<T>): boolean

A type predicate function which returns true if the given element is of the desired type and should be included in the resulting enumerable. The signature of the predicate must include a type guard, for example

function isFish(pet: Fish | Bird): pet is Fish {
  return (pet as Fish).swim !== undefined
}

thisArg?: any

The optional object to use for this in the function.

Return Value

IEnumerable<TResult>: A dynamic enumerable of the elements which match the given type guard.

Examples

const list = List.fromArray([1, 'a', 'b'])

list
  .filter(
    (item: string | number): item is string => typeof item === 'string',
  )
  .forEach((item: string) => console.log(item.toUpperCase())) // logs "A B"

Implemented in

List.filter, YList.filter

filter

<TResult> (predicate: function(T, number, IEnumerable<T>): boolean, thisArg?: any): IEnumerable<T & TResult>

Returns a dynamic IEnumerable<T> of the elements of this enumerable which match the given type guard.

Parameters

predicate: function(T, number, IEnumerable<T>): boolean

function isFish(pet: Fish | Bird): pet is Fish {
  return (pet as Fish).swim !== undefined
}

thisArg?: any

The optional object to use for this in the function.

Return Value

IEnumerable<T & TResult>: A dynamic enumerable of the elements which match the given type guard.

Examples

const list = List.fromArray([1, 'a', 'b'])

list
  .filter(
    (item: string | number): item is string => typeof item === 'string',
  )
  .forEach((item: string) => console.log(item.toUpperCase())) // logs "A B"

Implemented in

List.filter, YList.filter

find

(predicate: function(T, number, IEnumerable<T>): boolean, thisArg?: any): T

Returns the first element of the enumerable that matches a given predicate or null if there is no such element.

Parameters

predicate: function(T, number, IEnumerable<T>): boolean: A predicate function which returns true if the given element should be returned.
thisArg?: any: The optional object to use for this in the function.

Return Value

T: The first element of this enumerable that matches the predicate or null if there is no such element.

Examples

const enumerable = IEnumerable.from([10, 2, 3, 9, 5, 6])

console.log(enumerable.find((item) => item < 5)) // yields 2

// no matches with the given predicate
console.log(enumerable.find((item) => item < 2)) // yields null

Implemented in

List.find, YList.find

findIndex

(predicate: function(T, number, IEnumerable<T>): boolean, thisArg?: any): number

Searches the enumerable for the first item for which predicate returns true and returns its index.

Parameters

predicate: function(T, number, IEnumerable<T>): boolean: A predicate function which returns true if an item matches the search conditions.
thisArg?: any: The optional object to use for this in the function.

Return Value

number: The index of the first item for which predicate returns true or -1 if there is no such item in the enumerable.

Implemented in

List.findIndex, YList.findIndex

findLast

(predicate: function(T, number, IEnumerable<T>): boolean, thisArg?: any): T

Returns the last element of the enumerable that matches a given predicate or null if there is no such element.

Parameters

predicate: function(T, number, IEnumerable<T>): boolean: A predicate function which returns true if the given element should be returned.
thisArg?: any: The optional object to use for this in the function.

Return Value

T: The last element of this enumerable that matches the predicate or null if there is no such element.

Examples

const enumerable = IEnumerable.from([10, 2, 3, 9, 5, 6])

console.log(enumerable.findLast((item) => item < 5)) // yields 3

// no matches with the given predicate
console.log(enumerable.findLast((item) => item < 2)) // yields null

Implemented in

List.findLast, YList.findLast

findLastIndex

(predicate: function(T, number, IEnumerable<T>): boolean, thisArg?: any): number

Searches the enumerable for the last item for which predicate returns true and returns its index.

Parameters

predicate: function(T, number, IEnumerable<T>): boolean: A predicate function which returns true if an item matches the search conditions.
thisArg?: any: The optional object to use for this in the function.

Return Value

number: The index of the last item for which predicate returns true or -1 if there is no such item in the enumerable.

Implemented in

List.findLastIndex, YList.findLastIndex

first

(): T

Returns the first element of this enumerable.

Return Value

T: The first matching element of this enumerable or null if nothing was found.

Examples

const enumerable = IEnumerable.from([10, 2, 3, 9, 5, 6])

console.log(enumerable.first()) // yields 10

// returns null for empty enumerable
const empty = IEnumerable.from([])
console.log(empty.first()) // yields null

Implemented in

List.first, YList.first

flatMap

<TResult> (selector: function(T, number, IEnumerable<T>): IEnumerable<TResult>, thisArg?: any): IEnumerable<TResult>

Returns a flattened dynamic IEnumerable<T> of this enumerable using the given selector function which returns an enumerable for each element of this enumerable.

Parameters

selector: function(T, number, IEnumerable<T>): IEnumerable<TResult>: A function which returns an enumerable for each element of this enumerable.
thisArg?: any: The optional object to use for this in the function.

Return Value

IEnumerable<TResult>: A flattened dynamic enumerable of the enumerables provided for each element of this enumerable.

Examples

const enumerable = IEnumerable.from<number>([1, 2, 3])

const result = enumerable.flatMap((item) =>
  IEnumerable.from<number>([item, item * 2]),
)

console.log(result.toArray()) // yields [1,2,2,4,3,6]

The returned enumerable is dynamic

const list = List.fromArray<number[]>([[1], [2], [3]])

const result = list.flatMap((item) =>
  IEnumerable.from<number>([item[0] * 2]),
)

list.add([4])

// result changed also
console.log(result.toArray()) // yields [2,4,6,8]

Implemented in

List.flatMap, YList.flatMap

forEach

(action: function(T, number, IEnumerable<T>): void, thisArg?: any)

Iterates this enumerable and invokes the given function for each element with the element, its index, and this enumerable as arguments.

Parameters

action: function(T, number, IEnumerable<T>): void: The function to call for each element.
thisArg?: any: The optional object to use for this in the function.

Examples

const enumerable = IEnumerable.from([1, 2, 3, 4])

enumerable.forEach((item) => console.log(item)) // 1 2 3 4

// accessing the index
enumerable.forEach((item, index) =>
  console.log(`Item #${index} is ${item}`),
)

Implemented in

List.forEach, YList.forEach

getEnumerator

(): IEnumerator<T>

abstract

Gets an IEnumerator<T> which can be used to enumerate the items this instance represents.

This is the low-level API that needs to be implemented by all enumerables. Clients will only have to use this API, rarely, as iteration is more conveniently handled by the forEach method or using the iterable (for(let item of enumerable){}) protocol.

abstract

Return Value

IEnumerator<T>: The IEnumerator<T> which can be used to iterate over the items in this instance

Examples

Low-level enumerator usage

const enumerable = IEnumerable.from([1, 2, 3, 4])

const enumerator = enumerable.getEnumerator()
while (enumerator.moveNext()) {
  console.log(enumerator.current)
}
// 1 2 3 4

// enumerators can be reused
enumerator.reset()
while (enumerator.moveNext()) {
  console.log(enumerator.current)
}
// 1 2 3 4

Implemented in

ResultItemMapping.getEnumerator, ResultItemCollection.getEnumerator, List.getEnumerator, ListEnumerable.getEnumerator, List.getEnumerator, YList.getEnumerator, HashMap.getEnumerator, ObservableCollection.getEnumerator, YList.getEnumerator, StripeSelection.getEnumerator

groupBy

<TKey, TResult> (keySelector: function(T, number, IEnumerable<T>): TKey, resultCreator?: function(TKey, IEnumerable<T>, number): TResult): IEnumerable<TResult>

Groups the elements in the enumerable according to the equality of a key.

For each element in the original enumerable the keySelector will be used to retrieve a key. All elements with the same key will be provided to the optional resultCreator function that receives both the key, and an IEnumerable<T> of the elements that match that key to create a resulting object that will be yielded by this enumerable. Note that the resulting enumerable does not necessarily preserve the order of the (first) appearance of their elements in the original sequence. The elements of each group passed to the resultCreator are in the order of their original appearance.

This implementation differs from the TC39 proposal for array grouping. See the example "Using groupBy to create an object" to mimic the proposal's groupBy behavior.

Parameters

keySelector: function(T, number, IEnumerable<T>): TKey: A function which selects from each element the key.
resultCreator?: function(TKey, IEnumerable<T>, number): TResult: An optional function which transforms each group of elements and their common key into a resulting object. If omitted, the default implementation will create arrays of length 2 where the first element is the key and the second element is an IEnumerable<TSource> of the elements with the corresponding key.

Return Value

IEnumerable<TResult>: An enumeration of groups of the original enumerable.

Examples

A simple groupBy example

const enumerable = IEnumerable.from([
  { type: 'A', amount: 1 },
  { type: 'A', amount: 2 },
  { type: 'B', amount: 4 },
])

// without result creator
const groups1 = enumerable.groupBy<string, string>(
  (element) => element.type,
)

for (const g of groups1) {
  console.log(`Type is ${g[0]} and has ${g[1].length} members.`)
}
// Type is A and has 2 members.
// Type is B and has 1 members.

// with result creator
const groups2 = enumerable.groupBy(
  (element) => element.type,
  (type, elements) => ({
    type,
    amount: elements.sum((item) => item.amount),
  }),
)

console.log(groups2.toArray()) // yields [{"type":"A","amount":4},{"type":"B","amount":4}]

groupBy with index

const val = IEnumerable.ofRange(1, 10)
  .groupBy(
    (value, index) => index % 2,
    (key, items, index) => [`key ${index % 2}`, items.toArray()],
  )
  .toArray()

// [
//   ["key 0",[1,3,5,7,9]],
//   ["key 1",[2,4,6,8,10]]
// ]

Using groupBy to create an object

const enumerable: IEnumerable<{ value: number; key: string }> =
  IEnumerable.from([
    { value: 0, key: 'a' },
    { value: 1, key: 'b' },
    { value: 2, key: 'b' },
    { value: 3, key: 'a' },
  ])

const obj = Object.fromEntries(
  enumerable.groupBy(
    (item) => item.key,
    (key, items) => [key, items.toArray()],
  ) as Iterable<[unknown, unknown]>,
)

// {
//   a: [{value:0, key:a}, {value:3, key:a}],
//   b: [{value:1, key:b}, {value:2, key:b}]
// }

Implemented in

List.groupBy, YList.groupBy

includes

(value: T): boolean

Determines whether the given value is part of this enumerable.

Parameters

value: T: The value to search for.

Return Value

boolean: true if this enumerable contains the given value, false otherwise.

Examples

const enumerable = IEnumerable.from([1, 2, 3, 4])

console.log(enumerable.includes(2)) // true

console.log(enumerable.includes(5)) // false

Implemented in

ICollection.includes, List.includes, YList.includes

indexOf

(item: T, fromIndex?: number): number

The index of the given item in the enumerable.

Parameters

item: T: The item to search for.
fromIndex?: number: An optional start index for the search.

Return Value

number: The index of the given item in the enumerable. -1 if the item is not in the enumerable.

Implemented in

List.indexOf, YList.indexOf

last

(): T

Returns the last element of this enumerable.

Return Value

T: The last element of this enumerable, or null if the enumerable is empty.

Examples

const enumerable = IEnumerable.from([1, 2, 3, 4])
console.log(enumerable.last()) // yields 4

// if the enumerable is empty null will be returned
const empty = IEnumerable.from([])
console.log(empty.last()) // yields null

Implemented in

List.last, YList.last

map

<TResult> (selector: function(T, number, IEnumerable<T>): TResult, thisArg?: any): IEnumerable<TResult>

Returns a dynamic IEnumerable<T> of this enumerable using the given selector function which returns a new object for each element of this enumerable.

Parameters

selector: function(T, number, IEnumerable<T>): TResult: A function which converts each element into a new element of the type TResult.
thisArg?: any: The optional value to use as this when executing the selector.

Return Value

IEnumerable<TResult>: A dynamic enumerable of the results of the provided function.

Examples

const enumerable = IEnumerable.from([1, 2, 3])

const result = enumerable.map((item) => item * 2)

console.log(result.toArray()) // yields [2, 4, 6]

// with index
const result2 = enumerable.map((item, index) => item * index)

console.log(result2.toArray()) // yields [0, 2, 6]

// with index and enumerable
const result3 = enumerable.map(
  (item, index, enumerable) =>
    `Item no ${index} of ${enumerable.size} is ${item}`,
)

console.log(result3.toArray())
// ["Item no 0 of 3 is 1","Item no 1 of 3 is 2","Item no 2 of 3 is 3"]

The returned enumerable is dynamic

const list = List.fromArray([1, 2, 3])

const result = list.map((item) => item * 2)

list.add(4)

// result changed also
console.log(result.toArray()) // yields [2,4,6,8]

Implemented in

List.map, YList.map

ofType

(resultType: typeof Number): IEnumerable<number>

Converts this untyped enumerable into an enumerable with the given type.

The source enumerable may contain elements which are not of the given type. Those elements will not be contained in the returned enumerable.

Parameters

resultType: typeof Number: The type of the elements of the result enumerable.

Return Value

IEnumerable<number>: A typed enumerable.

Implemented in

List.ofType, YList.ofType

ofType

(resultType: typeof String): IEnumerable<string>

Converts this untyped enumerable into an enumerable with the given type.

The source enumerable may contain elements which are not of the given type. Those elements will not be contained in the returned enumerable.

Parameters

resultType: typeof String: The type of the elements of the result enumerable.

Return Value

IEnumerable<string>: A typed enumerable.

Implemented in

List.ofType, YList.ofType

ofType

(resultType: typeof Boolean): IEnumerable<boolean>

Converts this untyped enumerable into an enumerable with the given type.

The source enumerable may contain elements which are not of the given type. Those elements will not be contained in the returned enumerable.

Parameters

resultType: typeof Boolean: The type of the elements of the result enumerable.

Return Value

IEnumerable<boolean>: A typed enumerable.

Implemented in

List.ofType, YList.ofType

ofType

<TResult> (resultType: Constructor<TResult>): IEnumerable<TResult>

Converts this untyped enumerable into an enumerable with the given type.

The source enumerable may contain elements which are not of the given type. Those elements will not be contained in the returned enumerable.

Parameters

resultType: Constructor<TResult>: The type of the elements of the result enumerable.

Return Value

IEnumerable<TResult>: A typed enumerable.

Implemented in

List.ofType, YList.ofType

prepend

(items: T): IEnumerable<T>

Creates a wrapped enumerable that has on or several elements prepended to it.

Parameters

items: T: The item(s) to prepend to the enumeration

Return Value

IEnumerable<T>: A new live view over the original enumerable that has items prepended to it.

Examples

const enumerable1 = IEnumerable.from([1, 2, 3, 4])
console.log(enumerable1.prepend(0).toArray()) // yields [0,1,2,3,4]

// more than one value can be used too
const enumerable2 = IEnumerable.from([3, 4, 5, 6])
console.log(enumerable2.prepend(1, 2).toArray()) // yields [1,2,3,4,5,6]

Implemented in

List.prepend, YList.prepend

reduce

(accumulator: function(T, T, number, IEnumerable<T>): T): T

Applies the accumulator function to this elements of this enumerable.

Parameters

accumulator: function(T, T, number, IEnumerable<T>): T: A function which "adds" (accumulates) a value depending on the element and index to the initial value and returns the result.

Return Value

T: The result of the accumulation.

Examples

const enumerable = IEnumerable.from([1, 2, 3, 4, 5])

const result = enumerable.reduce(
  (accumulator, currentValue) => accumulator + currentValue,
)

console.log(result) // expected output: 15

Implemented in

List.reduce, YList.reduce

reduce

<TAccumulate> (accumulator: function(TAccumulate, T, number, IEnumerable<T>): TAccumulate, initialValue: TAccumulate): TAccumulate

Applies the accumulator function to this elements of this enumerable.

Parameters

accumulator: function(TAccumulate, T, number, IEnumerable<T>): TAccumulate: A function which "adds" (accumulates) a value depending on the element and index to the initial value and returns the result.
initialValue: TAccumulate: The initial value for the accumulator. Omit/use the reduce overload if you don't want to specify an initial value.

Return Value

TAccumulate: The result of the accumulation.

Examples

The returned enumerable is dynamic

const enumerable = IEnumerable.from([1, 2, 3, 4, 5])

const result = enumerable.reduce(
  (accumulator, currentValue) => Math.max(accumulator, currentValue),
  0,
)

console.log(result) // expected output: 5

Implemented in

List.reduce, YList.reduce

reduceRight

(accumulator: function(T, T, number, IEnumerable<T>): T): T

Applies the accumulator function to this elements of this enumerable in reverse order.

Parameters

accumulator: function(T, T, number, IEnumerable<T>): T: A function which "adds" (accumulates) a value depending on the element and index to the seed value and returns the result.

Return Value

T: The result of the accumulation.

Examples

const enumerable = IEnumerable.from([
  [0, 1],
  [2, 3],
  [4, 5],
])

const result = enumerable.reduceRight((accumulator, currentValue) =>
  accumulator.concat(currentValue),
)

console.log(result) // yields [4,5,2,3,0,1]

Implemented in

List.reduceRight, YList.reduceRight

reduceRight

<TAccumulate> (accumulator: function(TAccumulate, T, number, IEnumerable<T>): TAccumulate, initialValue: TAccumulate): TAccumulate

Applies the accumulator function to this elements of this enumerable in reverse order.

Parameters

accumulator: function(TAccumulate, T, number, IEnumerable<T>): TAccumulate: A function which "adds" (accumulates) a value depending on the element and index to the seed value and returns the result.
initialValue: TAccumulate: The initial value for the accumulator. Omit/use the reduceRight overload if you don't want to specify an initial value.

Return Value

TAccumulate: The final value of the accumulation.

Examples

The returned enumerable is dynamic

const enumerable = IEnumerable.from(['a', 'b', 'c', 'd'])

const result = enumerable.reduceRight(
  (accumulator, currentValue) => currentValue + accumulator,
  '.',
)

console.log(result) // yields 'abcd.'

Implemented in

List.reduceRight, YList.reduceRight

some

(predicate?: function(T, number, IEnumerable<T>): boolean, thisArg?: any): boolean

Determines whether this enumerable contains any elements matching the given predicate.

Parameters

Show options overload

predicate?: function(T, number, IEnumerable<T>): boolean: A function which returns true if the element matches a condition.
thisArg?: any: The optional object to use for this in the function.

Return Value

boolean: Whether this enumerable contains any elements matching the given predicate.

Examples

const enumerable = IEnumerable.from([1, 2, 3, 4, 5, 6, 7])

const result = enumerable.some((item) => item % 2 === 0)

console.log(result) // true

Implemented in

List.some, YList.some

sum

(selector: function(T, number, IEnumerable<T>): number): number

Calculates the sum of the elements of this enumerable.

Parameters

selector: function(T, number, IEnumerable<T>): number: A function which returns a numeric value for the given element.

Return Value

number: The sum of the elements of the enumerable.

Examples

const enumerable = IEnumerable.from([
  { type: 'A', amount: 3 },
  { type: 'B', amount: 2 },
  { type: 'C', amount: 2 },
  { type: 'D', amount: 5 },
])

const result = enumerable.sum((element) => element.amount)

console.log(result) // yields 12

Implemented in

List.sum, YList.sum

take

(count: number): IEnumerable<T>

Creates a dynamic view of this enumerable with the given number of elements taken from the start or end of this enumerable.

Parameters

count: number: The number of elements in the created enumerable. If the number is positive, the elements are taken from the beginning, otherwise, the elements are taken from the end.

Return Value

IEnumerable<T>: A dynamic iew of this enumerable with the given number of elements.

Examples

const enumerable = IEnumerable.from([1, 2, 3, 4, 5, 6, 7])

// positive parameter means taking elements from the beginning of the enumerable
console.log(enumerable.take(2).toArray()) // yields [1,2]

// negative parameter means taking elements from the end of the enumerable
console.log(enumerable.take(-2).toArray()) // yields [6,7]

Implemented in

List.take, YList.take

takeWhile

(predicate: function(T, number, IEnumerable<T>): boolean): IEnumerable<T>

Returns a dynamic IEnumerable<T> that contains the elements from this enumerable as long as the given predicate is true.

Parameters

predicate: function(T, number, IEnumerable<T>): boolean: A function which returns true as long as the elements should be added to the returned enumerable.

Return Value

IEnumerable<T>: A dynamic enumerable that is a subset of the original enumerable.

Examples

const enumerable = IEnumerable.from([1, 2, 3, 30, 4, 5])

const result = enumerable.takeWhile((item) => item < 5)

console.log(result.toArray()) // yields [1,2,3]

Implemented in

List.takeWhile, YList.takeWhile

toArray

(): T

Creates an array with the elements of this enumerable.

Return Value

T: An array with the elements of this enumerable.

Implemented in

List.toArray, YList.toArray

toList

(): List<T>

Creates a List<T> with the values of this enumerable.

Return Value

List<T>: A List<T> of the elements of this enumerable.

Implemented in

List.toList, YList.toList

toReversed

(): IEnumerable<T>

Returns an dynamic enumerable which contains the elements of this enumerable in reverse order.

Return Value

IEnumerable<T>: A dynamic enumerable which contains the elements of the original enumerable in reverse order.

Examples

const enumerable = IEnumerable.from([1, 2, 3, 4, 5])

const result = enumerable.toReversed()

console.log(result.toArray()) // yields [5,4,3,2,1]

The returned enumerable is dynamic

const list = List.fromArray([1, 2, 3, 4, 5])

const result = list.toReversed()

list.add(0)

// result changed also
console.log(result.toArray()) // yields [0,5,4,3,2,1]

Implemented in

List.toReversed, YList.toReversed

toSorted

(comparator?: function(T, T): number): IEnumerable<T>

Yields an ordered enumerable of the elements given an optional comparison function.

The sorting will happen each time the enumerable is enumerated.

Parameters

comparator?: function(T, T): number: A function with the signature (a, b) => number which is used for the sort operation to compare the elements in the enumerable. May be omitted. If omitted, the elements are sorted by converting them to strings first. Numbers are sorted as numbers without converting them to strings (this is different to the EcmaScript implementation).

Return Value

IEnumerable<T>: A sorted enumeration of the original enumerable.

Examples

const enumerable = IEnumerable.from([
  { type: 'name-6', rank: 8 },
  { type: 'name-23', rank: 4 },
  { type: 'name-3', rank: 5 },
])

// order by the elements' rank
const sortedEnumerable1 = enumerable.toSorted(
  (entryA, entryB) => entryA.rank - entryB.rank,
)

console.log(sortedEnumerable1.toArray())
// [{ "type": "name-23", "rank": 4 }, { "type": "name-3", "rank": 5 }, { "type": "name-6", "rank": 8 }]

// order by the elements' type using numeric collation to get a more "natural" order, with a comparer function
const collator = new Intl.Collator(undefined, {
  numeric: true,
  sensitivity: 'base',
})
const sortedEnumerable2 = enumerable.toSorted((entryA, entryB) =>
  collator.compare(entryA.type, entryB.type),
)

console.log(sortedEnumerable2.toArray())
// [{ "type": "name-3", "rank": 5 }, { "type": "name-6", "rank": 8 },{ "type": "name-23", "rank": 4 }]

Implemented in

List.toSorted, YList.toSorted

Constants

EMPTY

: IEnumerable<T>

static

An empty, immutable instance of IEnumerable<T>.

Static Methods

from

<T> (value: IEnumerable<T>): IEnumerable<T>

static

Creates an enumerable from a given array or enumerable-like object.

static

Parameters

value: IEnumerable<T>: The object that is either array-like, an enumerable, a generator instance, or a generator function.

Return Value

IEnumerable<T>: A new instance that may be a view of the given argument.

Examples

Creating enumerable views

const array = [1, 2, 3, 4, 5, 6, 7]

const enumerable = IEnumerable.from(array)

const result = enumerable.drop(3)

console.log(result.size) // yields 4

// arrays are converted to live enumerables
array.push(8)

console.log(result.size) // yields 5

function* generator(i: number): Generator<number, void> {
  yield i
  yield i + 10
}

// iterables will evaluate lazy, but will close upon depletion
// and can only be enumerated once, because the generator
// cannot be reevaluated after the iterable closes
const generatedEnum = IEnumerable.from(generator(5))
console.log(generatedEnum.last()) // yields 15
console.log(generatedEnum.size) // yields 0, now, because it's empty

const data = [1, 2, 3]
function* dynamicGenerator(): Generator<number> {
  yield 0
  for (const value of data) {
    yield value
  }
}

// generator functions are also live and evaluate lazily
// note the missing invocation of the parameter
const dynamicEnumerable = IEnumerable.from(dynamicGenerator)
console.log(dynamicEnumerable.last()) // yields 3
data.push(4)
// causes the generator to reevaluate
console.log(dynamicEnumerable.last()) // yields 4

ofRange

(from: number, count: number): IEnumerable<number>

static

Creates an enumerable that consists of the sequence of increasing values starting with from and a length of count.

For each element the value returned will increase by 1.

static

Parameters

from: number: the first value to yield
count: number: the number of values to yield

Return Value

IEnumerable<number>: A new enumerable that can yield count numbers starting with from.

Examples

const enumerable = IEnumerable.ofRange(10, 4)

console.log(enumerable.toArray()) // yields [10,11,12,13]

ofRepeat

<T> (item: T, count: number): IEnumerable<T>

static

Creates an enumerable that consists of count items.

static

Parameters

item: T: The element to yield.
count: number: The number of elements the new enumerable yields.

Return Value

IEnumerable<T>: A new enumerable that can yield count items

Examples

const enumerable = IEnumerable.ofRepeat(10, 4)

console.log(enumerable.toArray()) // yields [10,10,10,10]

IEnumerable<T>

Remarks

Type Parameters

T

Examples

See Also

Developer's Guide

API

Members

Properties

size

Implemented in

Methods

append

Parameters

Return Value

Examples

See Also

API

Implemented in

at

Parameters

Return Value

Examples

Implemented in

concat

Parameters

Return Value

Examples

See Also

API

Implemented in

distinct

Parameters

Return Value

Examples

See Also

API

Implemented in

drop

Parameters

Return Value

Examples

See Also

API

Implemented in

dropWhile

Parameters

Return Value

Examples

See Also

API

Implemented in

every

Parameters

Return Value

Throws

Examples

Implemented in

filter

Parameters

Return Value

Examples

Implemented in

filter

Parameters

Return Value

Examples

Implemented in

filter

Parameters

Return Value

Examples

Implemented in

find

Parameters

Return Value

Examples

Implemented in

findIndex