Class Iterable<T>`Abstract`

This class serves as the base for all operations which support [Symbol.iterator].

Type Parameters

Hierarchy

Iterable<T>
- Iterable

Implements

Iterable<T>

Constructors

constructor

new Iterable<T>(): Iterable<T>
Type Parameters
- T
Returns Iterable<T>

Properties

average

average: {
(this, options?): number;
<T>(this, options?): number;
}

Type declaration

- (this, options?): number
- Parameters
  - this: Iterable<number>
  - Optional options: MathOptions<number>
  Returns number
- <T>(this, options?): number
- Type Parameters
  - T
  Parameters
  - this: Iterable<T>
  - Optional options: MathOptions<T>
  Returns number

buffer

buffer: {}

Type declaration

catchError

catchError: {}

Type declaration

concat

concat: (<T, T2, T3>(this, v2, v3) => Iterable<T | T2 | T3>)

Type declaration

- <T, T2, T3>(this, v2, v3): Iterable<T | T2 | T3>
- Type Parameters
  - T
  - T2
  - T3
  Parameters
  - this: Iterable<T>
  - v2: Iterable<T2>
  - v3: Iterable<T3>
  Returns Iterable<T | T2 | T3>

concatAll

concatAll: {}

Type declaration

count

count: {}

Type declaration

defaultIfEmpty

defaultIfEmpty: {}

Type declaration

distinct

distinct: {}

Type declaration

distinctUntilChanged

distinctUntilChanged: {}

Type declaration

doWhile

doWhile: {}

Type declaration

elementAt

elementAt: {}

Type declaration

endWith

endWith: {}

Type declaration

every

every: {}

Type declaration

except

except: {}

Type declaration

expand

expand: {}

Type declaration

filter

filter: (<T>(this, predicate, thisArg?) => Iterable<T>)

Type declaration

- <T>(this, predicate, thisArg?): Iterable<T>
- Type Parameters
  - T
  Parameters
  - this: Iterable<T>
  - predicate: ((value, index) => boolean)
    - (value, index): boolean
      
      Parameters
      
      value: T
      
      index: number
      
      Returns boolean
  - Optional thisArg: any
  Returns Iterable<T>

finally

finally: {}

Type declaration

find

find: {}

Type declaration

findIndex

findIndex: {}

Type declaration

first

first: {}

Type declaration

flat

flat: {}

Type declaration

flatMap

flatMap: {}

Type declaration

groupBy

groupBy: {
<TSource, TKey>(this, keySelector): Iterable<GroupedIterable<TKey, TSource>>;
<TSource, TKey, TValue>(this, keySelector, elementSelector?): Iterable<GroupedIterable<TKey, TValue>>;
}

Type declaration

- <TSource, TKey>(this, keySelector): Iterable<GroupedIterable<TKey, TSource>>
- Type Parameters
  - TSource
  - TKey
  Parameters
  - this: Iterable<TSource>
  - keySelector: ((value) => TKey)
    - (value): TKey
      
      Parameters
      
      value: TSource
      
      Returns TKey
  Returns Iterable<GroupedIterable<TKey, TSource>>
- <TSource, TKey, TValue>(this, keySelector, elementSelector?): Iterable<GroupedIterable<TKey, TValue>>
- Type Parameters
  - TSource
  - TKey
  - TValue
  Parameters
  - this: Iterable<TSource>
  - keySelector: ((value) => TKey)
    - (value): TKey
      
      Parameters
      
      value: TSource
      
      Returns TKey
  - Optional elementSelector: ((value) => TValue)
    - (value): TValue
      
      Parameters
      
      value: TSource
      
      Returns TValue
  Returns Iterable<GroupedIterable<TKey, TValue>>

groupJoin

groupJoin: {}

Type declaration

ignoreElements

ignoreElements: {}

Type declaration

includes

includes: {}

Type declaration

innerJoin

innerJoin: {}

Type declaration

intersect

intersect: {}

Type declaration

isEmpty

isEmpty: {}

Type declaration

last

last: {}

Type declaration

map

map: {}

Type declaration

max

max: (<TSource, TResult>(this, options?) => TResult)

Type declaration

- <TSource, TResult>(this, options?): TResult
- Type Parameters
  - TSource
  - TResult = TSource
  Parameters
  - this: Iterable<TSource>
  - Optional options: ExtremaOptions<TSource, TResult>
  Returns TResult

maxBy

maxBy: {}

Type declaration

memoize

memoize: {
<TSource>(this, readerCount?): Iterable<TSource>;
<TSource, TResult>(this, readerCount?, selector?): Iterable<TResult>;
}

Type declaration

- <TSource>(this, readerCount?): Iterable<TSource>
- Type Parameters
  - TSource
  Parameters
  - this: Iterable<TSource>
  - Optional readerCount: number
  Returns Iterable<TSource>
- <TSource, TResult>(this, readerCount?, selector?): Iterable<TResult>
- Type Parameters
  - TSource
  - TResult
  Parameters
  - this: Iterable<TSource>
  - Optional readerCount: number
  - Optional selector: ((value) => Iterable<TResult>)
    - (value): Iterable<TResult>
      
      Parameters
      
      value: Iterable<TSource>
      
      Returns Iterable<TResult>
  Returns Iterable<TResult>

min

min: {}

Type declaration

minBy

minBy: {}

Type declaration

onErrorResumeNext

onErrorResumeNext: {}

Type declaration

orderBy

orderBy: {}

Type declaration

orderByDescending

orderByDescending: {}

Type declaration

pairwise

pairwise: {}

Type declaration

pluck

pluck: {}

Type declaration

publish

publish: {
<T>(this): Iterable<T>;
<T, R>(this, selector?): Iterable<R>;
}

Type declaration

- <T>(this): Iterable<T>
- Type Parameters
  - T
  Parameters
  - this: Iterable<T>
  Returns Iterable<T>
- <T, R>(this, selector?): Iterable<R>
- Type Parameters
  - T
  - R
  Parameters
  - this: Iterable<T>
  - Optional selector: ((value) => Iterable<R>)
    - (value): Iterable<R>
      
      Parameters
      
      value: Iterable<T>
      
      Returns Iterable<R>
  Returns Iterable<R>

reduce

reduce: (<T, R>(this, accumulator, seed?) => R)

Type declaration

- <T, R>(this, accumulator, seed?): R
- Type Parameters
  - T
  - R = T
  Parameters
  - this: Iterable<T>
  - accumulator: ((accumulator, current, index) => R)
    - (accumulator, current, index): R
      
      Parameters
      
      accumulator: R
      
      current: T
      
      index: number
      
      Returns R
  - Optional seed: R
  Returns R

reduceRight

reduceRight: (<T, R>(this, accumulator, seed?) => R)

Type declaration

- <T, R>(this, accumulator, seed?): R
- Type Parameters
  - T
  - R = T
  Parameters
  - this: Iterable<T>
  - accumulator: ((accumulator, current, index) => R)
    - (accumulator, current, index): R
      
      Parameters
      
      accumulator: R
      
      current: T
      
      index: number
      
      Returns R
  - Optional seed: R
  Returns R

repeat

repeat: {}

Type declaration

retry

retry: {}

Type declaration

reverse

reverse: {}

Type declaration

scan

scan: (<T, R>(this, accumulator, seed?) => Iterable<R>)

Type declaration

- <T, R>(this, accumulator, seed?): Iterable<R>
- Type Parameters
  - T
  - R = T
  Parameters
  - this: Iterable<T>
  - accumulator: ((accumulator, current, index) => R)
    - (accumulator, current, index): R
      
      Parameters
      
      accumulator: R
      
      current: T
      
      index: number
      
      Returns R
  - Optional seed: R
  Returns Iterable<R>

scanRight

scanRight: (<T, R>(this, accumulator, seed?) => Iterable<R>)

Type declaration

- <T, R>(this, accumulator, seed?): Iterable<R>
- Type Parameters
  - T
  - R = T
  Parameters
  - this: Iterable<T>
  - accumulator: ((accumulator, current, index) => R)
    - (accumulator, current, index): R
      
      Parameters
      
      accumulator: R
      
      current: T
      
      index: number
      
      Returns R
  - Optional seed: R
  Returns Iterable<R>

sequenceEqual

sequenceEqual: {}

Type declaration

share: {
<TSource>(this): Iterable<TSource>;
<TSource, TResult>(this, fn?): Iterable<TResult>;
}

Type declaration

- <TSource>(this): Iterable<TSource>
- Type Parameters
  - TSource
  Parameters
  - this: Iterable<TSource>
  Returns Iterable<TSource>
- <TSource, TResult>(this, fn?): Iterable<TResult>
- Type Parameters
  - TSource
  - TResult
  Parameters
  - this: Iterable<TSource>
  - Optional fn: ((value) => Iterable<TResult>)
    - (value): Iterable<TResult>
      
      Parameters
      
      value: Iterable<TSource>
      
      Returns Iterable<TResult>
  Returns Iterable<TResult>

single

single: {}

Type declaration

skip

skip: {}

Type declaration

skipLast

skipLast: {}

Type declaration

skipWhile

skipWhile: (<T>(this, predicate) => Iterable<T>)

Type declaration

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

slice

slice: {}

Type declaration

some

some: {}

Type declaration

startWith

startWith: {}

Type declaration

sum

sum: {
(this, options?): number;
<T>(this, options?): number;
}

Type declaration

- (this, options?): number
- Parameters
  - this: Iterable<number>
  - Optional options: MathOptions<number>
  Returns number
- <T>(this, options?): number
- Type Parameters
  - T
  Parameters
  - this: Iterable<T>
  - Optional options: MathOptions<T>
  Returns number

take

take: {}

Type declaration

takeLast

takeLast: {}

Type declaration

takeWhile

takeWhile: (<T>(this, predicate) => Iterable<T>)

Type declaration

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

tap

tap: (<TSource>(this, next?, error?, complete?) => Iterable<TSource>)

Type declaration

- <TSource>(this, next?, error?, complete?): Iterable<TSource>
- Type Parameters
  - TSource
  Parameters
  - this: Iterable<TSource>
  - Optional next: null | ((value) => any)
  - Optional error: null | ((err) => any)
  - Optional complete: null | (() => any)
  Returns Iterable<TSource>

toArray

toArray: {}

Type declaration

toDOMStream

toDOMStream: {
<T>(this, options): ReadableStream<Uint8Array>;
<T>(this, options): ReadableStream<Uint8Array>;
}

Type declaration

- <T>(this, options): ReadableStream<Uint8Array>
- Type Parameters
  - T
  Parameters
  - this: Iterable<T>
  - options: ReadableBYOBStreamOptions<Uint8Array>
  Returns ReadableStream<Uint8Array>
- <T>(this, options): ReadableStream<Uint8Array>
- Type Parameters
  - T
  Parameters
  - this: Iterable<T>
  - options: ReadableByteStreamOptions<Uint8Array>
  Returns ReadableStream<Uint8Array>

toMap

toMap: (<TSource, TKey, TElement>(this, options) => Map<TKey, TElement | TSource>)

Type declaration

- <TSource, TKey, TElement>(this, options): Map<TKey, TElement | TSource>
- Type Parameters
  - TSource
  - TKey
  - TElement = TSource
  Parameters
  - this: Iterable<TSource>
  - options: ToMapOptions<TSource, TKey, TElement>
  Returns Map<TKey, TElement | TSource>

toNodeStream

toNodeStream: {
<TSource>(this, options): IterableReadable<TSource>;
<TSource>(this, options): IterableReadable<TSource>;
}

Type declaration

- <TSource>(this, options): IterableReadable<TSource>
- Type Parameters
  - TSource
  Parameters
  - this: Iterable<TSource>
  - options: ReadableOptions | {
    objectMode: true;
    }
  Returns IterableReadable<TSource>
- <TSource>(this, options): IterableReadable<TSource>
- Type Parameters
  - TSource extends BufferLike
  Parameters
  - this: Iterable<TSource>
  - options: ReadableOptions | {
    objectMode: false;
    }
  Returns IterableReadable<TSource>

toSet

toSet: {}

Type declaration

union

union: {}

Type declaration

zip

zip: {
    <T, T2, T3>(this, source2, source3): Iterable<[T, T2, T3]>;
    <T, T2, T3, T4>(this, source2, source3, source4): Iterable<[T, T2, T3, T4]>;
    <T, T2, T3, T4, T5>(this, source2, source3, source4, source5): Iterable<[T, T2, T3, T4, T5]>;
    <T, T2, T3, T4, T5, T6>(this, source2, source3, source4, source5, source6): Iterable<[T, T2, T3, T4, T5, T6]>;
    <T>(this, ...sources): Iterable<T[]>;
}

Type declaration

- <T, T2, T3>(this, source2, source3): Iterable<[T, T2, T3]>
- Type Parameters
  - T
  - T2
  - T3
  Parameters
  - this: Iterable<T>
  - source2: Iterable<T2>
  - source3: Iterable<T3>
  Returns Iterable<[T, T2, T3]>
- <T, T2, T3, T4>(this, source2, source3, source4): Iterable<[T, T2, T3, T4]>
- Type Parameters
  - T
  - T2
  - T3
  - T4
  Parameters
  - this: Iterable<T>
  - source2: Iterable<T2>
  - source3: Iterable<T3>
  - source4: Iterable<T4>
  Returns Iterable<[T, T2, T3, T4]>
- <T, T2, T3, T4, T5>(this, source2, source3, source4, source5): Iterable<[T, T2, T3, T4, T5]>
- Type Parameters
  - T
  - T2
  - T3
  - T4
  - T5
  Parameters
  - this: Iterable<T>
  - source2: Iterable<T2>
  - source3: Iterable<T3>
  - source4: Iterable<T4>
  - source5: Iterable<T5>
  Returns Iterable<[T, T2, T3, T4, T5]>
- <T, T2, T3, T4, T5, T6>(this, source2, source3, source4, source5, source6): Iterable<[T, T2, T3, T4, T5, T6]>
- Type Parameters
  - T
  - T2
  - T3
  - T4
  - T5
  - T6
  Parameters
  - this: Iterable<T>
  - source2: Iterable<T2>
  - source3: Iterable<T3>
  - source4: Iterable<T4>
  - source5: Iterable<T5>
  - source6: Iterable<T6>
  Returns Iterable<[T, T2, T3, T4, T5, T6]>
- <T>(this, ...sources): Iterable<T[]>
- Type Parameters
  - T
  Parameters
  - this: Iterable<T>
  - Rest ...sources: Iterable<T>[]
  Returns Iterable<T[]>

Methods

`Abstract` [iterator]

[iterator](): Iterator<T, any, undefined>
Returns Iterator<T, any, undefined>
Implementation of Iterable.[iterator]
- Defined in iterable/iterablex.ts:17

forEach

forEach(projection, thisArg?): void
Parameters
- projection: ((value, index) => void)
  - - (value, index): void
    - Parameters
      
      value: T
      
      index: number
      
      Returns void
- Optional thisArg: any
Returns void

Nocollapse
- Defined in iterable/iterablex.ts:20

pipe

pipe<R>(...operations): R
Type Parameters
- R
Parameters
- Rest ...operations: UnaryFunction<Iterable<T>, R>[]
Returns R

Nocollapse
- Defined in iterable/iterablex.ts:29
pipe<R>(...operations): Iterable<R>
Type Parameters
- R
Parameters
- Rest ...operations: OperatorFunction<T, R>[]
Returns Iterable<R>
- Defined in iterable/iterablex.ts:30
pipe<R>(writable, options?): R
Type Parameters
- R extends WritableStream
Parameters
- writable: R
- Optional options: {
  end?: boolean;
  }
  - Optional end?: boolean
Returns R
- Defined in iterable/iterablex.ts:31
pipe(): Iterable<T>
Returns Iterable<T>
- Defined in iterable/iterablex.ts:156
pipe<A>(op1): Iterable<A>
Type Parameters
- A
Parameters
- op1: OperatorFunction<T, A>
Returns Iterable<A>
- Defined in iterable/iterablex.ts:157
pipe<A, B>(op1, op2): Iterable<B>
Type Parameters
- A
- B
Parameters
- op1: OperatorFunction<T, A>
- op2: OperatorFunction<A, B>
Returns Iterable<B>
- Defined in iterable/iterablex.ts:158
pipe<A, B, C>(op1, op2, op3): Iterable<C>
Type Parameters
- A
- B
- C
Parameters
- op1: OperatorFunction<T, A>
- op2: OperatorFunction<A, B>
- op3: OperatorFunction<B, C>
Returns Iterable<C>
- Defined in iterable/iterablex.ts:159
pipe<A, B, C, D>(op1, op2, op3, op4): Iterable<D>
Type Parameters
- A
- B
- C
- D
Parameters
- op1: OperatorFunction<T, A>
- op2: OperatorFunction<A, B>
- op3: OperatorFunction<B, C>
- op4: OperatorFunction<C, D>
Returns Iterable<D>
- Defined in iterable/iterablex.ts:164
pipe<A, B, C, D, E>(op1, op2, op3, op4, op5): Iterable<E>
Type Parameters
- A
- B
- C
- D
- E
Parameters
- op1: OperatorFunction<T, A>
- op2: OperatorFunction<A, B>
- op3: OperatorFunction<B, C>
- op4: OperatorFunction<C, D>
- op5: OperatorFunction<D, E>
Returns Iterable<E>
- Defined in iterable/iterablex.ts:170
pipe<A, B, C, D, E, F>(op1, op2, op3, op4, op5, op6): Iterable<F>
Type Parameters
- A
- B
- C
- D
- E
- F
Parameters
- op1: OperatorFunction<T, A>
- op2: OperatorFunction<A, B>
- op3: OperatorFunction<B, C>
- op4: OperatorFunction<C, D>
- op5: OperatorFunction<D, E>
- op6: OperatorFunction<E, F>
Returns Iterable<F>
- Defined in iterable/iterablex.ts:177
pipe<A, B, C, D, E, F, G>(op1, op2, op3, op4, op5, op6, op7): Iterable<G>
Type Parameters
- A
- B
- C
- D
- E
- F
- G
Parameters
- op1: OperatorFunction<T, A>
- op2: OperatorFunction<A, B>
- op3: OperatorFunction<B, C>
- op4: OperatorFunction<C, D>
- op5: OperatorFunction<D, E>
- op6: OperatorFunction<E, F>
- op7: OperatorFunction<F, G>
Returns Iterable<G>
- Defined in iterable/iterablex.ts:185
pipe<A, B, C, D, E, F, G, H>(op1, op2, op3, op4, op5, op6, op7, op8): Iterable<H>
Type Parameters
- A
- B
- C
- D
- E
- F
- G
- H
Parameters
- op1: OperatorFunction<T, A>
- op2: OperatorFunction<A, B>
- op3: OperatorFunction<B, C>
- op4: OperatorFunction<C, D>
- op5: OperatorFunction<D, E>
- op6: OperatorFunction<E, F>
- op7: OperatorFunction<F, G>
- op8: OperatorFunction<G, H>
Returns Iterable<H>
- Defined in iterable/iterablex.ts:194
pipe<A, B, C, D, E, F, G, H, I>(op1, op2, op3, op4, op5, op6, op7, op8, op9): Iterable<I>
Type Parameters
- A
- B
- C
- D
- E
- F
- G
- H
- I
Parameters
- op1: OperatorFunction<T, A>
- op2: OperatorFunction<A, B>
- op3: OperatorFunction<B, C>
- op4: OperatorFunction<C, D>
- op5: OperatorFunction<D, E>
- op6: OperatorFunction<E, F>
- op7: OperatorFunction<F, G>
- op8: OperatorFunction<G, H>
- op9: OperatorFunction<H, I>
Returns Iterable<I>
- Defined in iterable/iterablex.ts:204
pipe<R>(...operations): Iterable<R>
Type Parameters
- R
Parameters
- Rest ...operations: OperatorFunction<T, R>[]
Returns Iterable<R>
- Defined in iterable/iterablex.ts:215
pipe<A>(op1, options?): A
Type Parameters
- A extends WritableStream
Parameters
- op1: A
- Optional options: {
  end?: boolean;
  }
  - Optional end?: boolean
Returns A
- Defined in iterable/iterablex.ts:216

pipeThrough

pipeThrough<R>(duplex, options?): R
Type Parameters
- R extends ReadableStream<any>
Parameters
- duplex: {
  readable: R;
  writable: WritableStream<T>;
  }
  - readable: R
  - writable: WritableStream<T>
- Optional options: StreamPipeOptions
Returns R
- Defined in iterable/todomstream.ts:85

pipeTo

pipeTo(writable, options?): Promise<void>
Parameters
- writable: WritableStream<T>
- Optional options: StreamPipeOptions
Returns Promise<void>
- Defined in iterable/todomstream.ts:84

tee

tee(): [ReadableStream<T>, ReadableStream<T>]
Returns [ReadableStream<T>, ReadableStream<T>]
- Defined in iterable/todomstream.ts:83

`Static` as

as(source): Iterable<string>
Converts an existing string into an iterable of characters.
Parameters
- source: string
  
  The string to convert to an iterable.
Returns Iterable<string>
An terable stream of characters from the source.
- Defined in iterable/iterablex.ts:48
as<T>(source): Iterable<T>
Converts the iterable like input into an iterable.
Type Parameters
- T
  
  The tyep of elements in the source iterable.
Parameters
- source: Iterable<T>
  
  The iterable to convert to an iterable.
Returns Iterable<T>
An iterable stream of the source sequence.
- Defined in iterable/iterablex.ts:56
as<T>(source): Iterable<T>
Converts an array-like object to an iterable.
Type Parameters
- T
  
  The type of elements in the source array-like sequence.
Parameters
- source: ArrayLike<T>
  
  The array-like sequence to convert to an iterable.
Returns Iterable<T>
The iterable containing the elements from the array-like sequence.
- Defined in iterable/iterablex.ts:64
as<T>(source): Iterable<T>
Converts the object into a singleton in an iterable sequence.
Type Parameters
- T
  
  The type of element to turn into an iterable sequence.
Parameters
- source: T
  
  The item to turn into an iterable sequence.
Returns Iterable<T>
An iterable sequence from the source object.
- Defined in iterable/iterablex.ts:72

`Static` from

from<TSource, TResult>(source, selector?, thisArg?): Iterable<TResult>
Type Parameters
- TSource
- TResult = TSource
Parameters
- source: Iterable<TSource> | Iterator<TSource, any, undefined> | ArrayLike<TSource>
- selector: ((value, index) => TResult) = identity
  - - (value, index): TResult
    - Parameters
      
      value: TSource
      
      index: number
      
      Returns TResult
- Optional thisArg: any
Returns Iterable<TResult>

Nocollapse
- Defined in iterable/iterablex.ts:89

Class Iterable<T>Abstract

Type Parameters

T

Hierarchy

Implements

Index

Constructors

Properties

Methods

Constructors

constructor

Type Parameters

T

Returns Iterable<T>

Properties

average

Type declaration

Parameters

this: Iterable<number>

Optional options: MathOptions<number>

Returns number

Type Parameters

T

Parameters

this: Iterable<T>

Optional options: MathOptions<T>

Returns number

buffer

Type declaration

catchError

Type declaration

concat

Type declaration

Type Parameters

T

T2

T3

Parameters

this: Iterable<T>

v2: Iterable<T2>

v3: Iterable<T3>

Returns Iterable<T | T2 | T3>

concatAll

Type declaration

count

Type declaration

defaultIfEmpty

Type declaration

distinct

Type declaration

distinctUntilChanged

Type declaration

doWhile

Type declaration

elementAt

Type declaration

endWith

Type declaration

every

Type declaration

except

Type declaration

expand

Type declaration

filter

Type declaration

Type Parameters

T

Parameters

this: Iterable<T>

predicate: ((value, index) => boolean)

Parameters

value: T

index: number

Returns boolean

Optional thisArg: any

Returns Iterable<T>

finally

Type declaration

find

Class Iterable<T>`Abstract`

`Optional` options: MathOptions<number>

`Optional` options: MathOptions<T>

`Optional` thisArg: any

`Optional` elementSelector: ((value) => TValue)

`Optional` options: ExtremaOptions<TSource, TResult>

`Optional` readerCount: number