Sequence | Sequency

A Sequence provides a fluent functional API consisting of various intermediate and terminal operations for processing the iterated data. The operations are evaluated lazily to avoid examining all the input data when it's not necessary. Sequences can be iterated only once.

Type parameters

Hierarchy

SequenceOperators<T>
- Sequence

Properties

Readonly iterator

iterator: Iterator<T, any, undefined>

Methods

all

all<T>(this: Sequence<T>, predicate: (item: T) => boolean): boolean

Inherited from SequenceOperators.all
- Defined in all.ts:11
Returns true if all elements match the given predicate.

Type parameters
- T
Parameters
- this: Sequence<T>
- predicate: (item: T) => boolean
  - - (item: T): boolean
    - Parameters
      - item: T
      Returns boolean
Returns boolean

any

any<T>(this: Sequence<T>, predicate?: (item: T) => boolean): boolean

Inherited from SequenceOperators.any
- Defined in any.ts:11
Returns true if at least one element match the given predicate.

Type parameters
- T
Parameters
- this: Sequence<T>
- Optional predicate: (item: T) => boolean
  - - (item: T): boolean
    - Parameters
      - item: T
      Returns boolean
Returns boolean

asIterable

asIterable<T>(this: Sequence<T>): Iterable<T>

Inherited from SequenceOperators.asIterable
- Defined in asIterable.ts:10
Returns an iterable representation of the sequence.

Type parameters
- T
Parameters
- this: Sequence<T>
Returns Iterable<T>

associate

associate<T, K, V>(this: Sequence<T>, transform: (value: T) => [K, V]): Map<K, V>

Inherited from SequenceOperators.associate
- Defined in associate.ts:12
Transforms each element into a key-value pair and returns the results as map. In case of duplicate keys the last key-value pair overrides the other.

Type parameters
- T
- K
- V
Parameters
- this: Sequence<T>
- transform: (value: T) => [K, V]
  - - (value: T): [K, V]
    - Parameters
      - value: T
      Returns [K, V]
Returns Map<K, V>

associateBy

associateBy<K>(keySelector: (value: T) => K): Map<K, T>
associateBy<K>(key: K): Map<T[K], T>
associateBy<K, V>(keySelector: (value: T) => K, valueTransformer: (value: T) => V): Map<K, V>
associateBy<K, V>(key: K, valueTransformer: (value: T) => V): Map<T[K], V>

Inherited from SequenceOperators.associateBy
- Defined in associateBy.ts:11
Returns a map consisting of the elements mapped by the given keySelector.

Type parameters
- K
Parameters
- keySelector: (value: T) => K
  - - (value: T): K
    - Parameters
      - value: T
      Returns K
Returns Map<K, T>
Inherited from SequenceOperators.associateBy
- Defined in associateBy.ts:19
Returns a map consisting of the elements indexed by the given key.

Type parameters
- K: string | number | symbol
Parameters
- key: K
Returns Map<T[K], T>
Inherited from SequenceOperators.associateBy
- Defined in associateBy.ts:29
Returns a map consisting of the elements mapped by the given keySelector. The value is transformed into another value by the valueTransformer.

Type parameters
- K
- V
Parameters
- keySelector: (value: T) => K
  - - (value: T): K
    - Parameters
      - value: T
      Returns K
- valueTransformer: (value: T) => V
  - - (value: T): V
    - Parameters
      - value: T
      Returns V
Returns Map<K, V>
Inherited from SequenceOperators.associateBy
- Defined in associateBy.ts:39
Returns a map consisting of the elements indexed by the given key. The value is transformed into another value by the valueTransformer.

Type parameters
- K: string | number | symbol
- V
Parameters
- key: K
- valueTransformer: (value: T) => V
  - - (value: T): V
    - Parameters
      - value: T
      Returns V
Returns Map<T[K], V>

average

average(this: Sequence<number>): number

Inherited from SequenceOperators.average
- Defined in average.ts:10
Returns the average of all numbers of the sequence or NaN if the sequence is empty.

Parameters
- this: Sequence<number>
Returns number

chunk

chunk<T>(this: Sequence<T>, chunkSize: number): T[][]

Inherited from SequenceOperators.chunk
- Defined in chunk.ts:12
Splits the elements of the sequence into arrays which length is determined by the given chunkSize and returns all chunks as array.

Type parameters
- T
Parameters
- this: Sequence<T>
- chunkSize: number
Returns T[][]

contains

contains<T>(this: Sequence<T>, element: T): boolean

Inherited from SequenceOperators.contains
- Defined in contains.ts:11
Returns true if the sequence contains the given element.

Type parameters
- T
Parameters
- this: Sequence<T>
- element: T
Returns boolean

count

count<T>(this: Sequence<T>, predicate?: (item: T) => boolean): number

Inherited from SequenceOperators.count
- Defined in count.ts:12
Returns the number of elements of this sequence. If predicate is present, returns the number of elements matching the given predicate.

Type parameters
- T
Parameters
- this: Sequence<T>
- Optional predicate: (item: T) => boolean
  - - (item: T): boolean
    - Parameters
      - item: T
      Returns boolean
Returns number

distinct

distinct<T>(this: Sequence<T>): Sequence<T>

Inherited from SequenceOperators.distinct
- Defined in distinct.ts:29
Returns a new sequence which discards all duplicate elements.

Type parameters
- T
Parameters
- this: Sequence<T>
Returns Sequence<T>

distinctBy

distinctBy<T, K>(this: Sequence<T>, selector: (item: T) => K): Sequence<T>

Inherited from SequenceOperators.distinctBy
- Defined in distinctBy.ts:33
Returns a new sequence which discards all elements with duplicate items determined by the given selector.

Type parameters
- T
- K
Parameters
- this: Sequence<T>
- selector: (item: T) => K
  - - (item: T): K
    - Parameters
      - item: T
      Returns K
Returns Sequence<T>

drop

drop<T>(this: Sequence<T>, n: number): Sequence<T>

Inherited from SequenceOperators.drop
- Defined in drop.ts:11
Returns a new sequence which discards the first n elements;

Type parameters
- T
Parameters
- this: Sequence<T>
- n: number
Returns Sequence<T>

dropWhile

dropWhile<T>(this: Sequence<T>, predicate: (item: T) => boolean): Sequence<T>

Inherited from SequenceOperators.dropWhile
- Defined in dropWhile.ts:33
Drops all elements of the sequence as long as the given predicate evaluates to true.

Type parameters
- T
Parameters
- this: Sequence<T>
- predicate: (item: T) => boolean
  - - (item: T): boolean
    - Parameters
      - item: T
      Returns boolean
Returns Sequence<T>

elementAt

elementAt<T>(this: Sequence<T>, index: number): T

Inherited from SequenceOperators.elementAt
- Defined in elementAt.ts:12
Returns the element at position index (zero-based) or throws an error if index is out of bounds.

Type parameters
- T
Parameters
- this: Sequence<T>
- index: number
Returns T

elementAtOrElse

elementAtOrElse<T>(this: Sequence<T>, index: number, defaultValue: (index: number) => T): T

Inherited from SequenceOperators.elementAtOrElse
- Defined in elementAtOrElse.ts:13
Returns the element at position index (zero-based). If index is out of bounds returns the result of the given defaultValue function.

Type parameters
- T
Parameters
- this: Sequence<T>
- index: number
- defaultValue: (index: number) => T
  - - (index: number): T
    - Parameters
      - index: number
      Returns T
Returns T

elementAtOrNull

elementAtOrNull<T>(this: Sequence<T>, index: number): null | T

Inherited from SequenceOperators.elementAtOrNull
- Defined in elementAtOrNull.ts:12
Returns the element at position index (zero-based) or null if index is out of bounds.

Type parameters
- T
Parameters
- this: Sequence<T>
- index: number
Returns null | T

filter

filter<T>(this: Sequence<T>, predicate: (item: T) => boolean): Sequence<T>

Inherited from SequenceOperators.filter
- Defined in filter.ts:26
Returns a new sequence consisting of all elements that match the given predicate.

Type parameters
- T
Parameters
- this: Sequence<T>
- predicate: (item: T) => boolean
  - - (item: T): boolean
    - Parameters
      - item: T
      Returns boolean
Returns Sequence<T>

filterIndexed

filterIndexed<T>(this: Sequence<T>, predicate: (index: number, value: T) => boolean): Sequence<T>

Inherited from SequenceOperators.filterIndexed
- Defined in filterIndexed.ts:11
Returns a new sequence consisting of all elements that match the given predicate.

Type parameters
- T
Parameters
- this: Sequence<T>
- predicate: (index: number, value: T) => boolean
  - - (index: number, value: T): boolean
    - Parameters
      - index: number
      - value: T
      Returns boolean
Returns Sequence<T>

filterNot

filterNot<T>(this: Sequence<T>, predicate: (value: T) => boolean): Sequence<T>

Inherited from SequenceOperators.filterNot
- Defined in filterNot.ts:11
Returns a new sequence consisting of all elements that don't match the given predicate.

Type parameters
- T
Parameters
- this: Sequence<T>
- predicate: (value: T) => boolean
  - - (value: T): boolean
    - Parameters
      - value: T
      Returns boolean
Returns Sequence<T>

filterNotNull

filterNotNull<T>(this: Sequence<null | T>): Sequence<T>

Inherited from SequenceOperators.filterNotNull
- Defined in filterNotNull.ts:10
Returns a new sequence consisting of all non-null elements.

Type parameters
- T
Parameters
- this: Sequence<null | T>
Returns Sequence<T>

find

find<T>(this: Sequence<T>, predicate?: (item: T) => boolean): null | T

Inherited from SequenceOperators.find
- Defined in firstOrNull.ts:27
Returns the first element of the sequence or the first element matching predicate if present, otherwise returns null.

Type parameters
- T
Parameters
- this: Sequence<T>
- Optional predicate: (item: T) => boolean
  - - (item: T): boolean
    - Parameters
      - item: T
      Returns boolean
Returns null | T

findLast

findLast<T>(this: Sequence<T>, predicate?: (value: T) => boolean): null | T

Inherited from SequenceOperators.findLast
- Defined in lastOrNull.ts:28
Returns the last element of the sequence or the last element matching predicate if present, otherwise returns null.

Type parameters
- T
Parameters
- this: Sequence<T>
- Optional predicate: (value: T) => boolean
  - - (value: T): boolean
    - Parameters
      - value: T
      Returns boolean
Returns null | T

first

first<T>(this: Sequence<T>, predicate?: (item: T) => boolean): T

Inherited from SequenceOperators.first
- Defined in first.ts:12
Returns the first element of the sequence or the first element matching predicate if present, otherwise throws an error.

Type parameters
- T
Parameters
- this: Sequence<T>
- Optional predicate: (item: T) => boolean
  - - (item: T): boolean
    - Parameters
      - item: T
      Returns boolean
Returns T

firstOrNull

firstOrNull<T>(this: Sequence<T>, predicate?: (item: T) => boolean): null | T

Inherited from SequenceOperators.firstOrNull
- Defined in firstOrNull.ts:11
Returns the first element of the sequence or the first element matching predicate if present, otherwise returns null.

Type parameters
- T
Parameters
- this: Sequence<T>
- Optional predicate: (item: T) => boolean
  - - (item: T): boolean
    - Parameters
      - item: T
      Returns boolean
Returns null | T

flatMap

flatMap<S, T>(this: Sequence<S>, transform: (value: S) => Sequence<T>): Sequence<T>

Inherited from SequenceOperators.flatMap
- Defined in flatMap.ts:35
Transforms each element into a sequence of items and returns a flat single sequence of all those items.

Type parameters
- S
- T
Parameters
- this: Sequence<S>
- transform: (value: S) => Sequence<T>
  - - (value: S): Sequence<T>
    - Parameters
      - value: S
      Returns Sequence<T>
Returns Sequence<T>

flatten

flatten<T>(this: Sequence<Sequence<T> | Iterable<T>>): Sequence<T>

Inherited from SequenceOperators.flatten
- Defined in flatten.ts:10
Returns a single flat sequence of all the items from all sequences or iterables.

Type parameters
- T
Parameters
- this: Sequence<Sequence<T> | Iterable<T>>
Returns Sequence<T>

fold

fold<T, R>(this: Sequence<T>, initial: R, operation: (acc: R, element: T) => R): R

Inherited from SequenceOperators.fold
- Defined in fold.ts:14
Accumulates all elements of the sequence into a single result by applying the given operation starting with the initial value. The result of the last operation will be passed as accumulated value to the getNext invocation of the operation until all elements of the sequence are processed.

Type parameters
- T
- R
Parameters
- this: Sequence<T>
- initial: R
- operation: (acc: R, element: T) => R
  - - (acc: R, element: T): R
    - Parameters
      - acc: R
      - element: T
      Returns R
Returns R

foldIndexed

foldIndexed<T, R>(this: Sequence<T>, initial: R, operation: (index: number, acc: R, element: T) => R): R

Inherited from SequenceOperators.foldIndexed
- Defined in foldIndexed.ts:15
Accumulates all elements of the sequence into a single result by applying the given operation starting with the initial value. The result of the last operation will be passed as accumulated value to the getNext invocation of the operation as well as the index of the current element (zero-based) until all elements of the sequence are processed.

Type parameters
- T
- R
Parameters
- this: Sequence<T>
- initial: R
- operation: (index: number, acc: R, element: T) => R
  - - (index: number, acc: R, element: T): R
    - Parameters
      - index: number
      - acc: R
      - element: T
      Returns R
Returns R

forEach

forEach<T>(this: Sequence<T>, action: (item: T) => void): void

Inherited from SequenceOperators.forEach
- Defined in forEach.ts:10
Performs the given action (side-effect) for each element of the sequence.

Type parameters
- T
Parameters
- this: Sequence<T>
- action: (item: T) => void
  - - (item: T): void
    - Parameters
      - item: T
      Returns void
Returns void

forEachIndexed

forEachIndexed<T>(this: Sequence<T>, action: (index: number, value: T) => void): void

Inherited from SequenceOperators.forEachIndexed
- Defined in forEachIndexed.ts:11
Performs the given action (side-effect) for each element of the sequence and passes the index of the current element (zero-based).

Type parameters
- T
Parameters
- this: Sequence<T>
- action: (index: number, value: T) => void
  - - (index: number, value: T): void
    - Parameters
      - index: number
      - value: T
      Returns void
Returns void

groupBy

groupBy<T, K>(this: Sequence<T>, keySelector: (value: T) => K): Map<K, T[]>

Inherited from SequenceOperators.groupBy
- Defined in groupBy.ts:11
Groups all elements of the sequence into a map. Keys are determined by the given keySelector function.

Type parameters
- T
- K
Parameters
- this: Sequence<T>
- keySelector: (value: T) => K
  - - (value: T): K
    - Parameters
      - value: T
      Returns K
Returns Map<K, T[]>

indexOf

indexOf<T>(this: Sequence<T>, element: T): number

Inherited from SequenceOperators.indexOf
- Defined in indexOf.ts:11
Returns the zero-based index of the given element or -1 if the sequence does not contain the element.

Type parameters
- T
Parameters
- this: Sequence<T>
- element: T
Returns number

indexOfFirst

indexOfFirst<T>(this: Sequence<T>, predicate: (value: T) => boolean): number

Inherited from SequenceOperators.indexOfFirst
- Defined in indexOfFirst.ts:12
Returns the zero-based index of the first element matching the given predicate or -1 if no element matches the predicate.

Type parameters
- T
Parameters
- this: Sequence<T>
- predicate: (value: T) => boolean
  - - (value: T): boolean
    - Parameters
      - value: T
      Returns boolean
Returns number

indexOfLast

indexOfLast<T>(this: Sequence<T>, predicate: (value: T) => boolean): number

Inherited from SequenceOperators.indexOfLast
- Defined in indexOfLast.ts:12
Returns the zero-based index of the last element matching the given predicate or -1 if no element matches the predicate.

Type parameters
- T
Parameters
- this: Sequence<T>
- predicate: (value: T) => boolean
  - - (value: T): boolean
    - Parameters
      - value: T
      Returns boolean
Returns number

joinTo

joinTo<T>(this: Sequence<T>, config?: JoinConfig<T>): string

Inherited from SequenceOperators.joinTo
- Defined in joinToString.ts:73
Joins all elements of the sequence into a string with the given configuration.

Type parameters
- T
Parameters
- this: Sequence<T>
- config: JoinConfig<T> = defaults
Returns string

joinToString

joinToString<T>(this: Sequence<T>, config?: JoinConfig<T>): string

Inherited from SequenceOperators.joinToString
- Defined in joinToString.ts:31
Joins all elements of the sequence into a string with the given configuration.

Type parameters
- T
Parameters
- this: Sequence<T>
- config: JoinConfig<T> = defaults
Returns string

last

last<T>(this: Sequence<T>, predicate?: (value: T) => boolean): T

Inherited from SequenceOperators.last
- Defined in last.ts:12
Returns the last element of the sequence or the last element matching predicate if present, otherwise throws an error.

Type parameters
- T
Parameters
- this: Sequence<T>
- Optional predicate: (value: T) => boolean
  - - (value: T): boolean
    - Parameters
      - value: T
      Returns boolean
Returns T

lastOrNull

lastOrNull<T>(this: Sequence<T>, predicate?: (value: T) => boolean): null | T

Inherited from SequenceOperators.lastOrNull
- Defined in lastOrNull.ts:11
Returns the last element of the sequence or the last element matching predicate if present, otherwise returns null.

Type parameters
- T
Parameters
- this: Sequence<T>
- Optional predicate: (value: T) => boolean
  - - (value: T): boolean
    - Parameters
      - value: T
      Returns boolean
Returns null | T

map

map<S, T>(this: Sequence<S>, transform: (element: S) => T): Sequence<T>

Inherited from SequenceOperators.map
- Defined in map.ts:24
Transforms each element into another value by applying the given transform function and returns a new sequence.

Type parameters
- S
- T
Parameters
- this: Sequence<S>
- transform: (element: S) => T
  - - (element: S): T
    - Parameters
      - element: S
      Returns T
Returns Sequence<T>

mapIndexed

mapIndexed<T, R>(this: Sequence<T>, transform: (index: number, value: T) => R): Sequence<R>

Inherited from SequenceOperators.mapIndexed
- Defined in mapIndexed.ts:11
Transforms each element into another value by applying the given transform function and returns a new sequence.

Type parameters
- T
- R
Parameters
- this: Sequence<T>
- transform: (index: number, value: T) => R
  - - (index: number, value: T): R
    - Parameters
      - index: number
      - value: T
      Returns R
Returns Sequence<R>

mapNotNull

mapNotNull<T, R>(this: Sequence<T>, transform: (value: T) => null | R): Sequence<R>

Inherited from SequenceOperators.mapNotNull
- Defined in mapNotNull.ts:12
Transforms each element into another value by applying the given transform function and returns a new sequence. Transformations into null values are discarded.

Type parameters
- T
- R
Parameters
- this: Sequence<T>
- transform: (value: T) => null | R
  - - (value: T): null | R
    - Parameters
      - value: T
      Returns null | R
Returns Sequence<R>

max

max<T>(this: Sequence<T>): null | T

Inherited from SequenceOperators.max
- Defined in max.ts:10
Returns the maximum element of the sequence or null if sequence is empty.

Type parameters
- T
Parameters
- this: Sequence<T>
Returns null | T

maxBy

maxBy<T, R>(this: Sequence<T>, selector: (value: T) => R): null | T

Inherited from SequenceOperators.maxBy
- Defined in maxBy.ts:12
Returns the maximum element by comparing the results of the given selector function for each element of the sequence or null if the sequence is empty.

Type parameters
- T
- R
Parameters
- this: Sequence<T>
- selector: (value: T) => R
  - - (value: T): R
    - Parameters
      - value: T
      Returns R
Returns null | T

maxWith

maxWith<T>(this: Sequence<T>, compare: (a: T, b: T) => number): null | T

Inherited from SequenceOperators.maxWith
- Defined in maxWith.ts:11
Returns the maximum element of the sequence by evaluating the given compare function or null if sequence is empty.

Type parameters
- T
Parameters
- this: Sequence<T>
- compare: (a: T, b: T) => number
  - - (a: T, b: T): number
    - Parameters
      - a: T
      - b: T
      Returns number
Returns null | T

merge

merge<T, S>(this: Sequence<T>, other: Sequence<T> | Iterable<T>, selector: (value: T) => S, prependNewValues?: boolean): Sequence<T>

Inherited from SequenceOperators.merge
- Defined in merge.ts:16
Merges the elements of both sequences into a new sequence. Each element of this sequence is eventually replaced with an element of the other sequence by comparing results of the given selector function. If no value is found in the other sequence the element is retained. New elements of the other sequence are appended to the end of the new sequence or prepended to the start of the new sequence, if prependNewValues is set to true. This operation is not lazy evaluated.

Type parameters
- T
- S
Parameters
- this: Sequence<T>
- other: Sequence<T> | Iterable<T>
- selector: (value: T) => S
  - - (value: T): S
    - Parameters
      - value: T
      Returns S
- prependNewValues: boolean = false
Returns Sequence<T>

min

min<T>(this: Sequence<T>): null | T

Inherited from SequenceOperators.min
- Defined in min.ts:10
Returns the minimum element of the sequence or null if sequence is empty.

Type parameters
- T
Parameters
- this: Sequence<T>
Returns null | T

minBy

minBy<T, R>(this: Sequence<T>, selector: (value: T) => R): null | T

Inherited from SequenceOperators.minBy
- Defined in minBy.ts:12
Returns the minimum element by comparing the results of the given selector function for each element of the sequence or null if the sequence is empty.

Type parameters
- T
- R
Parameters
- this: Sequence<T>
- selector: (value: T) => R
  - - (value: T): R
    - Parameters
      - value: T
      Returns R
Returns null | T

minWith

minWith<T>(this: Sequence<T>, compare: (a: T, b: T) => number): null | T

Inherited from SequenceOperators.minWith
- Defined in minWith.ts:11
Returns the minimum element of the sequence by evaluating the given compare function or null if sequence is empty.

Type parameters
- T
Parameters
- this: Sequence<T>
- compare: (a: T, b: T) => number
  - - (a: T, b: T): number
    - Parameters
      - a: T
      - b: T
      Returns number
Returns null | T

minus

minus<T>(this: Sequence<T>, data: T | Sequence<T> | T[]): Sequence<T>

Inherited from SequenceOperators.minus
- Defined in minus.ts:12
Removes the given data and returns a new sequence. Data can either be a single element, an array of elements or a sequence of elements.

Type parameters
- T
Parameters
- this: Sequence<T>
- data: T | Sequence<T> | T[]
Returns Sequence<T>

none

none<T>(this: Sequence<T>, predicate?: (value: T) => boolean): boolean

Inherited from SequenceOperators.none
- Defined in none.ts:12
Returns true if no element match the given predicate or if the sequence is empty if no predicate is present.

Type parameters
- T
Parameters
- this: Sequence<T>
- Optional predicate: (value: T) => boolean
  - - (value: T): boolean
    - Parameters
      - value: T
      Returns boolean
Returns boolean

onEach

onEach<T>(this: Sequence<T>, action: (value: T) => void): Sequence<T>

Inherited from SequenceOperators.onEach
- Defined in onEach.ts:11
Performs the given action for each element and returns the sequence.

Type parameters
- T
Parameters
- this: Sequence<T>
- action: (value: T) => void
  - - (value: T): void
    - Parameters
      - value: T
      Returns void
Returns Sequence<T>

partition

partition<T>(this: Sequence<T>, predicate: (value: T) => boolean): { false: T[]; true: T[] }

Inherited from SequenceOperators.partition
- Defined in partition.ts:12
Evaluates the given predicate for each element of the sequence and assorts each element into one of two lists according to the result of the predicate. Returns both lists as an object.

Type parameters
- T
Parameters
- this: Sequence<T>
- predicate: (value: T) => boolean
  - - (value: T): boolean
    - Parameters
      - value: T
      Returns boolean
Returns { false: T[]; true: T[] }
- false: T[]
- true: T[]

plus

plus<T>(this: Sequence<T>, element: T): Sequence<T>
plus<T>(this: Sequence<T>, other: T[]): Sequence<T>
plus<T>(this: Sequence<T>, other: Sequence<T>): Sequence<T>

Inherited from SequenceOperators.plus
- Defined in plus.ts:29
Appends the given element to the end of the sequence and returns a new sequence.

Type parameters
- T
Parameters
- this: Sequence<T>
- element: T
Returns Sequence<T>
Inherited from SequenceOperators.plus
- Defined in plus.ts:37
Appends the given array to the end of the sequence and returns a new sequence.

Type parameters
- T
Parameters
- this: Sequence<T>
- other: T[]
Returns Sequence<T>
Inherited from SequenceOperators.plus
- Defined in plus.ts:45
Appends the given sequence to the end of the sequence and returns a new sequence.

Type parameters
- T
Parameters
- this: Sequence<T>
- other: Sequence<T>
Returns Sequence<T>

reduce

reduce<S, T>(this: Sequence<T>, operation: (acc: S, value: T) => S): S

Inherited from SequenceOperators.reduce
- Defined in reduce.ts:14
Reduces the whole sequence to a single value by invoking operation with each element from left to right. For every invocation of the operation acc is the result of the last invocation. For the first invocation of the operation acc is the first element of the sequence.

Type parameters
- S
- T
Parameters
- this: Sequence<T>
- operation: (acc: S, value: T) => S
  - - (acc: S, value: T): S
    - Parameters
      - acc: S
      - value: T
      Returns S
Returns S

reduceIndexed

reduceIndexed<S, T>(this: Sequence<T>, operation: (index: number, acc: S, element: T) => S): S

Inherited from SequenceOperators.reduceIndexed
- Defined in reduceIndexed.ts:14
Reduces the whole sequence to a single value by invoking operation with each element from left to right. For every invocation of the operation acc is the result of the last invocation. For the first invocation of the operation acc is the first element of the sequence. In addition the index of the current element is also passed to the operation.

Type parameters
- S
- T
Parameters
- this: Sequence<T>
- operation: (index: number, acc: S, element: T) => S
  - - (index: number, acc: S, element: T): S
    - Parameters
      - index: number
      - acc: S
      - element: T
      Returns S
Returns S

reverse

reverse<T>(this: Sequence<T>): Sequence<T>

Inherited from SequenceOperators.reverse
- Defined in reverse.ts:10
Returns a new sequence with all elements of the sequence in reverse order.

Type parameters
- T
Parameters
- this: Sequence<T>
Returns Sequence<T>

single

single<T>(this: Sequence<T>, predicate?: (value: T) => boolean): T

Inherited from SequenceOperators.single
- Defined in single.ts:13
Returns the single element of the sequence or throws error if the sequence has more than one element or none at all. If a predicate is passed returns the single element matching the predicate or throws an error if more or less than one element match the predicate.

Type parameters
- T
Parameters
- this: Sequence<T>
- Optional predicate: (value: T) => boolean
  - - (value: T): boolean
    - Parameters
      - value: T
      Returns boolean
Returns T

singleOrNull

singleOrNull<T>(this: Sequence<T>, predicate?: (value: T) => boolean): null | T

Inherited from SequenceOperators.singleOrNull
- Defined in singleOrNull.ts:13
Returns the single element of the sequence or null if the sequence has more than one element or none at all. If a predicate is passed returns the single element matching the predicate or null if more or less than one element match the predicate.

Type parameters
- T
Parameters
- this: Sequence<T>
- Optional predicate: (value: T) => boolean
  - - (value: T): boolean
    - Parameters
      - value: T
      Returns boolean
Returns null | T

sorted

sorted<T>(this: Sequence<T>, composeComparator?: (factory: ComparatorFactory<T>) => Comparator<T>): Sequence<T>

Inherited from SequenceOperators.sorted
- Defined in sorted.ts:14
Returns a new sequence with all elements sorted by the comparator specified by the given composeComparator function or in natural order if no arguments are given.

Type parameters
- T
Parameters
- this: Sequence<T>
- Optional composeComparator: (factory: ComparatorFactory<T>) => Comparator<T>
  - - (factory: ComparatorFactory<T>): Comparator<T>
    - Parameters
      - factory: ComparatorFactory<T>
      Returns Comparator<T>
Returns Sequence<T>

sortedBy

sortedBy<T, R>(this: Sequence<T>, selector: (value: T) => R): Sequence<T>

Inherited from SequenceOperators.sortedBy
- Defined in sortedBy.ts:12
Returns a new sequence with all elements sorted ascending by the value specified by the given selector function.

Type parameters
- T
- R
Parameters
- this: Sequence<T>
- selector: (value: T) => R
  - - (value: T): R
    - Parameters
      - value: T
      Returns R
Returns Sequence<T>

sortedByDescending

sortedByDescending<T, R>(this: Sequence<T>, selector: (value: T) => R): Sequence<T>

Inherited from SequenceOperators.sortedByDescending
- Defined in sortedByDescending.ts:12
Returns a new sequence with all elements sorted descending by the value specified by the given selector function.

Type parameters
- T
- R
Parameters
- this: Sequence<T>
- selector: (value: T) => R
  - - (value: T): R
    - Parameters
      - value: T
      Returns R
Returns Sequence<T>

sortedDescending

sortedDescending<T>(this: Sequence<T>): Sequence<T>

Inherited from SequenceOperators.sortedDescending
- Defined in sortedDescending.ts:10
Returns a new sequence with all elements sorted in reverse (descending) natural order.

Type parameters
- T
Parameters
- this: Sequence<T>
Returns Sequence<T>

sortedWith

sortedWith<T>(this: Sequence<T>, comparison: (a: T, b: T) => number): Sequence<T>

Inherited from SequenceOperators.sortedWith
- Defined in sortedWith.ts:11
Returns a new sequence with all elements sorted be the given compare function.

Type parameters
- T
Parameters
- this: Sequence<T>
- comparison: (a: T, b: T) => number
  - - (a: T, b: T): number
    - Parameters
      - a: T
      - b: T
      Returns number
Returns Sequence<T>

sum

sum(this: Sequence<number>): number

Inherited from SequenceOperators.sum
- Defined in sum.ts:10
Returns the sum of all numbers.

Parameters
- this: Sequence<number>
Returns number

sumBy

sumBy<T>(this: Sequence<T>, selector: (value: T) => number): number

Inherited from SequenceOperators.sumBy
- Defined in sumBy.ts:11
Returns the sum of all numbers specified by the given selector function.

Type parameters
- T
Parameters
- this: Sequence<T>
- selector: (value: T) => number
  - - (value: T): number
    - Parameters
      - value: T
      Returns number
Returns number

take

take<T>(this: Sequence<T>, n: number): Sequence<T>

Inherited from SequenceOperators.take
- Defined in take.ts:12
Returns a new sequence consisting of the first n elements. All other elements are discarded.

Type parameters
- T
Parameters
- this: Sequence<T>
- n: number
Returns Sequence<T>

takeWhile

takeWhile<T>(this: Sequence<T>, predicate: (item: T) => boolean): Sequence<T>

Inherited from SequenceOperators.takeWhile
- Defined in takeWhile.ts:28
Takes all elements of the sequence as long as the given predicate evaluates to true.

Type parameters
- T
Parameters
- this: Sequence<T>
- predicate: (item: T) => boolean
  - - (item: T): boolean
    - Parameters
      - item: T
      Returns boolean
Returns Sequence<T>

toArray

toArray<T>(this: Sequence<T>, array?: T[]): T[]

Inherited from SequenceOperators.toArray
- Defined in toArray.ts:12
Returns all elements of the sequence as array. If an array is passed the elements are appended to the end of the array.

Type parameters
- T
Parameters
- this: Sequence<T>
- Optional array: T[]
Returns T[]

toList

toList<T>(this: Sequence<T>, array?: T[]): T[]

Inherited from SequenceOperators.toList
- Defined in toArray.ts:27
Returns all elements of the sequence as array. If an array is passed the elements are appended to the end of the array.

Type parameters
- T
Parameters
- this: Sequence<T>
- Optional array: T[]
Returns T[]

toMap

toMap<K, V>(this: Sequence<[K, V]>, map?: Map<K, V>): Map<K, V>

Inherited from SequenceOperators.toMap
- Defined in toMap.ts:12
Returns a map consisting of each key-value pair. If a map is passed the pairs are set on this map. Duplicate keys override each other.

Type parameters
- K
- V
Parameters
- this: Sequence<[K, V]>
- Optional map: Map<K, V>
Returns Map<K, V>

toSet

toSet<T>(this: Sequence<T>, set?: Set<T>): Set<T>

Inherited from SequenceOperators.toSet
- Defined in toSet.ts:12
Returns all elements of the sequence as set. If a set is passed the elements are added to this set.

Type parameters
- T
Parameters
- this: Sequence<T>
- Optional set: Set<T>
Returns Set<T>

unzip

unzip<T, S>(this: Sequence<[T, S]>): [T[], S[]]

Inherited from SequenceOperators.unzip
- Defined in unzip.ts:11
Returns a pair of arrays where the first array contains all first values and the second array all second values from each input pair of the sequence.

Type parameters
- T
- S
Parameters
- this: Sequence<[T, S]>
Returns [T[], S[]]

withIndex

withIndex<T>(this: Sequence<T>): Sequence<IndexedValue<T>>

Inherited from SequenceOperators.withIndex
- Defined in withIndex.ts:33
Returns a new sequence consisting of indexed values for all original elements.

Type parameters
- T
Parameters
- this: Sequence<T>
Returns Sequence<IndexedValue<T>>

zip

zip<T, S>(this: Sequence<T>, other: Sequence<S>): Sequence<[T, S]>

Inherited from SequenceOperators.zip
- Defined in zip.ts:30
Returns a new sequence consisting of pairs built the elements of both sequences with the same index. The resulting sequence has the length of the shortest input sequence. All other elements are discarded.

Type parameters
- T
- S
Parameters
- this: Sequence<T>
- other: Sequence<S>
Returns Sequence<[T, S]>

Type parameters

T

Hierarchy

Index

Properties

Methods

Properties

Readonly iterator

Methods

all

Type parameters

T

Parameters

this: Sequence<T>

predicate: (item: T) => boolean

Parameters

item: T

Returns boolean

Returns boolean

any

Type parameters

T

Parameters

this: Sequence<T>

Optional predicate: (item: T) => boolean

Parameters

item: T

Returns boolean

Returns boolean

asIterable

Type parameters

T

Parameters

this: Sequence<T>

Returns Iterable<T>

associate

Type parameters

T

K

V

Parameters

this: Sequence<T>

transform: (value: T) => [K, V]

Parameters

value: T

Returns [K, V]

Returns Map<K, V>

associateBy

Type parameters

K

Parameters

keySelector: (value: T) => K

Parameters

value: T

Returns K

Returns Map<K, T>

Type parameters

K: string | number | symbol

Parameters

key: K

Returns Map<T[K], T>

Type parameters

K

V

Parameters

keySelector: (value: T) => K

Parameters

value: T

Returns K

valueTransformer: (value: T) => V

Parameters

value: T

Returns V

Returns Map<K, V>

Type parameters

K: string | number | symbol

V

Parameters

key: K

valueTransformer: (value: T) => V