The Interactive Extensions for JavaScript (IxJS)

IxJS is a set of libraries to compose synchronous and asynchronous collections and Array#extras style composition in JavaScript

The Interactive Extensions for JavaScript (IxJS) brings the Array#extras combinators to iterables, generators, async iterables and async generators. With the introduction of the Symbol.iterator and generators in ES2015, and subsequent introduction of Symbol.asyncIterator and async generators, it became obvious we need an abstraction over these data structures for composition, querying and more.

IxJS unifies both synchronous and asynchronous pull-based collections, just as RxJS unified the world of push-based collections. RxJS is great for event-based workflows where the data can be pushed at the rate of the producer, however, IxJS is great at I/O operations where you as the consumer can pull the data when you are ready.

Install IxJS from npm

npm install ix

(also read about how we package IxJS below)

`Iterable`

The Iterable class a way to create and compose synchronous collections much like Arrays, Maps and Sets in JavaScript using the Array#extras style using the familiar methods you are used to like map, filter, reduce and more.

// ES
import * as Ix from 'ix';

// CommonJS
const Ix = require('ix');

Ix.Iterable.from([1,2,3,4])
  .filter(x => x % 2 === 0)
  .map(x => x * 2)
  .forEach(x => console.log(`Next ${x}`));

// => 4
// => 8

Alternatively, we can use the for ... of statements to iterate our collections.

// ES
import * as Ix from 'ix';

// CommonJS
const Ix = require('ix');

const results = Ix.Iterable.from([1,2,3,4])
  .filter(x => x % 2 === 0)
  .map(x => x * 2);

for (let item of results) {
  console.log(`Next ${item}`);
}

// => 4
// => 8

Instead of bringing in the entire library for Iterable, we can pick and choose which operators we want, for bundling concerns.

// ES
import { IterableX as Iterable } from 'ix/iterable';
import 'ix/add/iterable-operators/map';

// CommonJS
const Iterable = require('ix/iterable').IterableX;
require('ix/add/iterable-operators/map');

const results = Iterable.of(1,2,3)
  .map(x => x + '!!');

We can also bring in only the operators that we want to using just the operators themselves. Many of these operators take a simple Iterable source such as an Array, Map, Set or generator function such as our map and filter functions.

// ES
import { map } from 'ix/iterable/map';
import { filter } from 'ix/iterable/filter';

// CommonJS
const map = require('ix/iterable/map').map;
const filter = require('ix/iterable/filter').filter;

const source = [1,2,3];
const results = map(
  filter(
    source,
    x => x % 2 === 0
  ),
  x => x * x
);

for (let item of results) {
  console.log(`Next: ${item}`);
}

// Next 4

Just like RxJS, IxJS supports "lettable" operators which allow you to chain together operators, keeping the surface area to a minimum on the Iterable object.

// ES
import { IterableX as Iterable } from 'ix/iterable';
import { map, filter } from 'ix/iterable/pipe';

// CommonJS
const Iterable = require('ix/iterable').IterableX;
const { map, filter } = require('ix/iterable/pipe');

const results = of(1, 2, 3).pipe(
  filter(x => x % 2 === 0),
  map(x => x * x)
);

for (let item of results) {
  console.log(`Next: ${item}`);
}

The Iterable object implements the iterator pattern in JavaScript by exposing the [Symbol.iterator] method which in turn exposes the Iterator class. The iterator yields values by calling the next() method which returns the IteratorResult class.

interface Iterable<T> {
  [Symbol.iterator](): Iterator<T>;
}

interface Iterator<T> {
  next(value?: any): IteratorResult<T>;
  return?(value?: any): IteratorResult<T>;
  throw?(e?: any): IteratorResult<T>;
}

interface IteratorResult<T> {
  value: T;
  done: Boolean;
}

`AsyncIterable`

The AsyncIterable object is based off the ECMAScript Proposal for Asynchronous Iterators. This would allow us to create asynchronous collections of Promises and be able to use such methods as the map, filter, reduce and other Array#extras methods that you are used to using.

import * as Ix from 'ix';

// CommonJS
const Ix = require('ix');

async function* gen() {
  yield 1;
  yield 2;
  yield 3;
  yield 4;
}

Ix.AsyncIterable.from(gen())
  .filter(x => x % 2 === 0)
  .map(x => x * 2)
  .forEach(x => console.log(`Next ${x}`))
  .catch(err => console.log(`Error ${err}`));

// => Next 4
// => Next 8

Much like with the Iterable object where we can iterate through our collections, we can use for await ... of instead which allows us to iterate over the asynchronous collection.

import * as Ix from 'ix';

// CommonJS
const Ix = require('ix');

async function* gen() {
  yield 1;
  yield 2;
  yield 3;
  yield 4;
}

const results = Ix.AsyncIterable.from(gen())
  .filter(x => x % 2 === 0)
  .map(x => x * 2);

for await (let item of results) {
  console.log(`Next ${x}`);
}

// => Next 4
// => Next 8

Instead of bringing in the entire library for AsyncIterable, we can pick and choose which operators we want, for bundling concerns.

// ES
import { AsyncIterableX as AsyncIterable } from 'ix/asynciterable';
import 'ix/add/asynciterable-operators/map';

// CommonJS
const AsyncIterable = require('ix/asynciterable').AsyncIterableX;
require('ix/add/asynciterable-operators/map');

const results = AsyncIterable.of(1,2,3)
  .map(x => x + '!!');

We can also bring in only the operators that we want to using just the operators themselves. Many of these operators take a simple AsyncIterable source from async function* functions such as the map and filter functions.

// ES
import { map } from 'ix/asynciterable/map';
import { filter } from 'ix/asynciterable/filter';

// CommonJS
const map = require('ix/asynciterable/map').map;
const filter = require('ix/asynciterable/filter').filter;

const source = async function* () {
  yield 1;
  yield 2;
  yield 3;
  yield 4;
};

const results = map(
  filter(
    source(),
    x => x % 2 === 0
  ),
  x => x * x
);

for await (let item of results) {
  console.log(`Next: ${item}`);
}

Just like RxJS, IxJS supports "lettable" operators which allow you to chain together operators, keeping the surface area to a minimum on the AsyncIterable object.

// ES
import { AsyncIterableX as AsyncIterable } from 'ix/asynciterable';
import { filter, map } from 'ix/asynciterable/pipe';

// CommonJS
const AsyncIterable = require('ix/asynciterable').AsyncIterableX;
const { filter, map } = require('ix/asynciterable/pipe');

const source = async function* () {
  yield 1;
  yield 2;
  yield 3;
  yield 4;
};

const results = from(source()).pipe(
  filter(async x => x % 2 === 0),
  map(async x => x * x)
);

for await (let item of results) {
  console.log(`Next: ${item}`);
}

The AsyncIterable class implements the async iterator pattern in JavaScript by exposing the [Symbol.asyncIterator] method which in turn exposes the AsyncIterator class. The iterator yields values by calling the next() method which returns a Promise which resolves a IteratorResult class.

interface AsyncIterable<T> {
  [Symbol.asyncIterator](): AsyncIterator<T>;
}

interface AsyncIterator<T> {
  [Symbol.asyncIterator](): AsyncIterator<T>;
  next(value?: any): Promise<IteratorResult<T>>;
  return?(value?: any): Promise<IteratorResult<T>>;
  throw?(e?: any): Promise<IteratorResult<T>>;
}

interface IteratorResult<T> {
  value: T;
  done: Boolean;
}

Converting from Iterable to AsyncIterable

Using IxJS, you can easily go from an Iterable to an AsyncIterable using a number of methods. First, we can use the from function, either as a standalone or on the Ix.AsyncIterable object. The from method accepts a standard Iterable, Generator, and Iterator of Promises, or even another AsyncIterable.

import { from } from 'ix/asynciterable/from';
import { map } from 'ix/asynciterable/map';

const xs = [1, 2, 3, 4];
const asyncIterable = from(xs);

const mapped = map(asyncIterable, async (item, index) => item * index);

for await (let item of mapped) {
  console.log(`Next: ${item}`);
}

In addition, you can use the specialized async methods that are suffixed with Async, such as mapAsync, filterAsync, flatMapAsync amongst others. These functions accept async functions which allow you to return a Promise as the result.

import { mapAsync } from 'ix/iterable/mapasync';

const xs = [1, 2, 3, 4];
const mapped = mapAsync(xs, async (item, index) => item * index);

for await (let item of mapped) {
  console.log(`Next: ${item}`);
}

Contributing

We are grateful for contributions to the IxJS project. The IxJS project evolves because of community involvemnent from people such as yourselves. Please read below on how to get involved.

Code Of Conduct

The IxJS project has a strict Code of Conduct that must be adhered at all times. This code of conduct comes from the Contributor Convenant. Please read the full text as to what is and is not permitted.

Contributing Guide

Read the Contributing Guide on how to get involved with the IxJS project. This includes our development process and how to test your code before committing.

Packaging

IxJS is written in TypeScript, but the project is compiled to multiple JS versions and common module formats. The base IxJS package includes all the compilation targets for convenience, but if you're conscientious about your node_modules footprint, don't worry -- we got you. The targets are also published under the @reactivex namespace:

npm install @reactivex/ix-ts # TypeScript target
npm install @reactivex/ix-es5-cjs # ES5 CommonJS target
npm install @reactivex/ix-es5-esm # ES5 ESModules target
npm install @reactivex/ix-es5-umd # ES5 UMD target
npm install @reactivex/ix-es2015-cjs # ES2015 CommonJS target
npm install @reactivex/ix-es2015-esm # ES2015 ESModules target
npm install @reactivex/ix-es2015-umd # ES2015 UMD target
npm install @reactivex/ix-esnext-esm # ESNext CommonJS target
npm install @reactivex/ix-esnext-esm # ESNext ESModules target
npm install @reactivex/ix-esnext-umd # ESNext UMD target

Why we package like this

The JS community is a diverse group with a varied list of target environments and tool chains. Publishing multiple packages accommodates projects of all types. Friends targeting the latest JS runtimes can pull in the ESNext + ESM build. Friends needing wide browser support and small download size can use the UMD bundle, which has been run through Google's Closure Compiler with advanced optimizations.

If you think we missed a compilation target and it's a blocker for adoption, please open an issue. We're here for you ❤️.

License

The MIT License (MIT)

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

Index

Modules

Classes

Interfaces

Type aliases

Variables

Functions

Type aliases

AsyncIterableInput

EventListenerOptions

EventListenerOptions: object | boolean

EventedTarget

EventedTarget: EventTarget | NodeEventEmitter

MergeResult

MergeResult: object

Type declaration

index: number
value: T

MonoTypeOperatorAsyncFunction

MonoTypeOperatorAsyncFunction: OperatorAsyncFunction<T, T>

MonoTypeOperatorFunction

MonoTypeOperatorFunction: OperatorFunction<T, T>

NodeEventEmitter

NodeEventEmitter: object

Type declaration

addListener: function
- - (eventName: string, handler: Function): void
  - Parameters
    - eventName: string
    - handler: Function
    Returns void
removeListener: function
- - (eventName: string, handler: Function): void
  - Parameters
    - eventName: string
    - handler: Function
    Returns void

OperatorAsyncFunction

OperatorAsyncFunction: UnaryFunction<AsyncIterable<T>, AsyncIterableX<R>>

OperatorFunction

OperatorFunction: UnaryFunction<Iterable<T>, IterableX<R>>

PartialAsyncObserver

PartialAsyncObserver: NextAsyncObserver<T> | ErrorAsyncObserver<T> | CompletionAsyncObserver<T>

PartialObserver

PartialObserver: NextObserver<T> | ErrorObserver<T> | CompletionObserver<T>

UnaryFunction

UnaryFunction: function

Type declaration

- (source: T): R
- Parameters
  - source: T
  Returns R

Variables

Const ARRAY_ERROR

ARRAY_ERROR: "error" = "error"

Const ARRAY_VALUE

ARRAY_VALUE: "value" = "value"

Const ENDED

ENDED: 2 = 2

Const ERRORED

ERRORED: 3 = 3

Const ERROR_TYPE

ERROR_TYPE: "error" = "error"

Const NEVER_PROMISE

NEVER_PROMISE: Promise<Object> = new Promise(() => {})

Const NON_FLOWING

NON_FLOWING: 0 = 0

Const READABLE

READABLE: 1 = 1

Const VALUE_TYPE

VALUE_TYPE: "value" = "value"

Const maxSafeInteger

maxSafeInteger: number = Math.pow(2, 53) - 1

Functions

_case

_case<TSource, TResult>(selector: function, sources: Map<TSource, AsyncIterable<TResult>>, defaultSource?: AsyncIterable<TResult>): AsyncIterableX<TResult>

- Defined in asynciterable/case.ts:5
Returns a sequence from a dictionary based on the result of evaluating a selector function.

Type parameters
- TSource
- TResult
Parameters
- selector: function
 
 Selector function used to pick a sequence from the given sources.
 - - (): TSource | Promise<TSource>
 - Returns TSource | Promise<TSource>
- sources: Map<TSource, AsyncIterable<TResult>>
 
 Dictionary mapping selector values onto resulting sequences.
- Default value defaultSource: AsyncIterable<TResult> = empty<TResult>()
Returns AsyncIterableX<TResult>

The source sequence corresponding with the evaluated selector value; otherwise, the default source.

_catch

_catch<T>(source: AsyncIterable<T>, ...args: AsyncIterable<T>[]): AsyncIterableX<T>

- Defined in asynciterable/catch.ts:59
Creates a sequence by concatenating source sequences until a source sequence completes successfully.

Type parameters
- T
Parameters
- source: AsyncIterable<T>
 
 The first source.
- Rest ...args: AsyncIterable<T>[]
 
 The rest of the sequence that continues to concatenate source sequences while errors occur.
Returns AsyncIterableX<T>

_catchAll

_catchAll<TSource>(source: Iterable<AsyncIterable<TSource>>): AsyncIterableX<TSource>

- Defined in asynciterable/catch.ts:53
Creates a sequence by concatenating source sequences until a source sequence completes successfully.

Type parameters
- TSource
Parameters
- source: Iterable<AsyncIterable<TSource>>
 
 Source sequences.
Returns AsyncIterableX<TSource>

Sequence that continues to concatenate source sequences while errors occur.

_catchStatic

_catchStatic<T>(...source: AsyncIterable<T>[]): AsyncIterableX<T>

- Defined in asynciterable/catch.ts:66
Creates a sequence by concatenating source sequences until a source sequence completes successfully.

Type parameters
- T
Parameters
- Rest ...source: AsyncIterable<T>[]
 
 Sequence that continues to concatenate source sequences while errors occur.
Returns AsyncIterableX<T>

Sequence that continues to concatenate source sequences while errors occur.

_concatAll

_concatAll<TSource>(source: Iterable<AsyncIterable<TSource>>): AsyncIterableX<TSource>

- Defined in asynciterable/concat.ts:20
Type parameters
- TSource
Parameters
- source: Iterable<AsyncIterable<TSource>>
Returns AsyncIterableX<TSource>

_finally

_finally<TSource>(source: AsyncIterable<TSource>, action: function): AsyncIterableX<TSource>

- Defined in asynciterable/finally.ts:24
Creates a sequence whose termination or disposal of an iterator causes a finally action to be executed.

Type parameters
- TSource
Parameters
- source: AsyncIterable<TSource>
 
 Source sequence
- action: function
 
 Action to run upon termination of the sequence, or when an iterator is disposed.
 - - (): void | Promise<void>
 - Returns void | Promise<void>
Returns AsyncIterableX<TSource>

Source sequence with guarantees on the invocation of the finally action.

_for

_for<TSource, TResult>(source: AsyncIterable<TSource>, fn: function): AsyncIterableX<TResult>

- Defined in asynciterable/for.ts:5
Concatenates the iterable sequences obtained by running the result selector for each element in the given source sequence.

Type parameters
- TSource
- TResult
Parameters
- source: AsyncIterable<TSource>
 
 Iterable source for which each element will be mapped onto an iterable source that will be concatenated in the result sequence.
- fn: function
 - - (value: TSource): AsyncIterable<TResult> | Promise<AsyncIterable<TResult>>
 - Parameters
 - value: TSource
 Returns AsyncIterable<TResult> | Promise<AsyncIterable<TResult>>
Returns AsyncIterableX<TResult>

The iterable sequence obtained by concatenating the sources returned by result selector for each element in the source.

_if

_if<TSource>(fn: function, thenSource: AsyncIterable<TSource>, elseSource?: AsyncIterable<TSource>): AsyncIterableX<TSource>

- Defined in asynciterable/if.ts:5
Type parameters
- TSource
Parameters
- fn: function
 - - (): boolean | Promise<boolean>
 - Returns boolean | Promise<boolean>
- thenSource: AsyncIterable<TSource>
- Default value elseSource: AsyncIterable<TSource> = empty<TSource>()
Returns AsyncIterableX<TSource>

_throw

_throw<TSource>(error: any): AsyncIterableX<TSource>

- Defined in asynciterable/throw.ts:16
Type parameters
- TSource
Parameters
- error: any
Returns AsyncIterableX<TSource>

_while

_while<TSource>(condition: function, source: AsyncIterable<TSource>): AsyncIterableX<TSource>

- Defined in asynciterable/while.ts:22
Type parameters
- TSource
Parameters
- condition: function
 - - (): boolean | Promise<boolean>
 - Returns boolean | Promise<boolean>
- source: AsyncIterable<TSource>
Returns AsyncIterableX<TSource>

arrayIndexOf

arrayIndexOf<T>(array: T[], item: T, comparer: function): number

- Defined in internal/arrayindexof.ts:4
ignore

Type parameters
- T
Parameters
- array: T[]
- item: T
- comparer: function
  - - (a: T, b: T): boolean
    - Parameters
      - a: T
      - b: T
      Returns boolean
Returns number

arrayIndexOfAsync

arrayIndexOfAsync<T>(array: T[], item: T, comparer: function): Promise<number>

- Defined in internal/arrayindexof.ts:16
ignore

Type parameters
- T
Parameters
- array: T[]
- item: T
- comparer: function
 - - (a: T, b: T): boolean | Promise<boolean>
 - Parameters
 - a: T
 - b: T
 Returns boolean | Promise<boolean>
Returns Promise<number>

arrayRemove

arrayRemove<T>(array: T[], item: T, comparer: function): Promise<boolean>

- Defined in asynciterable/intersect.ts:5
Type parameters
- T
Parameters
- array: T[]
- item: T
- comparer: function
 - - (x: T, y: T): boolean | Promise<boolean>
 - Parameters
 - x: T
 - y: T
 Returns boolean | Promise<boolean>
Returns Promise<boolean>

asyncify

asyncify<TSource>(func: Function): function

- Defined in asynciterable/asyncify.ts:5
Type parameters
- TSource
Parameters
- func: Function
Returns function
- - (...args: any[]): AsyncIterableX<TSource>
 - Parameters
 - Rest ...args: any[]
 Returns AsyncIterableX<TSource>

asyncifyErrback

asyncifyErrback<TSource>(func: Function): function

- Defined in asynciterable/asyncifyerrback.ts:5
Type parameters
- TSource
Parameters
- func: Function
Returns function
- - (...args: any[]): AsyncIterableX<TSource>
 - Parameters
 - Rest ...args: any[]
 Returns AsyncIterableX<TSource>

average

average(source: Iterable<number | PromiseLike<number>> | AsyncIterable<number>, selector?: undefined | function): Promise<number>
average<TSource>(source: Iterable<TSource | PromiseLike<TSource>> | AsyncIterable<TSource>, selector?: undefined | function): Promise<number>
average(source: Iterable<number>, selector?: undefined | function): number
average<T>(source: Iterable<T>, selector?: undefined | function): number

- Defined in asynciterable/average.ts:3
Computes the average of a sequence of values from the sequence either from the sequence itself or from the selector function.

Parameters
- source: Iterable<number | PromiseLike<number>> | AsyncIterable<number>
 
 A sequence of values to calculate the average of.
- Optional selector: undefined | function
Returns Promise<number>

The average of the sequence of values.
- Defined in asynciterable/average.ts:7
Computes the average of a sequence of values from the sequence either from the sequence itself or from the selector function.

Type parameters
- TSource
Parameters
- source: Iterable<TSource | PromiseLike<TSource>> | AsyncIterable<TSource>
 
 A sequence of values to calculate the average of.
- Optional selector: undefined | function
Returns Promise<number>

The average of the sequence of values.
- Defined in iterable/average.ts:3
Computes the average of a sequence of values from the sequence either from the sequence itself or from the selector function.

Parameters
- source: Iterable<number>
 
 A sequence of values to calculate the average of.
- Optional selector: undefined | function
Returns number

The average of the sequence of values.
- Defined in iterable/average.ts:4
Computes the average of a sequence of values from the sequence either from the sequence itself or from the selector function.

Type parameters
- T
Parameters
- source: Iterable<T>
 
 A sequence of values to calculate the average of.
- Optional selector: undefined | function
Returns number

The average of the sequence of values.

averageProto

averageProto(this: IterableX<number>, selector?: undefined | function): number
averageProto<T>(this: IterableX<T>, selector?: undefined | function): number
averageProto(this: AsyncIterableX<number>, selector?: undefined | function): Promise<number>
averageProto<T>(this: AsyncIterableX<T>, selector?: undefined | function): Promise<number>

- Defined in add/iterable-operators/average.ts:5
Parameters
- this: IterableX<number>
- Optional selector: undefined | function
Returns number
- Defined in add/iterable-operators/average.ts:6
Type parameters
- T
Parameters
- this: IterableX<T>
- Optional selector: undefined | function
Returns number
- Defined in add/asynciterable-operators/average.ts:5
Parameters
- this: AsyncIterableX<number>
- Optional selector: undefined | function
Returns Promise<number>
- Defined in add/asynciterable-operators/average.ts:9
Type parameters
- T
Parameters
- this: AsyncIterableX<T>
- Optional selector: undefined | function
Returns Promise<number>

bindCallback

bindCallback(func: any, thisArg: any, argCount: number): any

- Defined in internal/bindcallback.ts:4
ignore

Parameters
- func: any
- thisArg: any
- argCount: number
Returns any

buffer

buffer<TSource>(source: AsyncIterable<TSource>, count: number, skip?: undefined | number): AsyncIterableX<TSource[]>

- Defined in asynciterable/buffer.ts:40
Generates a sequence of buffers over the source sequence, with specified length and possible overlap.

Type parameters
- TSource
Parameters
- source: AsyncIterable<TSource>
 
 Source sequence
- count: number
 
 Number of elements for allocated buffers.
- Optional skip: undefined | number
Returns AsyncIterableX<TSource[]>

Sequence of buffers containing source sequence elements

bufferProto

bufferProto<T>(this: IterableX<T>, count: number, skip?: undefined | number): IterableX<T[]>

- Defined in add/iterable-operators/buffer.ts:7
ignore

Type parameters
- T
Parameters
- this: IterableX<T>
- count: number
- Optional skip: undefined | number
Returns IterableX<T[]>

catchProto

catchProto<T>(this: IterableX<T>, ...args: Iterable<T>[]): IterableX<T>

- Defined in add/iterable-operators/catch.ts:7
ignore

Type parameters
- T
Parameters
- this: IterableX<T>
- Rest ...args: Iterable<T>[]
Returns IterableX<T>

catchWith

catchWith<TSource>(source: AsyncIterable<TSource>, handler: function): AsyncIterableX<TSource>

- Defined in asynciterable/catchwith.ts:48
Creates a sequence that corresponds to the source sequence, concatenating it with the sequence resulting from calling an exception handler function in case of an error.

Type parameters
- TSource
Parameters
- source: AsyncIterable<TSource>
 
 Source sequence
- handler: function
 
 Handler to invoke when an exception of the specified type occurs.
 - - (error: any): AsyncIterable<TSource> | Promise<AsyncIterable<TSource>>
 - Parameters
 - error: any
 Returns AsyncIterable<TSource> | Promise<AsyncIterable<TSource>>
Returns AsyncIterableX<TSource>

Source sequence, concatenated with an exception handler result sequence in case of an error.

catchWithProto

catchWithProto<T>(this: IterableX<T>, fn: function): IterableX<T>

- Defined in add/iterable-operators/catchwith.ts:7
ignore

Type parameters
- T
Parameters
- this: IterableX<T>
- fn: function
 - - (error: any): Iterable<T>
 - Parameters
 - error: any
 Returns Iterable<T>
Returns IterableX<T>

chain

chain<TSource, TResult>(source: AsyncIterable<TSource>, selector: function): AsyncIterableX<TResult>

- Defined in asynciterable/chain.ts:26
Returns an async iterable sequence that is the result of invoking the selector on the source sequence, without sharing subscriptions. This operator allows for a fluent style of writing queries that use the same sequence multiple times.

Type parameters
- TSource
- TResult
Parameters
- source: AsyncIterable<TSource>
 
 Source sequence that will be shared in the selector function.
- selector: function
 
 Selector function which can use the source sequence as many times as needed, without sharing subscriptions to the source sequence.
 - - (source: AsyncIterable<TSource>): AsyncIterable<TResult>
 - Parameters
 - source: AsyncIterable<TSource>
 Returns AsyncIterable<TResult>
Returns AsyncIterableX<TResult>

An async iterable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function.

chainProto

chainProto<TSource, TResult>(this: IterableX<TSource>, selector: function): IterableX<TResult>

- Defined in add/iterable-operators/chain.ts:7
ignore

Type parameters
- TSource
- TResult
Parameters
- this: IterableX<TSource>
- selector: function
 - - (source: Iterable<TSource>): Iterable<TResult>
 - Parameters
 - source: Iterable<TSource>
 Returns Iterable<TResult>
Returns IterableX<TResult>

combineLatest

combineLatest<T, T2>(source: AsyncIterable<T>, source2: AsyncIterable<T2>): AsyncIterableX<[T, T2]>
combineLatest<T, T2, T3>(source: AsyncIterable<T>, source2: AsyncIterable<T2>, source3: AsyncIterable<T3>): AsyncIterableX<[T, T2, T3]>
combineLatest<T, T2, T3, T4>(source: AsyncIterable<T>, source2: AsyncIterable<T2>, source3: AsyncIterable<T3>, source4: AsyncIterable<T4>): AsyncIterableX<[T, T2, T3, T4]>
combineLatest<T, T2, T3, T4, T5>(source: AsyncIterable<T>, source2: AsyncIterable<T2>, source3: AsyncIterable<T3>, source4: AsyncIterable<T4>, source5: AsyncIterable<T5>): AsyncIterableX<[T, T2, T3, T4, T5]>
combineLatest<T, T2, T3, T4, T5, T6>(source: AsyncIterable<T>, source2: AsyncIterable<T2>, source3: AsyncIterable<T3>, source4: AsyncIterable<T4>, source5: AsyncIterable<T5>, source6: AsyncIterable<T6>): AsyncIterableX<[T, T2, T3, T4, T5, T6]>
combineLatest<T, R>(project: function, source: AsyncIterable<T>): AsyncIterableX<R>
combineLatest<T, T2, R>(project: function, source: AsyncIterable<T>, source2: AsyncIterable<T2>): AsyncIterableX<R>
combineLatest<T, T2, T3, R>(project: function, source: AsyncIterable<T>, source2: AsyncIterable<T2>, source3: AsyncIterable<T3>): AsyncIterableX<R>
combineLatest<T, T2, T3, T4, R>(project: function, source: AsyncIterable<T>, source2: AsyncIterable<T2>, source3: AsyncIterable<T3>, source4: AsyncIterable<T4>): AsyncIterableX<R>
combineLatest<T, T2, T3, T4, T5, R>(project: function, source: AsyncIterable<T>, source2: AsyncIterable<T2>, source3: AsyncIterable<T3>, source4: AsyncIterable<T4>, source5: AsyncIterable<T5>): AsyncIterableX<R>
combineLatest<T, T2, T3, T4, T5, T6, R>(project: function, source: AsyncIterable<T>, source2: AsyncIterable<T2>, source3: AsyncIterable<T3>, source4: AsyncIterable<T4>, source5: AsyncIterable<T5>, source6: AsyncIterable<T6>): AsyncIterableX<R>
combineLatest<T>(...sources: AsyncIterable<T>[]): AsyncIterableX<T[]>
combineLatest<T, R>(project: function, ...sources: AsyncIterable<T>[]): AsyncIterableX<R>
combineLatest<T, T2>(source: AsyncIterable<T>, source2: AsyncIterable<T2>): OperatorAsyncFunction<T, [T, T2]>
combineLatest<T, T2, T3>(source2: AsyncIterable<T2>, source3: AsyncIterable<T3>): OperatorAsyncFunction<T, [T, T2, T3]>
combineLatest<T, T2, T3, T4>(source2: AsyncIterable<T2>, source3: AsyncIterable<T3>, source4: AsyncIterable<T4>): OperatorAsyncFunction<T, [T, T2, T3, T4]>
combineLatest<T, T2, T3, T4, T5>(source2: AsyncIterable<T2>, source3: AsyncIterable<T3>, source4: AsyncIterable<T4>, source5: AsyncIterable<T5>): OperatorAsyncFunction<T, [T, T2, T3, T4, T5]>
combineLatest<T, T2, T3, T4, T5, T6>(source2: AsyncIterable<T2>, source3: AsyncIterable<T3>, source4: AsyncIterable<T4>, source5: AsyncIterable<T5>, source6: AsyncIterable<T6>): OperatorAsyncFunction<T, [T, T2, T3, T4, T5, T6]>
combineLatest<T, T2, R>(project: function, source2: AsyncIterable<T2>): OperatorAsyncFunction<T, R>
combineLatest<T, T2, T3, R>(project: function, source2: AsyncIterable<T2>, source3: AsyncIterable<T3>): OperatorAsyncFunction<T, R>
combineLatest<T, T2, T3, T4, R>(project: function, source2: AsyncIterable<T2>, source3: AsyncIterable<T3>, source4: AsyncIterable<T4>): OperatorAsyncFunction<T, R>
combineLatest<T, T2, T3, T4, T5, R>(project: function, source2: AsyncIterable<T2>, source3: AsyncIterable<T3>, source4: AsyncIterable<T4>, source5: AsyncIterable<T5>): OperatorAsyncFunction<T, R>
combineLatest<T, T2, T3, T4, T5, T6, R>(project: function, source2: AsyncIterable<T2>, source3: AsyncIterable<T3>, source4: AsyncIterable<T4>, source5: AsyncIterable<T5>, source6: AsyncIterable<T6>): OperatorAsyncFunction<T, R>
combineLatest<T>(...sources: AsyncIterable<T>[]): OperatorAsyncFunction<T, T[]>
combineLatest<T, R>(project: function, ...sources: AsyncIterable<T>[]): OperatorAsyncFunction<T, R>

- Defined in asynciterable/combinelatest.ts:65
Type parameters
- T
- T2
Parameters
- source: AsyncIterable<T>
- source2: AsyncIterable<T2>
Returns AsyncIterableX<[T, T2]>
- Defined in asynciterable/combinelatest.ts:69
Type parameters
- T
- T2
- T3
Parameters
- source: AsyncIterable<T>
- source2: AsyncIterable<T2>
- source3: AsyncIterable<T3>
Returns AsyncIterableX<[T, T2, T3]>
- Defined in asynciterable/combinelatest.ts:74
Type parameters
- T
- T2
- T3
- T4
Parameters
- source: AsyncIterable<T>
- source2: AsyncIterable<T2>
- source3: AsyncIterable<T3>
- source4: AsyncIterable<T4>
Returns AsyncIterableX<[T, T2, T3, T4]>
- Defined in asynciterable/combinelatest.ts:80
Type parameters
- T
- T2
- T3
- T4
- T5
Parameters
- source: AsyncIterable<T>
- source2: AsyncIterable<T2>
- source3: AsyncIterable<T3>
- source4: AsyncIterable<T4>
- source5: AsyncIterable<T5>
Returns AsyncIterableX<[T, T2, T3, T4, T5]>
- Defined in asynciterable/combinelatest.ts:87
Type parameters
- T
- T2
- T3
- T4
- T5
- T6
Parameters
- source: AsyncIterable<T>
- source2: AsyncIterable<T2>
- source3: AsyncIterable<T3>
- source4: AsyncIterable<T4>
- source5: AsyncIterable<T5>
- source6: AsyncIterable<T6>
Returns AsyncIterableX<[T, T2, T3, T4, T5, T6]>
- Defined in asynciterable/combinelatest.ts:96
Type parameters
- T
- R
Parameters
- project: function
 - - (values: [T]): R | Promise<R>
 - Parameters
 - values: [T]
 Returns R | Promise<R>
- source: AsyncIterable<T>
Returns AsyncIterableX<R>
- Defined in asynciterable/combinelatest.ts:100
Type parameters
- T
- T2
- R
Parameters
- project: function
 - - (values: [T, T2]): R | Promise<R>
 - Parameters
 - values: [T, T2]
 Returns R | Promise<R>
- source: AsyncIterable<T>
- source2: AsyncIterable<T2>
Returns AsyncIterableX<R>
- Defined in asynciterable/combinelatest.ts:105
Type parameters
- T
- T2
- T3
- R
Parameters
- project: function
 - - (values: [T, T2, T3]): R | Promise<R>
 - Parameters
 - values: [T, T2, T3]
 Returns R | Promise<R>
- source: AsyncIterable<T>
- source2: AsyncIterable<T2>
- source3: AsyncIterable<T3>
Returns AsyncIterableX<R>
- Defined in asynciterable/combinelatest.ts:111
Type parameters
- T
- T2
- T3
- T4
- R
Parameters
- project: function
 - - (values: [T, T2, T3, T4]): R | Promise<R>
 - Parameters
 - values: [T, T2, T3, T4]
 Returns R | Promise<R>
- source: AsyncIterable<T>
- source2: AsyncIterable<T2>
- source3: AsyncIterable<T3>
- source4: AsyncIterable<T4>
Returns AsyncIterableX<R>
- Defined in asynciterable/combinelatest.ts:118
Type parameters
- T
- T2
- T3
- T4
- T5
- R
Parameters
- project: function
 - - (values: [T, T2, T3, T4, T5]): R | Promise<R>
 - Parameters
 - values: [T, T2, T3, T4, T5]
 Returns R | Promise<R>
- source: AsyncIterable<T>
- source2: AsyncIterable<T2>
- source3: AsyncIterable<T3>
- source4: AsyncIterable<T4>
- source5: AsyncIterable<T5>
Returns AsyncIterableX<R>
- Defined in asynciterable/combinelatest.ts:126
Type parameters
- T
- T2
- T3
- T4
- T5
- T6
- R
Parameters
- project: function
 - - (values: [T, T2, T3, T4, T5, T6]): R | Promise<R>
 - Parameters
 - values: [T, T2, T3, T4, T5, T6]
 Returns R | Promise<R>
- source: AsyncIterable<T>
- source2: AsyncIterable<T2>
- source3: AsyncIterable<T3>
- source4: AsyncIterable<T4>
- source5: AsyncIterable<T5>
- source6: AsyncIterable<T6>
Returns AsyncIterableX<R>
- Defined in asynciterable/combinelatest.ts:136
Type parameters
- T
Parameters
- Rest ...sources: AsyncIterable<T>[]
Returns AsyncIterableX<T[]>
- Defined in asynciterable/combinelatest.ts:137
Type parameters
- T
- R
Parameters
- project: function
 - - (values: T[]): R | Promise<R>
 - Parameters
 - values: T[]
 Returns R | Promise<R>
- Rest ...sources: AsyncIterable<T>[]
Returns AsyncIterableX<R>
- Defined in asynciterable/pipe/combinelatest.ts:6
Type parameters
- T
- T2
Parameters
- source: AsyncIterable<T>
- source2: AsyncIterable<T2>
Returns OperatorAsyncFunction<T, [T, T2]>
- Defined in asynciterable/pipe/combinelatest.ts:10
Type parameters
- T
- T2
- T3
Parameters
- source2: AsyncIterable<T2>
- source3: AsyncIterable<T3>
Returns OperatorAsyncFunction<T, [T, T2, T3]>
- Defined in asynciterable/pipe/combinelatest.ts:14
Type parameters
- T
- T2
- T3
- T4
Parameters
- source2: AsyncIterable<T2>
- source3: AsyncIterable<T3>
- source4: AsyncIterable<T4>
Returns OperatorAsyncFunction<T, [T, T2, T3, T4]>
- Defined in asynciterable/pipe/combinelatest.ts:19
Type parameters
- T
- T2
- T3
- T4
- T5
Parameters
- source2: AsyncIterable<T2>
- source3: AsyncIterable<T3>
- source4: AsyncIterable<T4>
- source5: AsyncIterable<T5>
Returns OperatorAsyncFunction<T, [T, T2, T3, T4, T5]>
- Defined in asynciterable/pipe/combinelatest.ts:25
Type parameters
- T
- T2
- T3
- T4
- T5
- T6
Parameters
- source2: AsyncIterable<T2>
- source3: AsyncIterable<T3>
- source4: AsyncIterable<T4>
- source5: AsyncIterable<T5>
- source6: AsyncIterable<T6>
Returns OperatorAsyncFunction<T, [T, T2, T3, T4, T5, T6]>
- Defined in asynciterable/pipe/combinelatest.ts:33
Type parameters
- T
- T2
- R
Parameters
- project: function
 - - (values: [T, T2]): R | Promise<R>
 - Parameters
 - values: [T, T2]
 Returns R | Promise<R>
- source2: AsyncIterable<T2>
Returns OperatorAsyncFunction<T, R>
- Defined in asynciterable/pipe/combinelatest.ts:37
Type parameters
- T
- T2
- T3
- R
Parameters
- project: function
 - - (values: [T, T2, T3]): R | Promise<R>
 - Parameters
 - values: [T, T2, T3]
 Returns R | Promise<R>
- source2: AsyncIterable<T2>
- source3: AsyncIterable<T3>
Returns OperatorAsyncFunction<T, R>
- Defined in asynciterable/pipe/combinelatest.ts:42
Type parameters
- T
- T2
- T3
- T4
- R
Parameters
- project: function
 - - (values: [T, T2, T3, T4]): R | Promise<R>
 - Parameters
 - values: [T, T2, T3, T4]
 Returns R | Promise<R>
- source2: AsyncIterable<T2>
- source3: AsyncIterable<T3>
- source4: AsyncIterable<T4>
Returns OperatorAsyncFunction<T, R>
- Defined in asynciterable/pipe/combinelatest.ts:48
Type parameters
- T
- T2
- T3
- T4
- T5
- R
Parameters
- project: function
 - - (values: [T, T2, T3, T4, T5]): R | Promise<R>
 - Parameters
 - values: [T, T2, T3, T4, T5]
 Returns R | Promise<R>
- source2: AsyncIterable<T2>
- source3: AsyncIterable<T3>
- source4: AsyncIterable<T4>
- source5: AsyncIterable<T5>
Returns OperatorAsyncFunction<T, R>
- Defined in asynciterable/pipe/combinelatest.ts:55
Type parameters
- T
- T2
- T3
- T4
- T5
- T6
- R
Parameters
- project: function
 - - (values: [T, T2, T3, T4, T5, T6]): R | Promise<R>
 - Parameters
 - values: [T, T2, T3, T4, T5, T6]
 Returns R | Promise<R>
- source2: AsyncIterable<T2>
- source3: AsyncIterable<T3>
- source4: AsyncIterable<T4>
- source5: AsyncIterable<T5>
- source6: AsyncIterable<T6>
Returns OperatorAsyncFunction<T, R>
- Defined in asynciterable/pipe/combinelatest.ts:64
Type parameters
- T
Parameters
- Rest ...sources: AsyncIterable<T>[]
Returns OperatorAsyncFunction<T, T[]>
- Defined in asynciterable/pipe/combinelatest.ts:65
Type parameters
- T
- R
Parameters
- project: function
 - - (values: T[]): R | Promise<R>
 - Parameters
 - values: T[]
 Returns R | Promise<R>
- Rest ...sources: AsyncIterable<T>[]
Returns OperatorAsyncFunction<T, R>

combineLatestProto

combineLatestProto<T, T2>(this: AsyncIterableX<T>, source2: AsyncIterable<T2>): AsyncIterableX<[T, T2]>
combineLatestProto<T, T2, T3>(this: AsyncIterableX<T>, source2: AsyncIterable<T2>, source3: AsyncIterable<T3>): AsyncIterableX<[T, T2, T3]>
combineLatestProto<T, T2, T3, T4>(this: AsyncIterableX<T>, source2: AsyncIterable<T2>, source3: AsyncIterable<T3>, source4: AsyncIterable<T4>): AsyncIterableX<[T, T2, T3, T4]>
combineLatestProto<T, T2, T3, T4, T5>(this: AsyncIterableX<T>, source2: AsyncIterable<T2>, source3: AsyncIterable<T3>, source4: AsyncIterable<T4>, source5: AsyncIterable<T5>): AsyncIterableX<[T, T2, T3, T4, T5]>
combineLatestProto<T, T2, T3, T4, T5, T6>(this: AsyncIterableX<T>, source2: AsyncIterable<T2>, source3: AsyncIterable<T3>, source4: AsyncIterable<T4>, source5: AsyncIterable<T5>, source6: AsyncIterable<T6>): AsyncIterableX<[T, T2, T3, T4, T5, T6]>
combineLatestProto<T, R>(this: AsyncIterableX<T>, project: function): AsyncIterableX<R>
combineLatestProto<T, T2, R>(this: AsyncIterableX<T>, project: function, source2: AsyncIterable<T2>): AsyncIterableX<R>
combineLatestProto<T, T2, T3, R>(this: AsyncIterableX<T>, project: function, source2: AsyncIterable<T2>, source3: AsyncIterable<T3>): AsyncIterableX<R>
combineLatestProto<T, T2, T3, T4, R>(this: AsyncIterableX<T>, project: function, source2: AsyncIterable<T2>, source3: AsyncIterable<T3>, source4: AsyncIterable<T4>): AsyncIterableX<R>
combineLatestProto<T, T2, T3, T4, T5, R>(this: AsyncIterableX<T>, project: function, source2: AsyncIterable<T2>, source3: AsyncIterable<T3>, source4: AsyncIterable<T4>, source5: AsyncIterable<T5>): AsyncIterableX<R>
combineLatestProto<T, T2, T3, T4, T5, T6, R>(this: AsyncIterableX<T>, project: function, source2: AsyncIterable<T2>, source3: AsyncIterable<T3>, source4: AsyncIterable<T4>, source5: AsyncIterable<T5>, source6: AsyncIterable<T6>): AsyncIterableX<R>
combineLatestProto<T>(this: AsyncIterableX<T>, ...sources: AsyncIterable<T>[]): AsyncIterableX<T[]>
combineLatestProto<T, R>(this: AsyncIterableX<T>, project: function, ...sources: AsyncIterable<T>[]): AsyncIterableX<R>

- Defined in add/asynciterable-operators/combinelatest.ts:8
ignore

Type parameters
- T
- T2
Parameters
- this: AsyncIterableX<T>
- source2: AsyncIterable<T2>
Returns AsyncIterableX<[T, T2]>
- Defined in add/asynciterable-operators/combinelatest.ts:12
Type parameters
- T
- T2
- T3
Parameters
- this: AsyncIterableX<T>
- source2: AsyncIterable<T2>
- source3: AsyncIterable<T3>
Returns AsyncIterableX<[T, T2, T3]>
- Defined in add/asynciterable-operators/combinelatest.ts:17
Type parameters
- T
- T2
- T3
- T4
Parameters
- this: AsyncIterableX<T>
- source2: AsyncIterable<T2>
- source3: AsyncIterable<T3>
- source4: AsyncIterable<T4>
Returns AsyncIterableX<[T, T2, T3, T4]>
- Defined in add/asynciterable-operators/combinelatest.ts:23
Type parameters
- T
- T2
- T3
- T4
- T5
Parameters
- this: AsyncIterableX<T>
- source2: AsyncIterable<T2>
- source3: AsyncIterable<T3>
- source4: AsyncIterable<T4>
- source5: AsyncIterable<T5>
Returns AsyncIterableX<[T, T2, T3, T4, T5]>
- Defined in add/asynciterable-operators/combinelatest.ts:30
Type parameters
- T
- T2
- T3
- T4
- T5
- T6
Parameters
- this: AsyncIterableX<T>
- source2: AsyncIterable<T2>
- source3: AsyncIterable<T3>
- source4: AsyncIterable<T4>
- source5: AsyncIterable<T5>
- source6: AsyncIterable<T6>
Returns AsyncIterableX<[T, T2, T3, T4, T5, T6]>
- Defined in add/asynciterable-operators/combinelatest.ts:39
Type parameters
- T
- R
Parameters
- this: AsyncIterableX<T>
- project: function
 - - (values: [T]): R
 - Parameters
 - values: [T]
 Returns R
Returns AsyncIterableX<R>
- Defined in add/asynciterable-operators/combinelatest.ts:43
Type parameters
- T
- T2
- R
Parameters
- this: AsyncIterableX<T>
- project: function
 - - (values: [T, T2]): R
 - Parameters
 - values: [T, T2]
 Returns R
- source2: AsyncIterable<T2>
Returns AsyncIterableX<R>
- Defined in add/asynciterable-operators/combinelatest.ts:48
Type parameters
- T
- T2
- T3
- R
Parameters
- this: AsyncIterableX<T>
- project: function
 - - (values: [T, T2, T3]): R
 - Parameters
 - values: [T, T2, T3]
 Returns R
- source2: AsyncIterable<T2>
- source3: AsyncIterable<T3>
Returns AsyncIterableX<R>
- Defined in add/asynciterable-operators/combinelatest.ts:54
Type parameters
- T
- T2
- T3
- T4
- R
Parameters
- this: AsyncIterableX<T>
- project: function
 - - (values: [T, T2, T3, T4]): R
 - Parameters
 - values: [T, T2, T3, T4]
 Returns R
- source2: AsyncIterable<T2>
- source3: AsyncIterable<T3>
- source4: AsyncIterable<T4>
Returns AsyncIterableX<R>
- Defined in add/asynciterable-operators/combinelatest.ts:61
Type parameters
- T
- T2
- T3
- T4
- T5
- R
Parameters
- this: AsyncIterableX<T>
- project: function
 - - (values: [T, T2, T3, T4, T5]): R
 - Parameters
 - values: [T, T2, T3, T4, T5]
 Returns R
- source2: AsyncIterable<T2>
- source3: AsyncIterable<T3>
- source4: AsyncIterable<T4>
- source5: AsyncIterable<T5>
Returns AsyncIterableX<R>
- Defined in add/asynciterable-operators/combinelatest.ts:69
Type parameters
- T
- T2
- T3
- T4
- T5
- T6
- R
Parameters
- this: AsyncIterableX<T>
- project: function
 - - (values: [T, T2, T3, T4, T5, T6]): R
 - Parameters
 - values: [T, T2, T3, T4, T5, T6]
 Returns R
- source2: AsyncIterable<T2>
- source3: AsyncIterable<T3>
- source4: AsyncIterable<T4>
- source5: AsyncIterable<T5>
- source6: AsyncIterable<T6>
Returns AsyncIterableX<R>
- Defined in add/asynciterable-operators/combinelatest.ts:79
Type parameters
- T
Parameters
- this: AsyncIterableX<T>
- Rest ...sources: AsyncIterable<T>[]
Returns AsyncIterableX<T[]>
- Defined in add/asynciterable-operators/combinelatest.ts:83
Type parameters
- T
- R
Parameters
- this: AsyncIterableX<T>
- project: function
 - - (values: T[]): R
 - Parameters
 - values: T[]
 Returns R
- Rest ...sources: AsyncIterable<T>[]
Returns AsyncIterableX<R>

comparer

comparer(x: any, y: any): boolean

- Defined in internal/comparer.ts:5
ignore

Parameters
- x: any
- y: any
Returns boolean

comparerAsync

comparerAsync(x: any, y: any): Promise<boolean>

- Defined in internal/comparer.ts:12
ignore

Parameters
- x: any
- y: any
Returns Promise<boolean>

concat

concat<T>(source: AsyncIterable<T>): AsyncIterableX<T>
concat<T, T2>(source: AsyncIterable<T>, v2: AsyncIterable<T2>): AsyncIterableX<T | T2>
concat<T, T2, T3>(source: AsyncIterable<T>, v2: AsyncIterable<T2>, v3: AsyncIterable<T3>): AsyncIterableX<T | T2 | T3>
concat<T, T2, T3, T4>(source: AsyncIterable<T>, v2: AsyncIterable<T2>, v3: AsyncIterable<T3>, v4: AsyncIterable<T4>): AsyncIterableX<T | T2 | T3 | T4>
concat<T, T2, T3, T4, T5>(source: AsyncIterable<T>, v2: AsyncIterable<T2>, v3: AsyncIterable<T3>, v4: AsyncIterable<T4>, v5: AsyncIterable<T5>): AsyncIterable<T | T2 | T3 | T4 | T5>
concat<T, T2, T3, T4, T5, T6>(source: AsyncIterable<T>, v2: AsyncIterable<T2>, v3: AsyncIterable<T3>, v4: AsyncIterable<T4>, v5: AsyncIterable<T5>, v6: AsyncIterable<T6>): AsyncIterable<T | T2 | T3 | T4 | T5 | T6>
concat<T>(source: AsyncIterable<T>, ...args: AsyncIterable<T>[]): AsyncIterableX<T>
concat<T>(source: Iterable<T>): IterableX<T>
concat<T, T2>(source: Iterable<T>, v2: Iterable<T2>): IterableX<T | T2>
concat<T, T2, T3>(source: Iterable<T>, v2: Iterable<T2>, v3: Iterable<T3>): IterableX<T | T2 | T3>
concat<T, T2, T3, T4>(source: Iterable<T>, v2: Iterable<T2>, v3: Iterable<T3>, v4: Iterable<T4>): IterableX<T | T2 | T3 | T4>
concat<T, T2, T3, T4, T5>(source: Iterable<T>, v2: Iterable<T2>, v3: Iterable<T3>, v4: Iterable<T4>, v5: Iterable<T5>): Iterable<T | T2 | T3 | T4 | T5>
concat<T, T2, T3, T4, T5, T6>(source: Iterable<T>, v2: Iterable<T2>, v3: Iterable<T3>, v4: Iterable<T4>, v5: Iterable<T5>, v6: Iterable<T6>): Iterable<T | T2 | T3 | T4 | T5 | T6>
concat<T>(source: Iterable<T>, ...args: Iterable<T>[]): IterableX<T>
concat<T, T2>(v2: Iterable<T2>): MonoTypeOperatorFunction<T | T2>
concat<T, T2, T3>(v2: Iterable<T2>, v3: Iterable<T3>): MonoTypeOperatorFunction<T | T2 | T3>
concat<T, T2, T3, T4>(v2: Iterable<T2>, v3: Iterable<T3>, v4: Iterable<T4>): MonoTypeOperatorFunction<T | T2 | T3 | T4>
concat<T, T2, T3, T4, T5>(v2: Iterable<T2>, v3: Iterable<T3>, v4: Iterable<T4>, v5: Iterable<T5>): MonoTypeOperatorFunction<T | T2 | T3 | T4 | T5>
concat<T, T2, T3, T4, T5, T6>(v2: Iterable<T2>, v3: Iterable<T3>, v4: Iterable<T4>, v5: Iterable<T5>, v6: Iterable<T6>): MonoTypeOperatorFunction<T | T2 | T3 | T4 | T5 | T6>
concat<T, T2>(v2: AsyncIterable<T2>): MonoTypeOperatorAsyncFunction<T | T2>
concat<T, T2, T3>(v2: AsyncIterable<T2>, v3: AsyncIterable<T3>): MonoTypeOperatorAsyncFunction<T | T2 | T3>
concat<T, T2, T3, T4>(v2: AsyncIterable<T2>, v3: AsyncIterable<T3>, v4: AsyncIterable<T4>): MonoTypeOperatorAsyncFunction<T | T2 | T3 | T4>
concat<T, T2, T3, T4, T5>(v2: AsyncIterable<T2>, v3: AsyncIterable<T3>, v4: AsyncIterable<T4>, v5: AsyncIterable<T5>): MonoTypeOperatorAsyncFunction<T | T2 | T3 | T4 | T5>
concat<T, T2, T3, T4, T5, T6>(v2: AsyncIterable<T2>, v3: AsyncIterable<T3>, v4: AsyncIterable<T4>, v5: AsyncIterable<T5>, v6: AsyncIterable<T6>): MonoTypeOperatorAsyncFunction<T | T2 | T3 | T4 | T5 | T6>

- Defined in asynciterable/concat.ts:27
Type parameters
- T
Parameters
- source: AsyncIterable<T>
Returns AsyncIterableX<T>
- Defined in asynciterable/concat.ts:28
Type parameters
- T
- T2
Parameters
- source: AsyncIterable<T>
- v2: AsyncIterable<T2>
Returns AsyncIterableX<T | T2>
- Defined in asynciterable/concat.ts:32
Type parameters
- T
- T2
- T3
Parameters
- source: AsyncIterable<T>
- v2: AsyncIterable<T2>
- v3: AsyncIterable<T3>
Returns AsyncIterableX<T | T2 | T3>
- Defined in asynciterable/concat.ts:37
Type parameters
- T
- T2
- T3
- T4
Parameters
- source: AsyncIterable<T>
- v2: AsyncIterable<T2>
- v3: AsyncIterable<T3>
- v4: AsyncIterable<T4>
Returns AsyncIterableX<T | T2 | T3 | T4>
- Defined in asynciterable/concat.ts:43
Type parameters
- T
- T2
- T3
- T4
- T5
Parameters
- source: AsyncIterable<T>
- v2: AsyncIterable<T2>
- v3: AsyncIterable<T3>
- v4: AsyncIterable<T4>
- v5: AsyncIterable<T5>
Returns AsyncIterable<T | T2 | T3 | T4 | T5>
- Defined in asynciterable/concat.ts:50
Type parameters
- T
- T2
- T3
- T4
- T5
- T6
Parameters
- source: AsyncIterable<T>
- v2: AsyncIterable<T2>
- v3: AsyncIterable<T3>
- v4: AsyncIterable<T4>
- v5: AsyncIterable<T5>
- v6: AsyncIterable<T6>
Returns AsyncIterable<T | T2 | T3 | T4 | T5 | T6>
- Defined in asynciterable/concat.ts:58
Type parameters
- T
Parameters
- source: AsyncIterable<T>
- Rest ...args: AsyncIterable<T>[]
Returns AsyncIterableX<T>
- Defined in iterable/concat.ts:19
Type parameters
- T
Parameters
- source: Iterable<T>
Returns IterableX<T>
- Defined in iterable/concat.ts:20
Type parameters
- T
- T2
Parameters
- source: Iterable<T>
- v2: Iterable<T2>
Returns IterableX<T | T2>
- Defined in iterable/concat.ts:21
Type parameters
- T
- T2
- T3
Parameters
- source: Iterable<T>
- v2: Iterable<T2>
- v3: Iterable<T3>
Returns IterableX<T | T2 | T3>
- Defined in iterable/concat.ts:26
Type parameters
- T
- T2
- T3
- T4
Parameters
- source: Iterable<T>
- v2: Iterable<T2>
- v3: Iterable<T3>
- v4: Iterable<T4>
Returns IterableX<T | T2 | T3 | T4>
- Defined in iterable/concat.ts:32
Type parameters
- T
- T2
- T3
- T4
- T5
Parameters
- source: Iterable<T>
- v2: Iterable<T2>
- v3: Iterable<T3>
- v4: Iterable<T4>
- v5: Iterable<T5>
Returns Iterable<T | T2 | T3 | T4 | T5>
- Defined in iterable/concat.ts:39
Type parameters
- T
- T2
- T3
- T4
- T5
- T6
Parameters
- source: Iterable<T>
- v2: Iterable<T2>
- v3: Iterable<T3>
- v4: Iterable<T4>
- v5: Iterable<T5>
- v6: Iterable<T6>
Returns Iterable<T | T2 | T3 | T4 | T5 | T6>
- Defined in iterable/concat.ts:47
Type parameters
- T
Parameters
- source: Iterable<T>
- Rest ...args: Iterable<T>[]
Returns IterableX<T>
- Defined in iterable/pipe/concat.ts:6
Type parameters
- T
- T2
Parameters
- v2: Iterable<T2>
Returns MonoTypeOperatorFunction<T | T2>
- Defined in iterable/pipe/concat.ts:7
Type parameters
- T
- T2
- T3
Parameters
- v2: Iterable<T2>
- v3: Iterable<T3>
Returns MonoTypeOperatorFunction<T | T2 | T3>
- Defined in iterable/pipe/concat.ts:11
Type parameters
- T
- T2
- T3
- T4
Parameters
- v2: Iterable<T2>
- v3: Iterable<T3>
- v4: Iterable<T4>
Returns MonoTypeOperatorFunction<T | T2 | T3 | T4>
- Defined in iterable/pipe/concat.ts:16
Type parameters
- T
- T2
- T3
- T4
- T5
Parameters
- v2: Iterable<T2>
- v3: Iterable<T3>
- v4: Iterable<T4>
- v5: Iterable<T5>
Returns MonoTypeOperatorFunction<T | T2 | T3 | T4 | T5>
- Defined in iterable/pipe/concat.ts:22
Type parameters
- T
- T2
- T3
- T4
- T5
- T6
Parameters
- v2: Iterable<T2>
- v3: Iterable<T3>
- v4: Iterable<T4>
- v5: Iterable<T5>
- v6: Iterable<T6>
Returns MonoTypeOperatorFunction<T | T2 | T3 | T4 | T5 | T6>
- Defined in asynciterable/pipe/concat.ts:6
Type parameters
- T
- T2
Parameters
- v2: AsyncIterable<T2>
Returns MonoTypeOperatorAsyncFunction<T | T2>
- Defined in asynciterable/pipe/concat.ts:7
Type parameters
- T
- T2
- T3
Parameters
- v2: AsyncIterable<T2>
- v3: AsyncIterable<T3>
Returns MonoTypeOperatorAsyncFunction<T | T2 | T3>
- Defined in asynciterable/pipe/concat.ts:11
Type parameters
- T
- T2
- T3
- T4
Parameters
- v2: AsyncIterable<T2>
- v3: AsyncIterable<T3>
- v4: AsyncIterable<T4>
Returns MonoTypeOperatorAsyncFunction<T | T2 | T3 | T4>
- Defined in asynciterable/pipe/concat.ts:16
Type parameters
- T
- T2
- T3
- T4
- T5
Parameters
- v2: AsyncIterable<T2>
- v3: AsyncIterable<T3>
- v4: AsyncIterable<T4>
- v5: AsyncIterable<T5>
Returns MonoTypeOperatorAsyncFunction<T | T2 | T3 | T4 | T5>
- Defined in asynciterable/pipe/concat.ts:22
Type parameters
- T
- T2
- T3
- T4
- T5
- T6
Parameters
- v2: AsyncIterable<T2>
- v3: AsyncIterable<T3>
- v4: AsyncIterable<T4>
- v5: AsyncIterable<T5>
- v6: AsyncIterable<T6>
Returns MonoTypeOperatorAsyncFunction<T | T2 | T3 | T4 | T5 | T6>

concatAll

concatAll<TSource>(source: AsyncIterable<AsyncIterable<TSource>>): AsyncIterableX<TSource>

- Defined in asynciterable/concatall.ts:20
Concatenates the input sequences.

Type parameters
- TSource
Parameters
- source: AsyncIterable<AsyncIterable<TSource>>
 
 Source sequences.
Returns AsyncIterableX<TSource>

Sequence with the elements of the source sequences concatenated.

concatAllProto

concatAllProto<T>(this: IterableX<Iterable<T>>): IterableX<T>

- Defined in add/iterable-operators/concatall.ts:7
ignore

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

concatProto

concatProto<T>(this: IterableX<T>): IterableX<T>
concatProto<T, T2>(this: IterableX<T>, v2: Iterable<T2>): IterableX<T | T2>
concatProto<T, T2, T3>(this: IterableX<T>, v2: Iterable<T2>, v3: Iterable<T3>): IterableX<T | T2 | T3>
concatProto<T, T2, T3, T4>(this: IterableX<T>, v2: Iterable<T2>, v3: Iterable<T3>, v4: Iterable<T4>): IterableX<T | T2 | T3 | T4>
concatProto<T, T2, T3, T4, T5>(this: IterableX<T>, v2: Iterable<T2>, v3: Iterable<T3>, v4: Iterable<T4>, v5: Iterable<T5>): Iterable<T | T2 | T3 | T4 | T5>
concatProto<T, T2, T3, T4, T5, T6>(this: IterableX<T>, v2: Iterable<T2>, v3: Iterable<T3>, v4: Iterable<T4>, v5: Iterable<T5>, v6: Iterable<T6>): Iterable<T | T2 | T3 | T4 | T5 | T6>
concatProto<T>(this: AsyncIterableX<T>): AsyncIterableX<T>
concatProto<T, T2>(this: AsyncIterableX<T>, v2: AsyncIterable<T2>): AsyncIterableX<T | T2>
concatProto<T, T2, T3>(this: AsyncIterableX<T>, v2: AsyncIterable<T2>, v3: AsyncIterable<T3>): AsyncIterableX<T | T2 | T3>
concatProto<T, T2, T3, T4>(this: AsyncIterableX<T>, v2: AsyncIterable<T2>, v3: AsyncIterable<T3>, v4: AsyncIterable<T4>): AsyncIterableX<T | T2 | T3 | T4>
concatProto<T, T2, T3, T4, T5>(this: AsyncIterableX<T>, v2: AsyncIterable<T2>, v3: AsyncIterable<T3>, v4: AsyncIterable<T4>, v5: AsyncIterable<T5>): AsyncIterable<T | T2 | T3 | T4 | T5>
concatProto<T, T2, T3, T4, T5, T6>(this: AsyncIterableX<T>, v2: AsyncIterable<T2>, v3: AsyncIterable<T3>, v4: AsyncIterable<T4>, v5: AsyncIterable<T5>, v6: AsyncIterable<T6>): AsyncIterable<T | T2 | T3 | T4 | T5 | T6>

- Defined in add/iterable-operators/concat.ts:8
ignore

Type parameters
- T
Parameters
- this: IterableX<T>
Returns IterableX<T>
- Defined in add/iterable-operators/concat.ts:12
ignore

Type parameters
- T
- T2
Parameters
- this: IterableX<T>
- v2: Iterable<T2>
Returns IterableX<T | T2>
- Defined in add/iterable-operators/concat.ts:13
Type parameters
- T
- T2
- T3
Parameters
- this: IterableX<T>
- v2: Iterable<T2>
- v3: Iterable<T3>
Returns IterableX<T | T2 | T3>
- Defined in add/iterable-operators/concat.ts:21
ignore

Type parameters
- T
- T2
- T3
- T4
Parameters
- this: IterableX<T>
- v2: Iterable<T2>
- v3: Iterable<T3>
- v4: Iterable<T4>
Returns IterableX<T | T2 | T3 | T4>
- Defined in add/iterable-operators/concat.ts:30
ignore

Type parameters
- T
- T2
- T3
- T4
- T5
Parameters
- this: IterableX<T>
- v2: Iterable<T2>
- v3: Iterable<T3>
- v4: Iterable<T4>
- v5: Iterable<T5>
Returns Iterable<T | T2 | T3 | T4 | T5>
- Defined in add/iterable-operators/concat.ts:40
ignore

Type parameters
- T
- T2
- T3
- T4
- T5
- T6
Parameters
- this: IterableX<T>
- v2: Iterable<T2>
- v3: Iterable<T3>
- v4: Iterable<T4>
- v5: Iterable<T5>
- v6: Iterable<T6>
Returns Iterable<T | T2 | T3 | T4 | T5 | T6>
- Defined in add/asynciterable-operators/concat.ts:8
ignore

Type parameters
- T
Parameters
- this: AsyncIterableX<T>
Returns AsyncIterableX<T>
- Defined in add/asynciterable-operators/concat.ts:12
ignore

Type parameters
- T
- T2
Parameters
- this: AsyncIterableX<T>
- v2: AsyncIterable<T2>
Returns AsyncIterableX<T | T2>
- Defined in add/asynciterable-operators/concat.ts:19
ignore

Type parameters
- T
- T2
- T3
Parameters
- this: AsyncIterableX<T>
- v2: AsyncIterable<T2>
- v3: AsyncIterable<T3>
Returns AsyncIterableX<T | T2 | T3>
- Defined in add/asynciterable-operators/concat.ts:27
ignore

Type parameters
- T
- T2
- T3
- T4
Parameters
- this: AsyncIterableX<T>
- v2: AsyncIterable<T2>
- v3: AsyncIterable<T3>
- v4: AsyncIterable<T4>
Returns AsyncIterableX<T | T2 | T3 | T4>
- Defined in add/asynciterable-operators/concat.ts:36
ignore

Type parameters
- T
- T2
- T3
- T4
- T5
Parameters
- this: AsyncIterableX<T>
- v2: AsyncIterable<T2>
- v3: AsyncIterable<T3>
- v4: AsyncIterable<T4>
- v5: AsyncIterable<T5>
Returns AsyncIterable<T | T2 | T3 | T4 | T5>
- Defined in add/asynciterable-operators/concat.ts:46
ignore

Type parameters
- T
- T2
- T3
- T4
- T5
- T6
Parameters
- this: AsyncIterableX<T>
- v2: AsyncIterable<T2>
- v3: AsyncIterable<T3>
- v4: AsyncIterable<T4>
- v5: AsyncIterable<T5>
- v6: AsyncIterable<T6>
Returns AsyncIterable<T | T2 | T3 | T4 | T5 | T6>

concatStatic

concatStatic<T>(v1: AsyncIterable<T>): AsyncIterableX<T>
concatStatic<T, T2>(v1: AsyncIterable<T>, v2: AsyncIterable<T2>): AsyncIterableX<T | T2>
concatStatic<T, T2, T3>(v1: AsyncIterable<T>, v2: AsyncIterable<T2>, v3: AsyncIterable<T3>): AsyncIterableX<T | T2 | T3>
concatStatic<T, T2, T3, T4>(v1: AsyncIterable<T>, v2: AsyncIterable<T2>, v3: AsyncIterable<T3>, v4: AsyncIterable<T4>): AsyncIterableX<T | T2 | T3 | T4>
concatStatic<T, T2, T3, T4, T5>(v1: AsyncIterable<T>, v2: AsyncIterable<T2>, v3: AsyncIterable<T3>, v4: AsyncIterable<T4>, v5: AsyncIterable<T5>): AsyncIterable<T | T2 | T3 | T4 | T5>
concatStatic<T, T2, T3, T4, T5, T6>(v1: AsyncIterable<T>, v2: AsyncIterable<T2>, v3: AsyncIterable<T3>, v4: AsyncIterable<T4>, v5: AsyncIterable<T5>, v6: AsyncIterable<T6>): AsyncIterable<T | T2 | T3 | T4 | T5 | T6>
concatStatic<T>(v1: Iterable<T>): IterableX<T>
concatStatic<T, T2>(v1: Iterable<T>, v2: Iterable<T2>): IterableX<T | T2>
concatStatic<T, T2, T3>(v1: Iterable<T>, v2: Iterable<T2>, v3: Iterable<T3>): IterableX<T | T2 | T3>
concatStatic<T, T2, T3, T4>(v1: Iterable<T>, v2: Iterable<T2>, v3: Iterable<T3>, v4: Iterable<T4>): IterableX<T | T2 | T3 | T4>
concatStatic<T, T2, T3, T4, T5>(v1: Iterable<T>, v2: Iterable<T2>, v3: Iterable<T3>, v4: Iterable<T4>, v5: Iterable<T5>): Iterable<T | T2 | T3 | T4 | T5>
concatStatic<T, T2, T3, T4, T5, T6>(v1: Iterable<T>, v2: Iterable<T2>, v3: Iterable<T3>, v4: Iterable<T4>, v5: Iterable<T5>, v6: Iterable<T6>): Iterable<T | T2 | T3 | T4 | T5 | T6>

- Defined in asynciterable/concat.ts:69
Type parameters
- T
Parameters
- v1: AsyncIterable<T>
Returns AsyncIterableX<T>
- Defined in asynciterable/concat.ts:70
Type parameters
- T
- T2
Parameters
- v1: AsyncIterable<T>
- v2: AsyncIterable<T2>
Returns AsyncIterableX<T | T2>
- Defined in asynciterable/concat.ts:74
Type parameters
- T
- T2
- T3
Parameters
- v1: AsyncIterable<T>
- v2: AsyncIterable<T2>
- v3: AsyncIterable<T3>
Returns AsyncIterableX<T | T2 | T3>
- Defined in asynciterable/concat.ts:79
Type parameters
- T
- T2
- T3
- T4
Parameters
- v1: AsyncIterable<T>
- v2: AsyncIterable<T2>
- v3: AsyncIterable<T3>
- v4: AsyncIterable<T4>
Returns AsyncIterableX<T | T2 | T3 | T4>
- Defined in asynciterable/concat.ts:85
Type parameters
- T
- T2
- T3
- T4
- T5
Parameters
- v1: AsyncIterable<T>
- v2: AsyncIterable<T2>
- v3: AsyncIterable<T3>
- v4: AsyncIterable<T4>
- v5: AsyncIterable<T5>
Returns AsyncIterable<T | T2 | T3 | T4 | T5>
- Defined in asynciterable/concat.ts:92
Type parameters
- T
- T2
- T3
- T4
- T5
- T6
Parameters
- v1: AsyncIterable<T>
- v2: AsyncIterable<T2>
- v3: AsyncIterable<T3>
- v4: AsyncIterable<T4>
- v5: AsyncIterable<T5>
- v6: AsyncIterable<T6>
Returns AsyncIterable<T | T2 | T3 | T4 | T5 | T6>
- Defined in iterable/concat.ts:55
Type parameters
- T
Parameters
- v1: Iterable<T>
Returns IterableX<T>
- Defined in iterable/concat.ts:56
Type parameters
- T
- T2
Parameters
- v1: Iterable<T>
- v2: Iterable<T2>
Returns IterableX<T | T2>
- Defined in iterable/concat.ts:57
Type parameters
- T
- T2
- T3
Parameters
- v1: Iterable<T>
- v2: Iterable<T2>
- v3: Iterable<T3>
Returns IterableX<T | T2 | T3>
- Defined in iterable/concat.ts:62
Type parameters
- T
- T2
- T3
- T4
Parameters
- v1: Iterable<T>
- v2: Iterable<T2>
- v3: Iterable<T3>
- v4: Iterable<T4>
Returns IterableX<T | T2 | T3 | T4>
- Defined in iterable/concat.ts:68
Type parameters
- T
- T2
- T3
- T4
- T5
Parameters
- v1: Iterable<T>
- v2: Iterable<T2>
- v3: Iterable<T3>
- v4: Iterable<T4>
- v5: Iterable<T5>
Returns Iterable<T | T2 | T3 | T4 | T5>
- Defined in iterable/concat.ts:75
Type parameters
- T
- T2
- T3
- T4
- T5
- T6
Parameters
- v1: Iterable<T>
- v2: Iterable<T2>
- v3: Iterable<T3>
- v4: Iterable<T4>
- v5: Iterable<T5>
- v6: Iterable<T6>
Returns Iterable<T | T2 | T3 | T4 | T5 | T6>

count

count<T>(source: AsyncIterable<T>, fn?: function): Promise<number>

- Defined in asynciterable/count.ts:1
Returns a number that represents how many elements in the specified sequence satisfy a condition if present, else the number of items in the collection.

Type parameters
- T
Parameters
- source: AsyncIterable<T>
 
 A sequence that contains elements to be tested and counted.
- Default value fn: function = async () => true
 - - (value: T): boolean | Promise<boolean>
 - Parameters
 - value: T
 Returns boolean | Promise<boolean>
Returns Promise<number>

countProto

countProto<T>(this: IterableX<T>, fn?: undefined | function): number

- Defined in add/iterable-operators/count.ts:7
ignore

Type parameters
- T
Parameters
- this: IterableX<T>
- Optional fn: undefined | function
Returns number

create

create<T>(fn: function): AsyncIterableX<T>

- Defined in asynciterable/create.ts:20
Creates an enumerable sequence based on an enumerator factory function.

Type parameters
- T
Parameters
- fn: function
 - - (): AsyncIterator<T> | Promise<AsyncIterator<T>>
 - Returns AsyncIterator<T> | Promise<AsyncIterator<T>>
Returns AsyncIterableX<T>

Sequence that will invoke the iterator factory upon a call to Symbol.iterator.

createGrouping

createGrouping<TSource, TKey, TValue>(source: AsyncIterable<TSource>, keySelector: function, elementSelector: function): Promise<Map<TKey, TValue[]>>

- Defined in asynciterable/_grouping.ts:4
ignore

Type parameters
- TSource
- TKey
- TValue
Parameters
- source: AsyncIterable<TSource>
- keySelector: function
 - - (value: TSource): TKey | Promise<TKey>
 - Parameters
 - value: TSource
 Returns TKey | Promise<TKey>
- elementSelector: function
 - - (value: TSource): TValue | Promise<TValue>
 - Parameters
 - value: TSource
 Returns TValue | Promise<TValue>
Returns Promise<Map<TKey, TValue[]>>

debounce

debounce<TSource>(source: AsyncIterable<TSource>, time: number): AsyncIterableX<TSource>

- Defined in asynciterable/debounce.ts:75
Type parameters
- TSource
Parameters
- source: AsyncIterable<TSource>
- time: number
Returns AsyncIterableX<TSource>

debounceProto

debounceProto<T>(this: AsyncIterableX<T>, time: number): AsyncIterableX<T>

- Defined in add/asynciterable-operators/debounce.ts:7
ignore

Type parameters
- T
Parameters
- this: AsyncIterableX<T>
- time: number
Returns AsyncIterableX<T>

defaultCompare

defaultCompare<T>(key: T, minValue: T): number

- Defined in iterable/_extremaby.ts:6
ignore

Type parameters
- T
Parameters
- key: T
- minValue: T
Returns number

defaultCompareAsync

defaultCompareAsync<T>(key: T, minValue: T): Promise<number>

- Defined in asynciterable/_extremaby.ts:6
ignore

Type parameters
- T
Parameters
- key: T
- minValue: T
Returns Promise<number>

defaultIfEmpty

defaultIfEmpty<T>(source: AsyncIterable<T>, defaultValue: T): AsyncIterableX<T>

- Defined in asynciterable/defaultifempty.ts:25
Returns the elements of the specified sequence or the type parameter's default value in a singleton collection if the sequence is empty.

Type parameters
- T
Parameters
- source: AsyncIterable<T>
 
 The sequence to return a default value for if it is empty.
- defaultValue: T
 
 The default value if the sequence is empty.
Returns AsyncIterableX<T>

An that contains the default value if source is empty; otherwise, source.

defaultIfEmptyProto

defaultIfEmptyProto<T>(this: IterableX<T>, defaultValue: T): IterableX<T>

- Defined in add/iterable-operators/defaultifempty.ts:7
ignore

Type parameters
- T
Parameters
- this: IterableX<T>
- defaultValue: T
Returns IterableX<T>

defer

defer<TSource>(factory: function): AsyncIterableX<TSource>

- Defined in asynciterable/defer.ts:19
Creates an enumerable sequence based on an iterable factory function.

Type parameters
- TSource
Parameters
- factory: function
 
 Iterable factory function.
 - - (): AsyncIterable<TSource> | Promise<AsyncIterable<TSource>>
 - Returns AsyncIterable<TSource> | Promise<AsyncIterable<TSource>>
Returns AsyncIterableX<TSource>

Sequence that will invoke the iterable factory upon a call to Symbol.iterator.

delay

delay<TSource>(source: AsyncIterable<TSource>, dueTime: number): AsyncIterableX<TSource>

- Defined in asynciterable/delay.ts:22
Type parameters
- TSource
Parameters
- source: AsyncIterable<TSource>
- dueTime: number
Returns AsyncIterableX<TSource>

delayEach

delayEach<TSource>(source: AsyncIterable<TSource>, dueTime: number): AsyncIterableX<TSource>

- Defined in asynciterable/delayeach.ts:22
Type parameters
- TSource
Parameters
- source: AsyncIterable<TSource>
- dueTime: number
Returns AsyncIterableX<TSource>

distinct

distinct<TSource, TKey>(source: AsyncIterable<TSource>, keySelector?: function, comparer?: function): AsyncIterableX<TSource>

- Defined in asynciterable/distinct.ts:35
Returns elements with a distinct key value by using the specified comparer to compare key values.

Type parameters
- TSource
- TKey
Parameters
- source: AsyncIterable<TSource>
 
 Source sequence.
- Default value keySelector: function = identityAsync
 - - (value: TSource): TKey | Promise<TKey>
 - Parameters
 - value: TSource
 Returns TKey | Promise<TKey>
- Default value comparer: function = comparerAsync
 - - (x: TKey, y: TKey): boolean | Promise<boolean>
 - Parameters
 - x: TKey
 - y: TKey
 Returns boolean | Promise<boolean>
Returns AsyncIterableX<TSource>

Sequence that contains the elements from the source sequence with distinct key values.

distinctProto

distinctProto<TSource, TKey>(this: IterableX<TSource>, keySelector?: undefined | function, comparer?: undefined | function): IterableX<TSource>

- Defined in add/iterable-operators/distinct.ts:7
ignore

Type parameters
- TSource
- TKey
Parameters
- this: IterableX<TSource>
- Optional keySelector: undefined | function
- Optional comparer: undefined | function
Returns IterableX<TSource>

distinctUntilChanged

distinctUntilChanged<TSource, TKey>(source: AsyncIterable<TSource>, keySelector?: function, comparer?: function): AsyncIterableX<TSource>

- Defined in asynciterable/distinctuntilchanged.ts:39
Returns consecutive distinct elements based on a key value by using the specified equality comparer to compare key values.

Type parameters
- TSource
- TKey
Parameters
- source: AsyncIterable<TSource>
 
 Source sequence.
- Default value keySelector: function = identityAsync
 - - (value: TSource): TKey | Promise<TKey>
 - Parameters
 - value: TSource
 Returns TKey | Promise<TKey>
- Default value comparer: function = comparerAsync
 - - (first: TKey, second: TKey): boolean | Promise<boolean>
 - Parameters
 - first: TKey
 - second: TKey
 Returns boolean | Promise<boolean>
Returns AsyncIterableX<TSource>

Sequence without adjacent non-distinct elements.

distinctUntilChangedProto

distinctUntilChangedProto<TSource, TKey>(this: IterableX<TSource>, keySelector?: undefined | function, cmp?: undefined | function): IterableX<TSource>

- Defined in add/iterable-operators/distinctuntilchanged.ts:7
ignore

Type parameters
- TSource
- TKey
Parameters
- this: IterableX<TSource>
- Optional keySelector: undefined | function
- Optional cmp: undefined | function
Returns IterableX<TSource>

doWhile

doWhile<TSource>(source: AsyncIterable<TSource>, condition: function): AsyncIterableX<TSource>

- Defined in asynciterable/dowhile.ts:5
Generates an iterable sequence by repeating a source sequence as long as the given loop postcondition holds.

Type parameters
- TSource
Parameters
- source: AsyncIterable<TSource>
 
 Source sequence to repeat while the condition evaluates true.
- condition: function
 
 Loop condition.
 - - (): boolean | Promise<boolean>
 - Returns boolean | Promise<boolean>
Returns AsyncIterableX<TSource>

Sequence generated by repeating the given sequence until the condition evaluates to false.

doWhileProto

doWhileProto<TSource>(this: IterableX<TSource>, condition: function): IterableX<TSource>

- Defined in add/iterable-operators/dowhile.ts:7
ignore

Type parameters
- TSource
Parameters
- this: IterableX<TSource>
- condition: function
 - - (): boolean
 - Returns boolean
Returns IterableX<TSource>

elementAt

elementAt<T>(source: AsyncIterable<T>, index: number): Promise<T | undefined>

- Defined in asynciterable/elementat.ts:1
Returns the element at a specified index in a sequence or undefined if the index is out of range.

Type parameters
- T
Parameters
- source: AsyncIterable<T>
 
 The source sequence.
- index: number
 
 The zero-based index of the element to retrieve.
Returns Promise<T | undefined>

undefined if the index is outside the bounds of the source sequence; otherwise, the element at the specified position in the source sequence.

elementAtProto

elementAtProto<T>(this: IterableX<T>, index: number): undefined | T

- Defined in add/iterable-operators/elementat.ts:7
ignore

Type parameters
- T
Parameters
- this: IterableX<T>
- index: number
Returns undefined | T

empty

empty<TSource>(): AsyncIterableX<TSource>

- Defined in asynciterable/empty.ts:9
Returns an empty iterable.

Type parameters
- TSource
Returns AsyncIterableX<TSource>

The empty iterable.

endWith

endWith<TSource>(source: AsyncIterable<TSource>, ...args: TSource[]): AsyncIterableX<TSource>

- Defined in asynciterable/endwith.ts:23
Type parameters
- TSource
Parameters
- source: AsyncIterable<TSource>
- Rest ...args: TSource[]
Returns AsyncIterableX<TSource>

endWithProto

endWithProto<T>(this: IterableX<T>, ...args: T[]): IterableX<T>

- Defined in add/iterable-operators/endwith.ts:7
ignore

Type parameters
- T
Parameters
- this: IterableX<T>
- Rest ...args: T[]
Returns IterableX<T>

every

every<T, S>(source: AsyncIterable<T>, predicate: function): Promise<boolean>
every<T>(source: AsyncIterable<T>, predicate: function): Promise<boolean>
every<T, S>(source: Iterable<T>, predicate: function): boolean
every<T>(source: Iterable<T>, predicate: function): boolean

- Defined in asynciterable/every.ts:1
Type parameters
- T
- S: T
Parameters
- source: AsyncIterable<T>
- predicate: function
 - - (value: T, index: number): boolean
 - Parameters
 - value: T
 - index: number
 Returns boolean
Returns Promise<boolean>
- Defined in asynciterable/every.ts:5
Type parameters
- T
Parameters
- source: AsyncIterable<T>
- predicate: function
 - - (value: T, index: number): boolean | Promise<boolean>
 - Parameters
 - value: T
 - index: number
 Returns boolean | Promise<boolean>
Returns Promise<boolean>
- Defined in iterable/every.ts:8
Determines whether every element of a sequence satisfy a condition.

Type parameters
- T
- S: T
Parameters
- source: Iterable<T>
 
 Source sequence.
- predicate: function
 
 A function to test each element for a condition.
 - - (value: T, index: number): boolean
 - Parameters
 - value: T
 - index: number
 Returns boolean
Returns boolean

true if every element of the source sequence passes the test in the specified predicate, or if the sequence is empty; otherwise, false.
- Defined in iterable/every.ts:12
Type parameters
- T
Parameters
- source: Iterable<T>
- predicate: function
 - - (value: T, index: number): boolean
 - Parameters
 - value: T
 - index: number
 Returns boolean
Returns boolean

everyProto

everyProto<T, S>(this: IterableX<T>, predicate: function): boolean
everyProto<T>(this: IterableX<T>, predicate: function): boolean
everyProto<T, S>(this: AsyncIterableX<T>, predicate: function): Promise<boolean>
everyProto<T>(this: AsyncIterableX<T>, predicate: function): Promise<boolean>

- Defined in add/iterable-operators/every.ts:7
ignore

Type parameters
- T
- S: T
Parameters
- this: IterableX<T>
- predicate: function
 - - (value: T, index: number): boolean
 - Parameters
 - value: T
 - index: number
 Returns boolean
Returns boolean
- Defined in add/iterable-operators/every.ts:11
Type parameters
- T
Parameters
- this: IterableX<T>
- predicate: function
 - - (value: T, index: number): boolean
 - Parameters
 - value: T
 - index: number
 Returns boolean
Returns boolean
- Defined in add/asynciterable-operators/every.ts:7
ignore

Type parameters
- T
- S: T
Parameters
- this: AsyncIterableX<T>
- predicate: function
 - - (value: T, index: number): boolean
 - Parameters
 - value: T
 - index: number
 Returns boolean
Returns Promise<boolean>
- Defined in add/asynciterable-operators/every.ts:11
Type parameters
- T
Parameters
- this: AsyncIterableX<T>
- predicate: function
 - - (value: T, index: number): boolean | Promise<boolean>
 - Parameters
 - value: T
 - index: number
 Returns boolean | Promise<boolean>
Returns Promise<boolean>

except

except<TSource>(first: AsyncIterable<TSource>, second: AsyncIterable<TSource>, comparer?: function): AsyncIterableX<TSource>

- Defined in asynciterable/except.ts:36
Produces the set difference of two sequences by using the an equality comparer to compare values.

Type parameters
- TSource
Parameters
- first: AsyncIterable<TSource>
 
 A sequence whose elements that are not also in second will be returned.
- second: AsyncIterable<TSource>
 
 A sequence whose elements that also occur in the first sequence will cause those elements to be removed from the returned sequence.
- Default value comparer: function = comparerAsync
 - - (x: TSource, y: TSource): boolean | Promise<boolean>
 - Parameters
 - x: TSource
 - y: TSource
 Returns boolean | Promise<boolean>
Returns AsyncIterableX<TSource>

A sequence that contains the set difference of the elements of two sequences.

exceptProto

exceptProto<TSource>(this: IterableX<TSource>, second: Iterable<TSource>, comparer?: undefined | function): IterableX<TSource>

- Defined in add/iterable-operators/except.ts:7
ignore

Type parameters
- TSource
Parameters
- this: IterableX<TSource>
- second: Iterable<TSource>
- Optional comparer: undefined | function
Returns IterableX<TSource>

expand

expand<TSource>(source: AsyncIterable<TSource>, selector: function): AsyncIterableX<TSource>

- Defined in asynciterable/expand.ts:29
Expands the sequence by recursively applying a selector function.

Type parameters
- TSource
Parameters
- source: AsyncIterable<TSource>
 
 Source sequence.
- selector: function
 
 Selector function to retrieve the next sequence to expand
 - - (value: TSource): AsyncIterable<TSource> | Promise<AsyncIterable<TSource>>
 - Parameters
 - value: TSource
 Returns AsyncIterable<TSource> | Promise<AsyncIterable<TSource>>
Returns AsyncIterableX<TSource>

Sequence with results from the recursive expansion of the source sequence.

expandProto

expandProto<TSource>(this: IterableX<TSource>, fn: function): IterableX<TSource>

- Defined in add/iterable-operators/expand.ts:7
ignore

Type parameters
- TSource
Parameters
- this: IterableX<TSource>
- fn: function
 - - (value: TSource): Iterable<TSource>
 - Parameters
 - value: TSource
 Returns Iterable<TSource>
Returns IterableX<TSource>

extremaBy

extremaBy<TSource, TKey>(source: AsyncIterable<TSource>, keyFn: function, cmp: function): AsyncIterableX<TSource>

- Defined in asynciterable/_extremaby.ts:62
ignore

Type parameters
- TSource
- TKey
Parameters
- source: AsyncIterable<TSource>
- keyFn: function
 - - (x: TSource): TKey | Promise<TKey>
 - Parameters
 - x: TSource
 Returns TKey | Promise<TKey>
- cmp: function
 - - (x: TKey, y: TKey): number | Promise<number>
 - Parameters
 - x: TKey
 - y: TKey
 Returns number | Promise<number>
Returns AsyncIterableX<TSource>

filter

filter<T, S>(source: Iterable<T | PromiseLike<T>> | AsyncIterable<T>, predicate: function, thisArg?: any): AsyncIterableX<S>
filter<T>(source: Iterable<T | PromiseLike<T>> | AsyncIterable<T>, predicate: function, thisArg?: any): AsyncIterableX<T>
filter<T, S>(source: Iterable<T>, predicate: function, thisArg?: any): IterableX<S>
filter<T>(source: Iterable<T>, predicate: function, thisArg?: any): IterableX<T>
filter<T, S>(predicate: function, thisArg?: any): OperatorFunction<T, S>
filter<T>(predicate: function, thisArg?: any): OperatorFunction<T, T>
filter<T, S>(predicate: function, thisArg?: any): OperatorAsyncFunction<T, S>
filter<T>(predicate: function, thisArg?: any): OperatorAsyncFunction<T, T>

- Defined in asynciterable/filter.ts:27
Type parameters
- T
- S: T
Parameters
- source: Iterable<T | PromiseLike<T>> | AsyncIterable<T>
- predicate: function
 - - (value: T, index: number): boolean
 - Parameters
 - value: T
 - index: number
 Returns boolean
- Optional thisArg: any
Returns AsyncIterableX<S>
- Defined in asynciterable/filter.ts:32
Type parameters
- T
Parameters
- source: Iterable<T | PromiseLike<T>> | AsyncIterable<T>
- predicate: function
 - - (value: T, index: number): boolean | Promise<boolean>
 - Parameters
 - value: T
 - index: number
 Returns boolean | Promise<boolean>
- Optional thisArg: any
Returns AsyncIterableX<T>
- Defined in iterable/filter.ts:31
Filters a sequence of values based on a predicate.

Type parameters
- T
- S: T
Parameters
- source: Iterable<T>
 
 Source sequence.
- predicate: function
 
 A function to test each source element for a condition.
 - - (value: T, index: number): boolean
 - Parameters
 - value: T
 - index: number
 Returns boolean
- Optional thisArg: any
Returns IterableX<S>

Sequence that contains elements from the input sequence that satisfy the condition.
- Defined in iterable/filter.ts:36
Type parameters
- T
Parameters
- source: Iterable<T>
- predicate: function
 - - (value: T, index: number): boolean
 - Parameters
 - value: T
 - index: number
 Returns boolean
- Optional thisArg: any
Returns IterableX<T>
- Defined in iterable/pipe/filter.ts:6
Type parameters
- T
- S: T
Parameters
- predicate: function
 - - (value: T, index: number): boolean
 - Parameters
 - value: T
 - index: number
 Returns boolean
- Optional thisArg: any
Returns OperatorFunction<T, S>
- Defined in iterable/pipe/filter.ts:10
Type parameters
- T
Parameters
- predicate: function
 - - (value: T, index: number): boolean
 - Parameters
 - value: T
 - index: number
 Returns boolean
- Optional thisArg: any
Returns OperatorFunction<T, T>
- Defined in asynciterable/pipe/filter.ts:6
Type parameters
- T
- S: T
Parameters
- predicate: function
 - - (value: T, index: number): boolean
 - Parameters
 - value: T
 - index: number
 Returns boolean
- Optional thisArg: any
Returns OperatorAsyncFunction<T, S>
- Defined in asynciterable/pipe/filter.ts:10
Type parameters
- T
Parameters
- predicate: function
 - - (value: T, index: number): boolean | Promise<boolean>
 - Parameters
 - value: T
 - index: number
 Returns boolean | Promise<boolean>
- Optional thisArg: any
Returns OperatorAsyncFunction<T, T>

filterAsync

filterAsync<T, S>(source: Iterable<T | PromiseLike<T>> | AsyncIterable<T>, predicate: function, thisArg?: any): AsyncIterableX<S>
filterAsync<T>(source: Iterable<T | PromiseLike<T>> | AsyncIterable<T>, predicate: function, thisArg?: any): AsyncIterableX<T>

- Defined in iterable/filterasync.ts:34
Filters a sequence of values based on a predicate.

Type parameters
- T
- S: T
Parameters
- source: Iterable<T | PromiseLike<T>> | AsyncIterable<T>
 
 Source sequence.
- predicate: function
 
 A function to test each source element for a condition.
 - - (value: T, index: number): boolean
 - Parameters
 - value: T
 - index: number
 Returns boolean
- Optional thisArg: any
Returns AsyncIterableX<S>

Sequence that contains elements from the input sequence that satisfy the condition.
- Defined in iterable/filterasync.ts:39
Type parameters
- T
Parameters
- source: Iterable<T | PromiseLike<T>> | AsyncIterable<T>
- predicate: function
 - - (value: T, index: number): boolean | Promise<boolean>
 - Parameters
 - value: T
 - index: number
 Returns boolean | Promise<boolean>
- Optional thisArg: any
Returns AsyncIterableX<T>

filterProto

filterProto<T, S>(this: IterableX<T>, predicate: function, thisArg?: any): IterableX<S>
filterProto<T>(this: IterableX<T>, predicate: function, thisArg?: any): IterableX<T>
filterProto<T, S>(this: AsyncIterableX<T>, predicate: function, thisArg?: any): AsyncIterableX<S>
filterProto<TSource>(this: AsyncIterableX<TSource>, predicate: function, thisArg?: any): AsyncIterableX<TSource>

- Defined in add/iterable-operators/filter.ts:7
ignore

Type parameters
- T
- S: T
Parameters
- this: IterableX<T>
- predicate: function
 - - (value: T, index: number): boolean
 - Parameters
 - value: T
 - index: number
 Returns boolean
- Optional thisArg: any
Returns IterableX<S>
- Defined in add/iterable-operators/filter.ts:12
Type parameters
- T
Parameters
- this: IterableX<T>
- predicate: function
 - - (value: T, index: number): boolean
 - Parameters
 - value: T
 - index: number
 Returns boolean
- Optional thisArg: any
Returns IterableX<T>
- Defined in add/asynciterable-operators/filter.ts:8
ignore

Type parameters
- T
- S: T
Parameters
- this: AsyncIterableX<T>
- predicate: function
 - - (value: T, index: number): boolean
 - Parameters
 - value: T
 - index: number
 Returns boolean
- Optional thisArg: any
Returns AsyncIterableX<S>
- Defined in add/asynciterable-operators/filter.ts:13
Type parameters
- TSource
Parameters
- this: AsyncIterableX<TSource>
- predicate: function
 - - (value: TSource, index: number): boolean | Promise<boolean>
 - Parameters
 - value: TSource
 - index: number
 Returns boolean | Promise<boolean>
- Optional thisArg: any
Returns AsyncIterableX<TSource>

finallyProto

finallyProto<TSource>(this: IterableX<TSource>, action: function): IterableX<TSource>

- Defined in add/iterable-operators/finally.ts:7
ignore

Type parameters
- TSource
Parameters
- this: IterableX<TSource>
- action: function
 - - (): void
 - Returns void
Returns IterableX<TSource>

find

find<T, S>(source: AsyncIterable<T>, predicate: function, thisArg?: any): Promise<S | undefined>
find<T>(source: AsyncIterable<T>, predicate: function, thisArg?: any): Promise<T | undefined>
find<T, S>(source: Iterable<T>, predicate: function, thisArg?: any): S | undefined
find<T>(source: Iterable<T>, predicate: function, thisArg?: any): T | undefined

- Defined in asynciterable/find.ts:3
Type parameters
- T
- S: T
Parameters
- source: AsyncIterable<T>
- predicate: function
 - - (value: T, index: number): boolean
 - Parameters
 - value: T
 - index: number
 Returns boolean
- Optional thisArg: any
Returns Promise<S | undefined>
- Defined in asynciterable/find.ts:8
Type parameters
- T
Parameters
- source: AsyncIterable<T>
- predicate: function
 - - (value: T, index: number): boolean | Promise<boolean>
 - Parameters
 - value: T
 - index: number
 Returns boolean | Promise<boolean>
- Optional thisArg: any
Returns Promise<T | undefined>
- Defined in iterable/find.ts:12
Returns the value of the first element in the sequence that satisfies the provided testing function. Otherwise undefined is returned.

Type parameters
- T
- S: T
Parameters
- source: Iterable<T>
 
 Source sequence.
- predicate: function
 
 Function to execute for every item in the sequence.
 - - (value: T, index: number): boolean
 - Parameters
 - value: T
 - index: number
 Returns boolean
- Optional thisArg: any
Returns S | undefined

The value of the first element in the sequence that satisfies the provided testing function. Otherwise undefined is returned.
- Defined in iterable/find.ts:17
Type parameters
- T
Parameters
- source: Iterable<T>
- predicate: function
 - - (value: T, index: number): boolean
 - Parameters
 - value: T
 - index: number
 Returns boolean
- Optional thisArg: any
Returns T | undefined

findIndex

findIndex<T>(source: AsyncIterable<T>, predicate: function, thisArg?: any): Promise<number>
findIndex<T, S>(source: Iterable<T>, predicate: function, thisArg?: any): number
findIndex<T>(source: Iterable<T>, predicate: function, thisArg?: any): number

- Defined in asynciterable/findindex.ts:3
Type parameters
- T
Parameters
- source: AsyncIterable<T>
- predicate: function
 - - (value: T, index: number): boolean | Promise<boolean>
 - Parameters
 - value: T
 - index: number
 Returns boolean | Promise<boolean>
- Optional thisArg: any
Returns Promise<number>
- Defined in iterable/findindex.ts:3
Type parameters
- T
- S: T
Parameters
- source: Iterable<T>
- predicate: function
 - - (value: T, index: number): boolean
 - Parameters
 - value: T
 - index: number
 Returns boolean
- Optional thisArg: any
Returns number
- Defined in iterable/findindex.ts:8
Type parameters
- T
Parameters
- source: Iterable<T>
- predicate: function
 - - (value: T, index: number): boolean
 - Parameters
 - value: T
 - index: number
 Returns boolean
- Optional thisArg: any
Returns number

findIndexProto

findIndexProto<T>(this: IterableX<T>, fn: function, thisArg?: any): number

- Defined in add/iterable-operators/findindex.ts:7
ignore

Type parameters
- T
Parameters
- this: IterableX<T>
- fn: function
 - - (value: T, index: number): boolean
 - Parameters
 - value: T
 - index: number
 Returns boolean
- Optional thisArg: any
Returns number

findProto

findProto<T, S>(this: IterableX<T>, predicate: function, thisArg?: any): S | undefined
findProto<T>(this: IterableX<T>, predicate: function, thisArg?: any): T | undefined
findProto<T, S>(this: AsyncIterableX<T>, predicate: function, thisArg?: any): Promise<S | undefined>
findProto<T>(this: AsyncIterableX<T>, predicate: function, thisArg?: any): Promise<T | undefined>

- Defined in add/iterable-operators/find.ts:8
ignore

Type parameters
- T
- S: T
Parameters
- this: IterableX<T>
- predicate: function
 - - (value: T, index: number): boolean
 - Parameters
 - value: T
 - index: number
 Returns boolean
- Optional thisArg: any
Returns S | undefined
- Defined in add/iterable-operators/find.ts:13
Type parameters
- T
Parameters
- this: IterableX<T>
- predicate: function
 - - (value: T, index: number): boolean
 - Parameters
 - value: T
 - index: number
 Returns boolean
- Optional thisArg: any
Returns T | undefined
- Defined in add/asynciterable-operators/find.ts:8
ignore

Type parameters
- T
- S: T
Parameters
- this: AsyncIterableX<T>
- predicate: function
 - - (value: T, index: number): boolean
 - Parameters
 - value: T
 - index: number
 Returns boolean
- Optional thisArg: any
Returns Promise<S | undefined>
- Defined in add/asynciterable-operators/find.ts:13
Type parameters
- T
Parameters
- this: AsyncIterableX<T>
- predicate: function
 - - (value: T, index: number): boolean | Promise<boolean>
 - Parameters
 - value: T
 - index: number
 Returns boolean | Promise<boolean>
- Optional thisArg: any
Returns Promise<T | undefined>

first

first<T, S>(source: AsyncIterable<T>, predicate: function): Promise<S | undefined>
first<T>(source: AsyncIterable<T>, predicate?: undefined | function): Promise<T | undefined>
first<T, S>(source: Iterable<T>, predicate: function): S | undefined
first<T>(source: Iterable<T>, predicate?: undefined | function): T | undefined

- Defined in asynciterable/first.ts:1
Type parameters
- T
- S: T
Parameters
- source: AsyncIterable<T>
- predicate: function
 - - (value: T, index: number): boolean
 - Parameters
 - value: T
 - index: number
 Returns boolean
Returns Promise<S | undefined>
- Defined in asynciterable/first.ts:5
Type parameters
- T
Parameters
- source: AsyncIterable<T>
- Optional predicate: undefined | function
Returns Promise<T | undefined>
- Defined in iterable/first.ts:10
Returns the first element in a sequence that satisfies a specified condition if provided, else the first element in the sequence.

Type parameters
- T
- S: T
Parameters
- source: Iterable<T>
 
 Source collection
- predicate: function
 - - (value: T, index: number): boolean
 - Parameters
 - value: T
 - index: number
 Returns boolean
Returns S | undefined

The first element in the sequence that passes the test in the specified predicate function if provided, else the first element. If there are no elements, undefined is returned.
- Defined in iterable/first.ts:14
Type parameters
- T
Parameters
- source: Iterable<T>
- Optional predicate: undefined | function
Returns T | undefined

firstProto

firstProto<T, S>(this: IterableX<T>, predicate: function): S | undefined
firstProto<T>(this: IterableX<T>, predicate?: undefined | function): T | undefined
firstProto<T, S>(this: AsyncIterableX<T>, predicate: function): Promise<S | undefined>
firstProto<T>(this: AsyncIterableX<T>, predicate?: undefined | function): Promise<T | undefined>

- Defined in add/iterable-operators/first.ts:8
ignore

Type parameters
- T
- S: T
Parameters
- this: IterableX<T>
- predicate: function
 - - (value: T, index: number): boolean
 - Parameters
 - value: T
 - index: number
 Returns boolean
Returns S | undefined
- Defined in add/iterable-operators/first.ts:12
Type parameters
- T
Parameters
- this: IterableX<T>
- Optional predicate: undefined | function
Returns T | undefined
- Defined in add/asynciterable-operators/first.ts:8
ignore

Type parameters
- T
- S: T
Parameters
- this: AsyncIterableX<T>
- predicate: function
 - - (value: T, index: number): boolean
 - Parameters
 - value: T
 - index: number
 Returns boolean
Returns Promise<S | undefined>
- Defined in add/asynciterable-operators/first.ts:12
Type parameters
- T
Parameters
- this: AsyncIterableX<T>
- Optional predicate: undefined | function
Returns Promise<T | undefined>

flatMap

flatMap<TSource, TResult>(source: AsyncIterable<TSource>, selector: function, thisArg?: any): AsyncIterableX<TResult>

- Defined in asynciterable/flatmap.ts:27
Projects each element of a sequence to iterable and flattens the resulting sequences into one sequence.

Type parameters
- TSource
- TResult
Parameters
- source: AsyncIterable<TSource>
 
 Source sequence
- selector: function
 
 A transform function to apply to each element.
 - - (value: TSource): AsyncIterable<TResult> | Promise<AsyncIterable<TResult>>
 - Parameters
 - value: TSource
 Returns AsyncIterable<TResult> | Promise<AsyncIterable<TResult>>
- Optional thisArg: any
Returns AsyncIterableX<TResult>

An iterable whose elements are the result of invoking the one-to-many transform function on each element of the input sequence.

flatMapAsync

flatMapAsync<TSource, TResult>(source: Iterable<TSource | PromiseLike<TSource>> | AsyncIterable<TSource>, selector: function, thisArg?: any): AsyncIterableX<TResult>

- Defined in iterable/flatmapasync.ts:37
Projects each element of a sequence to a potentially async iterable and flattens the resulting sequences into one sequence.

Type parameters
- TSource
- TResult
Parameters
- source: Iterable<TSource | PromiseLike<TSource>> | AsyncIterable<TSource>
 
 Source sequence
- selector: function
 
 A transform function to apply to each element.
 - - (value: TSource): Iterable<TResult | PromiseLike<TResult>> | AsyncIterable<TResult>
 - Parameters
 - value: TSource
 Returns Iterable<TResult | PromiseLike<TResult>> | AsyncIterable<TResult>
- Optional thisArg: any
Returns AsyncIterableX<TResult>

An async iterable whose elements are the result of invoking the one-to-many transform function on each element of the input sequence.

flatMapProto

flatMapProto<TSource, TResult>(this: IterableX<TSource>, fn: function, thisArg?: any): IterableX<TResult>

- Defined in add/iterable-operators/flatmap.ts:7
ignore

Type parameters
- TSource
- TResult
Parameters
- this: IterableX<TSource>
- fn: function
 - - (value: TSource): Iterable<TResult>
 - Parameters
 - value: TSource
 Returns Iterable<TResult>
- Optional thisArg: any
Returns IterableX<TResult>

flatten

flatten<T>(source: AsyncIterable<T>, depth?: number): AsyncIterableX<T>

- Defined in asynciterable/flatten.ts:37
Flattens the source sequence until the specified depth.

Type parameters
- T
Parameters
- source: AsyncIterable<T>
 
 Source sequence.
- Default value depth: number = Infinity
 
 The depth to flatten the source sequence.
Returns AsyncIterableX<T>

The flattened sequence, flattened to the specified depth.

flattenProto

flattenProto<T>(this: IterableX<T>, depth?: undefined | number): IterableX<T>

- Defined in add/iterable-operators/flatten.ts:7
ignore

Type parameters
- T
Parameters
- this: IterableX<T>
- Optional depth: undefined | number
Returns IterableX<T>

forEach

forEach<T>(source: AsyncIterable<T>, fn: function): Promise<void>

- Defined in asynciterable/debounce.ts:3
Type parameters
- T
Parameters
- source: AsyncIterable<T>
- fn: function
 - - (item: T): void | Promise<void>
 - Parameters
 - item: T
 Returns void | Promise<void>
Returns Promise<void>

forkJoin

forkJoin<T, T2>(source: AsyncIterable<T>, source2: AsyncIterable<T2>): Promise<[T, T2] | undefined>
forkJoin<T, T2, T3>(source: AsyncIterable<T>, source2: AsyncIterable<T2>, source3: AsyncIterable<T3>): Promise<[T, T2, T3] | undefined>
forkJoin<T, T2, T3, T4>(source: AsyncIterable<T>, source2: AsyncIterable<T2>, source3: AsyncIterable<T3>, source4: AsyncIterable<T4>): Promise<[T, T2, T3, T4] | undefined>
forkJoin<T, T2, T3, T4, T5>(source: AsyncIterable<T>, source2: AsyncIterable<T2>, source3: AsyncIterable<T3>, source4: AsyncIterable<T4>, source5: AsyncIterable<T5>): Promise<[T, T2, T3, T4, T5] | undefined>
forkJoin<T, T2, T3, T4, T5, T6>(source: AsyncIterable<T>, source2: AsyncIterable<T2>, source3: AsyncIterable<T3>, source4: AsyncIterable<T4>, source5: AsyncIterable<T5>, source6: AsyncIterable<T6>): Promise<[T, T2, T3, T4, T5, T6] | undefined>
forkJoin<T, R>(project: function, source: AsyncIterable<T>): Promise<R | undefined>
forkJoin<T, T2, R>(project: function, source: AsyncIterable<T>, source2: AsyncIterable<T2>): Promise<R | undefined>
forkJoin<T, T2, T3, R>(project: function, source: AsyncIterable<T>, source2: AsyncIterable<T2>, source3: AsyncIterable<T3>): Promise<R | undefined>
forkJoin<T, T2, T3, T4, R>(project: function, source: AsyncIterable<T>, source2: AsyncIterable<T2>, source3: AsyncIterable<T3>, source4: AsyncIterable<T4>): Promise<R | undefined>
forkJoin<T, T2, T3, T4, T5, R>(project: function, source: AsyncIterable<T>, source2: AsyncIterable<T2>, source3: AsyncIterable<T3>, source4: AsyncIterable<T4>, source5: AsyncIterable<T5>): Promise<R | undefined>
forkJoin<T, T2, T3, T4, T5, T6, R>(project: function, source: AsyncIterable<T>, source2: AsyncIterable<T2>, source3: AsyncIterable<T3>, source4: AsyncIterable<T4>, source5: AsyncIterable<T5>, source6: AsyncIterable<T6>): Promise<R | undefined>
forkJoin<T>(...sources: AsyncIterable<T>[]): Promise<T[] | undefined>
forkJoin<T, R>(project: function, ...sources: AsyncIterable<T>[]): Promise<R | undefined>

- Defined in asynciterable/forkjoin.ts:12
Type parameters
- T
- T2
Parameters
- source: AsyncIterable<T>
- source2: AsyncIterable<T2>
Returns Promise<[T, T2] | undefined>
- Defined in asynciterable/forkjoin.ts:16
Type parameters
- T
- T2
- T3
Parameters
- source: AsyncIterable<T>
- source2: AsyncIterable<T2>
- source3: AsyncIterable<T3>
Returns Promise<[T, T2, T3] | undefined>
- Defined in asynciterable/forkjoin.ts:21
Type parameters
- T
- T2
- T3
- T4
Parameters
- source: AsyncIterable<T>
- source2: AsyncIterable<T2>
- source3: AsyncIterable<T3>
- source4: AsyncIterable<T4>
Returns Promise<[T, T2, T3, T4] | undefined>
- Defined in asynciterable/forkjoin.ts:27
Type parameters
- T
- T2
- T3
- T4
- T5
Parameters
- source: AsyncIterable<T>
- source2: AsyncIterable<T2>
- source3: AsyncIterable<T3>
- source4: AsyncIterable<T4>
- source5: AsyncIterable<T5>
Returns Promise<[T, T2, T3, T4, T5] | undefined>
- Defined in asynciterable/forkjoin.ts:34
Type parameters
- T
- T2
- T3
- T4
- T5
- T6
Parameters
- source: AsyncIterable<T>
- source2: AsyncIterable<T2>
- source3: AsyncIterable<T3>
- source4: AsyncIterable<T4>
- source5: AsyncIterable<T5>
- source6: AsyncIterable<T6>
Returns Promise<[T, T2, T3, T4, T5, T6] | undefined>
- Defined in asynciterable/forkjoin.ts:43
Type parameters
- T
- R
Parameters
- project: function
 - - (values: [T]): R | Promise<R>
 - Parameters
 - values: [T]
 Returns R | Promise<R>
- source: AsyncIterable<T>
Returns Promise<R | undefined>
- Defined in asynciterable/forkjoin.ts:47
Type parameters
- T
- T2
- R
Parameters
- project: function
 - - (values: [T, T2]): R | Promise<R>
 - Parameters
 - values: [T, T2]
 Returns R | Promise<R>
- source: AsyncIterable<T>
- source2: AsyncIterable<T2>
Returns Promise<R | undefined>
- Defined in asynciterable/forkjoin.ts:52
Type parameters
- T
- T2
- T3
- R
Parameters
- project: function
 - - (values: [T, T2, T3]): R | Promise<R>
 - Parameters
 - values: [T, T2, T3]
 Returns R | Promise<R>
- source: AsyncIterable<T>
- source2: AsyncIterable<T2>
- source3: AsyncIterable<T3>
Returns Promise<R | undefined>
- Defined in asynciterable/forkjoin.ts:58
Type parameters
- T
- T2
- T3
- T4
- R
Parameters
- project: function
 - - (values: [T, T2, T3, T4]): R | Promise<R>
 - Parameters
 - values: [T, T2, T3, T4]
 Returns R | Promise<R>
- source: AsyncIterable<T>
- source2: AsyncIterable<T2>
- source3: AsyncIterable<T3>
- source4: AsyncIterable<T4>
Returns Promise<R | undefined>
- Defined in asynciterable/forkjoin.ts:65
Type parameters
- T
- T2
- T3
- T4
- T5
- R
Parameters
- project: function
 - - (values: [T, T2, T3, T4, T5]): R | Promise<R>
 - Parameters
 - values: [T, T2, T3, T4, T5]
 Returns R | Promise<R>
- source: AsyncIterable<T>
- source2: AsyncIterable<T2>
- source3: AsyncIterable<T3>
- source4: AsyncIterable<T4>
- source5: AsyncIterable<T5>
Returns Promise<R | undefined>
- Defined in asynciterable/forkjoin.ts:73
Type parameters
- T
- T2
- T3
- T4
- T5
- T6
- R
Parameters
- project: function
 - - (values: [T, T2, T3, T4, T5, T6]): R | Promise<R>
 - Parameters
 - values: [T, T2, T3, T4, T5, T6]
 Returns R | Promise<R>
- source: AsyncIterable<T>
- source2: AsyncIterable<T2>
- source3: AsyncIterable<T3>
- source4: AsyncIterable<T4>
- source5: AsyncIterable<T5>
- source6: AsyncIterable<T6>
Returns Promise<R | undefined>
- Defined in asynciterable/forkjoin.ts:83
Type parameters
- T
Parameters
- Rest ...sources: AsyncIterable<T>[]
Returns Promise<T[] | undefined>
- Defined in asynciterable/forkjoin.ts:84
Type parameters
- T
- R
Parameters
- project: function
 - - (values: T[]): R | Promise<R>
 - Parameters
 - values: T[]
 Returns R | Promise<R>
- Rest ...sources: AsyncIterable<T>[]
Returns Promise<R | undefined>

forkJoinProto

forkJoinProto<T, T2>(this: AsyncIterableX<T>, source2: AsyncIterable<T2>): Promise<[T, T2] | undefined>
forkJoinProto<T, T2, T3>(this: AsyncIterableX<T>, source2: AsyncIterable<T2>, source3: AsyncIterable<T3>): Promise<[T, T2, T3] | undefined>
forkJoinProto<T, T2, T3, T4>(this: AsyncIterableX<T>, source2: AsyncIterable<T2>, source3: AsyncIterable<T3>, source4: AsyncIterable<T4>): Promise<[T, T2, T3, T4] | undefined>
forkJoinProto<T, T2, T3, T4, T5>(this: AsyncIterableX<T>, source2: AsyncIterable<T2>, source3: AsyncIterable<T3>, source4: AsyncIterable<T4>, source5: AsyncIterable<T5>): Promise<[T, T2, T3, T4, T5] | undefined>
forkJoinProto<T, T2, T3, T4, T5, T6>(this: AsyncIterableX<T>, source2: AsyncIterable<T2>, source3: AsyncIterable<T3>, source4: AsyncIterable<T4>, source5: AsyncIterable<T5>, source6: AsyncIterable<T6>): Promise<[T, T2, T3, T4, T5, T6] | undefined>
forkJoinProto<T, R>(this: AsyncIterableX<T>, project: function): Promise<R>
forkJoinProto<T, T2, R>(this: AsyncIterableX<T>, project: function, source2: AsyncIterable<T2>): Promise<R | undefined>
forkJoinProto<T, T2, T3, R>(this: AsyncIterableX<T>, project: function, source2: AsyncIterable<T2>, source3: AsyncIterable<T3>): Promise<R | undefined>
forkJoinProto<T, T2, T3, T4, R>(this: AsyncIterableX<T>, project: function, source2: AsyncIterable<T2>, source3: AsyncIterable<T3>, source4: AsyncIterable<T4>): Promise<R | undefined>
forkJoinProto<T, T2, T3, T4, T5, R>(this: AsyncIterableX<T>, project: function, source2: AsyncIterable<T2>, source3: AsyncIterable<T3>, source4: AsyncIterable<T4>, source5: AsyncIterable<T5>): Promise<R | undefined>
forkJoinProto<T, T2, T3, T4, T5, T6, R>(this: AsyncIterableX<T>, project: function, source2: AsyncIterable<T2>, source3: AsyncIterable<T3>, source4: AsyncIterable<T4>, source5: AsyncIterable<T5>, source6: AsyncIterable<T6>): Promise<R | undefined>
forkJoinProto<T>(this: AsyncIterableX<T>, ...sources: AsyncIterable<T>[]): Promise<T[] | undefined>
forkJoinProto<T, R>(this: AsyncIterableX<T>, project: function, ...sources: AsyncIterable<T>[]): Promise<R | undefined>

- Defined in add/asynciterable-operators/forkjoin.ts:8
ignore

Type parameters
- T
- T2
Parameters
- this: AsyncIterableX<T>
- source2: AsyncIterable<T2>
Returns Promise<[T, T2] | undefined>
- Defined in add/asynciterable-operators/forkjoin.ts:12
Type parameters
- T
- T2
- T3
Parameters
- this: AsyncIterableX<T>
- source2: AsyncIterable<T2>
- source3: AsyncIterable<T3>
Returns Promise<[T, T2, T3] | undefined>
- Defined in add/asynciterable-operators/forkjoin.ts:17
Type parameters
- T
- T2
- T3
- T4
Parameters
- this: AsyncIterableX<T>
- source2: AsyncIterable<T2>
- source3: AsyncIterable<T3>
- source4: AsyncIterable<T4>
Returns Promise<[T, T2, T3, T4] | undefined>
- Defined in add/asynciterable-operators/forkjoin.ts:23
Type parameters
- T
- T2
- T3
- T4
- T5
Parameters
- this: AsyncIterableX<T>
- source2: AsyncIterable<T2>
- source3: AsyncIterable<T3>
- source4: AsyncIterable<T4>
- source5: AsyncIterable<T5>
Returns Promise<[T, T2, T3, T4, T5] | undefined>
- Defined in add/asynciterable-operators/forkjoin.ts:30
Type parameters
- T
- T2
- T3
- T4
- T5
- T6
Parameters
- this: AsyncIterableX<T>
- source2: AsyncIterable<T2>
- source3: AsyncIterable<T3>
- source4: AsyncIterable<T4>
- source5: AsyncIterable<T5>
- source6: AsyncIterable<T6>
Returns Promise<[T, T2, T3, T4, T5, T6] | undefined>
- Defined in add/asynciterable-operators/forkjoin.ts:39
Type parameters
- T
- R
Parameters
- this: AsyncIterableX<T>
- project: function
 - - (values: [T]): R
 - Parameters
 - values: [T]
 Returns R
Returns Promise<R>
- Defined in add/asynciterable-operators/forkjoin.ts:43
Type parameters
- T
- T2
- R
Parameters
- this: AsyncIterableX<T>
- project: function
 - - (values: [T, T2]): R
 - Parameters
 - values: [T, T2]
 Returns R
- source2: AsyncIterable<T2>
Returns Promise<R | undefined>
- Defined in add/asynciterable-operators/forkjoin.ts:48
Type parameters
- T
- T2
- T3
- R
Parameters
- this: AsyncIterableX<T>
- project: function
 - - (values: [T, T2, T3]): R
 - Parameters
 - values: [T, T2, T3]
 Returns R
- source2: AsyncIterable<T2>
- source3: AsyncIterable<T3>
Returns Promise<R | undefined>
- Defined in add/asynciterable-operators/forkjoin.ts:54
Type parameters
- T
- T2
- T3
- T4
- R
Parameters
- this: AsyncIterableX<T>
- project: function
 - - (values: [T, T2, T3, T4]): R
 - Parameters
 - values: [T, T2, T3, T4]
 Returns R
- source2: AsyncIterable<T2>
- source3: AsyncIterable<T3>
- source4: AsyncIterable<T4>
Returns Promise<R | undefined>
- Defined in add/asynciterable-operators/forkjoin.ts:61
Type parameters
- T
- T2
- T3
- T4
- T5
- R
Parameters
- this: AsyncIterableX<T>
- project: function
 - - (values: [T, T2, T3, T4, T5]): R
 - Parameters
 - values: [T, T2, T3, T4, T5]
 Returns R
- source2: AsyncIterable<T2>
- source3: AsyncIterable<T3>
- source4: AsyncIterable<T4>
- source5: AsyncIterable<T5>
Returns Promise<R | undefined>
- Defined in add/asynciterable-operators/forkjoin.ts:69
Type parameters
- T
- T2
- T3
- T4
- T5
- T6
- R
Parameters
- this: AsyncIterableX<T>
- project: function
 - - (values: [T, T2, T3, T4, T5, T6]): R
 - Parameters
 - values: [T, T2, T3, T4, T5, T6]
 Returns R
- source2: AsyncIterable<T2>
- source3: AsyncIterable<T3>
- source4: AsyncIterable<T4>
- source5: AsyncIterable<T5>
- source6: AsyncIterable<T6>
Returns Promise<R | undefined>
- Defined in add/asynciterable-operators/forkjoin.ts:79
Type parameters
- T
Parameters
- this: AsyncIterableX<T>
- Rest ...sources: AsyncIterable<T>[]
Returns Promise<T[] | undefined>
- Defined in add/asynciterable-operators/forkjoin.ts:83
Type parameters
- T
- R
Parameters
- this: AsyncIterableX<T>
- project: function
 - - (values: T[]): R
 - Parameters
 - values: T[]
 Returns R
- Rest ...sources: AsyncIterable<T>[]
Returns Promise<R | undefined>

fromEvent

fromEvent<TSource>(obj: EventedTarget, type: string, options?: EventListenerOptions): AsyncIterableX<TSource>

- Defined in asynciterable/fromevent.ts:31
Type parameters
- TSource
Parameters
- obj: EventedTarget
- type: string
- Optional options: EventListenerOptions
Returns AsyncIterableX<TSource>

fromEventPattern

fromEventPattern<TSource>(addHandler: function, removeHandler: function): AsyncIterableX<TSource>

- Defined in asynciterable/fromeventpattern.ts:5
Type parameters
- TSource
Parameters
- addHandler: function
 - - (handler: function): void
 - Parameters
 - handler: function
 
 (...args: any[]): void
 
 Parameters
 
 Rest ...args: any[]
 
 Returns void
 Returns void
- removeHandler: function
 - - (handler: function): void
 - Parameters
 - handler: function
 
 (...args: any[]): void
 
 Parameters
 
 Rest ...args: any[]
 
 Returns void
 Returns void
Returns AsyncIterableX<TSource>

fromNodeStream

fromNodeStream(stream: ReadableStream, size?: undefined | number): AsyncIterableX<string | Buffer>

- Defined in asynciterable/fromnodestream.ts:94
Parameters
- stream: ReadableStream
- Optional size: undefined | number
Returns AsyncIterableX<string | Buffer>

generate

generate<TState, TResult>(initialState: TState, condition: function, iterate: function, resultSelector: function): AsyncIterableX<TResult>

- Defined in asynciterable/generate.ts:29
Type parameters
- TState
- TResult
Parameters
- initialState: TState
- condition: function
 - - (value: TState): boolean | Promise<boolean>
 - Parameters
 - value: TState
 Returns boolean | Promise<boolean>
- iterate: function
 - - (value: TState): TState | Promise<TState>
 - Parameters
 - value: TState
 Returns TState | Promise<TState>
- resultSelector: function
 - - (value: TState): TResult | Promise<TResult>
 - Parameters
 - value: TState
 Returns TResult | Promise<TResult>
Returns AsyncIterableX<TResult>

generateTime

generateTime<TState, TResult>(initialState: TState, condition: function, iterate: function, resultSelector: function, timeSelector: function): AsyncIterableX<TResult>

- Defined in asynciterable/generatetime.ts:35
Type parameters
- TState
- TResult
Parameters
- initialState: TState
- condition: function
 - - (value: TState): boolean | Promise<boolean>
 - Parameters
 - value: TState
 Returns boolean | Promise<boolean>
- iterate: function
 - - (value: TState): TState | Promise<TState>
 - Parameters
 - value: TState
 Returns TState | Promise<TState>
- resultSelector: function
 - - (value: TState): TResult | Promise<TResult>
 - Parameters
 - value: TState
 Returns TResult | Promise<TResult>
- timeSelector: function
 - - (value: TState): number | Promise<number>
 - Parameters
 - value: TState
 Returns number | Promise<number>
Returns AsyncIterableX<TResult>

groupBy

groupBy<TSource, TKey>(source: AsyncIterable<TSource>, keySelector: function): AsyncIterableX<GroupedAsyncIterable<TKey, TSource>>
groupBy<TSource, TKey, TValue>(source: AsyncIterable<TSource>, keySelector: function, elementSelector?: undefined | function): AsyncIterableX<GroupedAsyncIterable<TKey, TValue>>
groupBy<TSource, TKey, TValue, TResult>(source: AsyncIterable<TSource>, keySelector: function, elementSelector?: undefined | function, resultSelector?: undefined | function): AsyncIterableX<TResult>
groupBy<TSource, TKey>(source: Iterable<TSource>, keySelector: function): IterableX<GroupedIterable<TKey, TSource>>
groupBy<TSource, TKey, TValue>(source: Iterable<TSource>, keySelector: function, elementSelector?: undefined | function): IterableX<GroupedIterable<TKey, TValue>>
groupBy<TSource, TKey, TValue, TResult>(source: Iterable<TSource>, keySelector: function, elementSelector?: undefined | function, resultSelector?: undefined | function): IterableX<TResult>
groupBy<TSource, TKey>(keySelector: function): OperatorFunction<TSource, GroupedIterable<TKey, TSource>>
groupBy<TSource, TKey, TValue>(keySelector: function, elementSelector?: undefined | function): OperatorFunction<TSource, GroupedIterable<TKey, TValue>>
groupBy<TSource, TKey, TValue, TResult>(keySelector: function, elementSelector?: undefined | function, resultSelector?: undefined | function): OperatorFunction<TSource, TResult>
groupBy<TSource, TKey>(keySelector: function): OperatorAsyncFunction<TSource, GroupedAsyncIterable<TKey, TSource>>
groupBy<TSource, TKey, TValue>(keySelector: function, elementSelector?: undefined | function): OperatorAsyncFunction<TSource, GroupedAsyncIterable<TKey, TValue>>
groupBy<TSource, TKey, TValue, TResult>(keySelector: function, elementSelector?: undefined | function, resultSelector?: undefined | function): OperatorAsyncFunction<TSource, TResult>

- Defined in asynciterable/groupby.ts:53
Type parameters
- TSource
- TKey
Parameters
- source: AsyncIterable<TSource>
- keySelector: function
 - - (value: TSource): TKey | Promise<TKey>
 - Parameters
 - value: TSource
 Returns TKey | Promise<TKey>
Returns AsyncIterableX<GroupedAsyncIterable<TKey, TSource>>
- Defined in asynciterable/groupby.ts:57
Type parameters
- TSource
- TKey
- TValue
Parameters
- source: AsyncIterable<TSource>
- keySelector: function
 - - (value: TSource): TKey | Promise<TKey>
 - Parameters
 - value: TSource
 Returns TKey | Promise<TKey>
- Optional elementSelector: undefined | function
Returns AsyncIterableX<GroupedAsyncIterable<TKey, TValue>>
- Defined in asynciterable/groupby.ts:62
Type parameters
- TSource
- TKey
- TValue
- TResult
Parameters
- source: AsyncIterable<TSource>
- keySelector: function
 - - (value: TSource): TKey | Promise<TKey>
 - Parameters
 - value: TSource
 Returns TKey | Promise<TKey>
- Optional elementSelector: undefined | function
- Optional resultSelector: undefined | function
Returns AsyncIterableX<TResult>
- Defined in iterable/groupby.ts:51
Type parameters
- TSource
- TKey
Parameters
- source: Iterable<TSource>
- keySelector: function
 - - (value: TSource): TKey
 - Parameters
 - value: TSource
 Returns TKey
Returns IterableX<GroupedIterable<TKey, TSource>>
- Defined in iterable/groupby.ts:55
Type parameters
- TSource
- TKey
- TValue
Parameters
- source: Iterable<TSource>
- keySelector: function
 - - (value: TSource): TKey
 - Parameters
 - value: TSource
 Returns TKey
- Optional elementSelector: undefined | function
Returns IterableX<GroupedIterable<TKey, TValue>>
- Defined in iterable/groupby.ts:60
Type parameters
- TSource
- TKey
- TValue
- TResult
Parameters
- source: Iterable<TSource>
- keySelector: function
 - - (value: TSource): TKey
 - Parameters
 - value: TSource
 Returns TKey
- Optional elementSelector: undefined | function
- Optional resultSelector: undefined | function
Returns IterableX<TResult>
- Defined in iterable/pipe/groupby.ts:6
Type parameters
- TSource
- TKey
Parameters
- keySelector: function
 - - (value: TSource): TKey
 - Parameters
 - value: TSource
 Returns TKey
Returns OperatorFunction<TSource, GroupedIterable<TKey, TSource>>
- Defined in iterable/pipe/groupby.ts:9
Type parameters
- TSource
- TKey
- TValue
Parameters
- keySelector: function
 - - (value: TSource): TKey
 - Parameters
 - value: TSource
 Returns TKey
- Optional elementSelector: undefined | function
Returns OperatorFunction<TSource, GroupedIterable<TKey, TValue>>
- Defined in iterable/pipe/groupby.ts:13
Type parameters
- TSource
- TKey
- TValue
- TResult
Parameters
- keySelector: function
 - - (value: TSource): TKey
 - Parameters
 - value: TSource
 Returns TKey
- Optional elementSelector: undefined | function
- Optional resultSelector: undefined | function
Returns OperatorFunction<TSource, TResult>
- Defined in asynciterable/pipe/groupby.ts:6
Type parameters
- TSource
- TKey
Parameters
- keySelector: function
 - - (value: TSource): TKey | Promise<TKey>
 - Parameters
 - value: TSource
 Returns TKey | Promise<TKey>
Returns OperatorAsyncFunction<TSource, GroupedAsyncIterable<TKey, TSource>>
- Defined in asynciterable/pipe/groupby.ts:9
Type parameters
- TSource
- TKey
- TValue
Parameters
- keySelector: function
 - - (value: TSource): TKey | Promise<TKey>
 - Parameters
 - value: TSource
 Returns TKey | Promise<TKey>
- Optional elementSelector: undefined | function
Returns OperatorAsyncFunction<TSource, GroupedAsyncIterable<TKey, TValue>>
- Defined in asynciterable/pipe/groupby.ts:13
Type parameters
- TSource
- TKey
- TValue
- TResult
Parameters
- keySelector: function
 - - (value: TSource): TKey | Promise<TKey>
 - Parameters
 - value: TSource
 Returns TKey | Promise<TKey>
- Optional elementSelector: undefined | function
- Optional resultSelector: undefined | function
Returns OperatorAsyncFunction<TSource, TResult>

groupByProto

groupByProto<TSource, TKey>(this: IterableX<TSource>, keySelector: function): IterableX<GroupedIterable<TKey, TSource>>
groupByProto<TSource, TKey, TValue>(this: IterableX<TSource>, keySelector: function, elementSelector?: undefined | function): IterableX<GroupedIterable<TKey, TValue>>
groupByProto<TSource, TKey, TValue, TResult>(this: IterableX<TSource>, keySelector: function, elementSelector?: undefined | function, resultSelector?: undefined | function): IterableX<TResult>
groupByProto<TSource, TKey>(this: AsyncIterableX<TSource>, keySelector: function): AsyncIterableX<GroupedAsyncIterable<TKey, TSource>>
groupByProto<TSource, TKey, TValue>(this: AsyncIterableX<TSource>, keySelector: function, elementSelector?: undefined | function): AsyncIterableX<GroupedAsyncIterable<TKey, TValue>>
groupByProto<TSource, TKey, TValue, TResult>(this: AsyncIterableX<TSource>, keySelector: function, elementSelector?: undefined | function, resultSelector?: undefined | function): AsyncIterableX<TResult>

- Defined in add/iterable-operators/groupby.ts:5
Type parameters
- TSource
- TKey
Parameters
- this: IterableX<TSource>
- keySelector: function
 - - (value: TSource): TKey
 - Parameters
 - value: TSource
 Returns TKey
Returns IterableX<GroupedIterable<TKey, TSource>>
- Defined in add/iterable-operators/groupby.ts:9
Type parameters
- TSource
- TKey
- TValue
Parameters
- this: IterableX<TSource>
- keySelector: function
 - - (value: TSource): TKey
 - Parameters
 - value: TSource
 Returns TKey
- Optional elementSelector: undefined | function
Returns IterableX<GroupedIterable<TKey, TValue>>
- Defined in add/iterable-operators/groupby.ts:14
Type parameters
- TSource
- TKey
- TValue
- TResult
Parameters
- this: IterableX<TSource>
- keySelector: function
 - - (value: TSource): TKey | Promise<TKey>
 - Parameters
 - value: TSource
 Returns TKey | Promise<TKey>
- Optional elementSelector: undefined | function
- Optional resultSelector: undefined | function
Returns IterableX<TResult>
- Defined in add/asynciterable-operators/groupby.ts:9
Type parameters
- TSource
- TKey
Parameters
- this: AsyncIterableX<TSource>
- keySelector: function
 - - (value: TSource): TKey | Promise<TKey>
 - Parameters
 - value: TSource
 Returns TKey | Promise<TKey>
Returns AsyncIterableX<GroupedAsyncIterable<TKey, TSource>>
- Defined in add/asynciterable-operators/groupby.ts:13
Type parameters
- TSource
- TKey
- TValue
Parameters
- this: AsyncIterableX<TSource>
- keySelector: function
 - - (value: TSource): TKey | Promise<TKey>
 - Parameters
 - value: TSource
 Returns TKey | Promise<TKey>
- Optional elementSelector: undefined | function
Returns AsyncIterableX<GroupedAsyncIterable<TKey, TValue>>
- Defined in add/asynciterable-operators/groupby.ts:18
Type parameters
- TSource
- TKey
- TValue
- TResult
Parameters
- this: AsyncIterableX<TSource>
- keySelector: function
 - - (value: TSource): TKey | Promise<TKey>
 - Parameters
 - value: TSource
 Returns TKey | Promise<TKey>
- Optional elementSelector: undefined | function
- Optional resultSelector: undefined | function
Returns AsyncIterableX<TResult>

groupByResultIdentity

groupByResultIdentity<TKey, TValue>(key: TKey, values: Iterable<TValue>): any

- Defined in iterable/groupby.ts:47
Type parameters
- TKey
- TValue
Parameters
- key: TKey
- values: Iterable<TValue>
Returns any

groupByResultIdentityAsync

groupByResultIdentityAsync<TKey, TValue>(key: TKey, values: Iterable<TValue>): any

- Defined in asynciterable/groupby.ts:49
Type parameters
- TKey
- TValue
Parameters
- key: TKey
- values: Iterable<TValue>
Returns any

groupJoin

groupJoin<TOuter, TInner, TKey, TResult>(outer: AsyncIterable<TOuter>, inner: AsyncIterable<TInner>, outerSelector: function, innerSelector: function, resultSelector: function): AsyncIterableX<TResult>

- Defined in asynciterable/groupjoin.ts:43
Type parameters
- TOuter
- TInner
- TKey
- TResult
Parameters
- outer: AsyncIterable<TOuter>
- inner: AsyncIterable<TInner>
- outerSelector: function
 - - (value: TOuter): TKey | Promise<TKey>
 - Parameters
 - value: TOuter
 Returns TKey | Promise<TKey>
- innerSelector: function
 - - (value: TInner): TKey | Promise<TKey>
 - Parameters
 - value: TInner
 Returns TKey | Promise<TKey>
- resultSelector: function
 - - (outer: TOuter, inner: AsyncIterable<TInner>): TResult | Promise<TResult>
 - Parameters
 - outer: TOuter
 - inner: AsyncIterable<TInner>
 Returns TResult | Promise<TResult>
Returns AsyncIterableX<TResult>

groupJoinProto

groupJoinProto<TOuter, TInner, TKey, TResult>(this: IterableX<TOuter>, inner: Iterable<TInner>, outerSelector: function, innerSelector: function, resultSelector: function): IterableX<TResult>

- Defined in add/iterable-operators/groupjoin.ts:7
ignore

Type parameters
- TOuter
- TInner
- TKey
- TResult
Parameters
- this: IterableX<TOuter>
- inner: Iterable<TInner>
- outerSelector: function
 - - (value: TOuter): TKey
 - Parameters
 - value: TOuter
 Returns TKey
- innerSelector: function
 - - (value: TInner): TKey
 - Parameters
 - value: TInner
 Returns TKey
- resultSelector: function
 - - (outer: TOuter, inner: Iterable<TInner>): TResult
 - Parameters
 - outer: TOuter
 - inner: Iterable<TInner>
 Returns TResult
Returns IterableX<TResult>

identity

identity(x: any): any

- Defined in internal/identity.ts:4
ignore

Parameters
- x: any
Returns any

identityAsync

identityAsync(x: any): Promise<any>

- Defined in internal/identity.ts:11
ignore

Parameters
- x: any
Returns Promise<any>

ignoreElements

ignoreElements<TSource>(source: AsyncIterable<TSource>): AsyncIterableX<TSource>

- Defined in asynciterable/ignoreelements.ts:18
Type parameters
- TSource
Parameters
- source: AsyncIterable<TSource>
Returns AsyncIterableX<TSource>

ignoreElementsProto

ignoreElementsProto<T>(this: IterableX<T>): IterableX<T>

- Defined in add/iterable-operators/ignoreelements.ts:7
ignore

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

includes

includes<T>(source: AsyncIterable<T>, searchElement: T, fromIndex?: number): Promise<boolean>

- Defined in asynciterable/includes.ts:3
Type parameters
- T
Parameters
- source: AsyncIterable<T>
- searchElement: T
- Default value fromIndex: number = 0
Returns Promise<boolean>

includesProto

includesProto<T>(this: IterableX<T>, searchElement: T, fromIndex: number): boolean

- Defined in add/iterable-operators/includes.ts:7
ignore

Type parameters
- T
Parameters
- this: IterableX<T>
- searchElement: T
- fromIndex: number
Returns boolean

innerJoin

innerJoin<TOuter, TInner, TKey, TResult>(outer: AsyncIterable<TOuter>, inner: AsyncIterable<TInner>, outerSelector: function, innerSelector: function, resultSelector: function): AsyncIterableX<TResult>

- Defined in asynciterable/innerjoin.ts:40
Type parameters
- TOuter
- TInner
- TKey
- TResult
Parameters
- outer: AsyncIterable<TOuter>
- inner: AsyncIterable<TInner>
- outerSelector: function
 - - (value: TOuter): TKey | Promise<TKey>
 - Parameters
 - value: TOuter
 Returns TKey | Promise<TKey>
- innerSelector: function
 - - (value: TInner): TKey | Promise<TKey>
 - Parameters
 - value: TInner
 Returns TKey | Promise<TKey>
- resultSelector: function
 - - (outer: TOuter, inner: TInner): TResult | Promise<TResult>
 - Parameters
 - outer: TOuter
 - inner: TInner
 Returns TResult | Promise<TResult>
Returns AsyncIterableX<TResult>

innerJoinProto

innerJoinProto<TOuter, TInner, TKey, TResult>(this: IterableX<TOuter>, inner: Iterable<TInner>, outerSelector: function, innerSelector: function, resultSelector: function): IterableX<TResult>

- Defined in add/iterable-operators/innerjoin.ts:7
ignore

Type parameters
- TOuter
- TInner
- TKey
- TResult
Parameters
- this: IterableX<TOuter>
- inner: Iterable<TInner>
- outerSelector: function
 - - (value: TOuter): TKey
 - Parameters
 - value: TOuter
 Returns TKey
- innerSelector: function
 - - (value: TInner): TKey
 - Parameters
 - value: TInner
 Returns TKey
- resultSelector: function
 - - (outer: TOuter, inner: TInner): TResult
 - Parameters
 - outer: TOuter
 - inner: TInner
 Returns TResult
Returns IterableX<TResult>

intersect

intersect<TSource>(first: AsyncIterable<TSource>, second: AsyncIterable<TSource>, comparer?: function): AsyncIterableX<TSource>

- Defined in asynciterable/intersect.ts:48
Type parameters
- TSource
Parameters
- first: AsyncIterable<TSource>
- second: AsyncIterable<TSource>
- Default value comparer: function = comparerAsync
 - - (x: TSource, y: TSource): boolean | Promise<boolean>
 - Parameters
 - x: TSource
 - y: TSource
 Returns boolean | Promise<boolean>
Returns AsyncIterableX<TSource>

intersectProto

intersectProto<T>(this: IterableX<T>, second: IterableX<T>, comparer?: undefined | function): IterableX<T>

- Defined in add/iterable-operators/intersect.ts:7
ignore

Type parameters
- T
Parameters
- this: IterableX<T>
- second: IterableX<T>
- Optional comparer: undefined | function
Returns IterableX<T>

interval

interval(dueTime: number): AsyncIterableX<number>

- Defined in asynciterable/interval.ts:21
Parameters
- dueTime: number
Returns AsyncIterableX<number>

isArrayLike

isArrayLike(x: any): boolean

- Defined in internal/isiterable.ts:4
ignore

Parameters
- x: any
Returns boolean

isAsyncIterable

isAsyncIterable(x: any): boolean

- Defined in internal/isiterable.ts:18
ignore

Parameters
- x: any
Returns boolean

isEmpty

isEmpty<T>(source: AsyncIterable<T>): Promise<boolean>

- Defined in asynciterable/isempty.ts:1
Type parameters
- T
Parameters
- source: AsyncIterable<T>
Returns Promise<boolean>

isEmptyProto

isEmptyProto<T>(this: IterableX<T>): boolean

- Defined in add/iterable-operators/isempty.ts:7
ignore

Type parameters
- T
Parameters
- this: IterableX<T>
Returns boolean

isEventTarget

isEventTarget(obj: any): boolean

- Defined in asynciterable/fromevent.ts:23
Parameters
- obj: any
Returns boolean

isIterable

isIterable(x: any): boolean

- Defined in internal/isiterable.ts:11
ignore

Parameters
- x: any
Returns boolean

isNodeEventEmitter

isNodeEventEmitter(obj: any): boolean

- Defined in asynciterable/fromevent.ts:19
Parameters
- obj: any
Returns boolean

isObservable

isObservable(x: any): boolean

- Defined in asynciterable/asynciterablex.ts:205
Parameters
- x: any
Returns boolean

isPromise

isPromise(x: any): boolean

- Defined in asynciterable/asynciterablex.ts:201
Parameters
- x: any
Returns boolean

last

last<T, S>(source: AsyncIterable<T>, predicate: function): Promise<S | undefined>
last<T>(source: AsyncIterable<T>, predicate?: undefined | function): Promise<T | undefined>
last<T, S>(source: Iterable<T>, predicate: function): S | undefined
last<T>(source: Iterable<T>, predicate?: undefined | function): T | undefined

- Defined in asynciterable/last.ts:1
Type parameters
- T
- S: T
Parameters
- source: AsyncIterable<T>
- predicate: function
 - - (value: T, index: number): boolean
 - Parameters
 - value: T
 - index: number
 Returns boolean
Returns Promise<S | undefined>
- Defined in asynciterable/last.ts:5
Type parameters
- T
Parameters
- source: AsyncIterable<T>
- Optional predicate: undefined | function
Returns Promise<T | undefined>
- Defined in iterable/last.ts:1
Type parameters
- T
- S: T
Parameters
- source: Iterable<T>
- predicate: function
 - - (value: T, index: number): boolean
 - Parameters
 - value: T
 - index: number
 Returns boolean
Returns S | undefined
- Defined in iterable/last.ts:5
Type parameters
- T
Parameters
- source: Iterable<T>
- Optional predicate: undefined | function
Returns T | undefined

lastProto

lastProto<T, S>(this: IterableX<T>, predicate: function): S | undefined
lastProto<T>(this: IterableX<T>, predicate?: undefined | function): T | undefined
lastProto<T, S>(this: AsyncIterableX<T>, predicate: function): Promise<S | undefined>
lastProto<T>(this: AsyncIterableX<T>, predicate?: undefined | function): Promise<T | undefined>

- Defined in add/iterable-operators/last.ts:7
ignore

Type parameters
- T
- S: T
Parameters
- this: IterableX<T>
- predicate: function
 - - (value: T, index: number): boolean
 - Parameters
 - value: T
 - index: number
 Returns boolean
Returns S | undefined
- Defined in add/iterable-operators/last.ts:11
Type parameters
- T
Parameters
- this: IterableX<T>
- Optional predicate: undefined | function
Returns T | undefined
- Defined in add/asynciterable-operators/last.ts:8
ignore

Type parameters
- T
- S: T
Parameters
- this: AsyncIterableX<T>
- predicate: function
 - - (value: T, index: number): boolean
 - Parameters
 - value: T
 - index: number
 Returns boolean
Returns Promise<S | undefined>
- Defined in add/asynciterable-operators/last.ts:12
Type parameters
- T
Parameters
- this: AsyncIterableX<T>
- Optional predicate: undefined | function
Returns Promise<T | undefined>

makeTuple

makeTuple<TFirst, TSecond>(x: TFirst, y: TSecond): [TFirst, TSecond]

- Defined in asynciterable/ofentries.ts:3
Type parameters
- TFirst
- TSecond
Parameters
- x: TFirst
- y: TSecond
Returns [TFirst, TSecond]

map

map<TSource, TResult>(source: AsyncIterable<TSource>, selector: function, thisArg?: any): AsyncIterableX<TResult>

- Defined in asynciterable/map.ts:26
Type parameters
- TSource
- TResult
Parameters
- source: AsyncIterable<TSource>
- selector: function
 - - (value: TSource, index: number): Promise<TResult> | TResult
 - Parameters
 - value: TSource
 - index: number
 Returns Promise<TResult> | TResult
- Optional thisArg: any
Returns AsyncIterableX<TResult>

mapAsync

mapAsync<TSource, TResult>(source: Iterable<TSource | Promise<TSource>> | AsyncIterable<TSource>, selector: function, thisArg?: any): AsyncIterableX<TResult>

- Defined in iterable/mapasync.ts:25
Type parameters
- TSource
- TResult
Parameters
- source: Iterable<TSource | Promise<TSource>> | AsyncIterable<TSource>
- selector: function
 - - (value: TSource, index: number): TResult | Promise<TResult>
 - Parameters
 - value: TSource
 - index: number
 Returns TResult | Promise<TResult>
- Optional thisArg: any
Returns AsyncIterableX<TResult>

mapProto

mapProto<T, U>(this: IterableX<T>, fn: function, thisArg?: any): IterableX

- Defined in add/iterable-operators/map.ts:7
ignore

Type parameters
- T
- U
Parameters
- this: IterableX<T>
- fn: function
 - - (value: T, index: number): U
 - Parameters
 - value: T
 - index: number
 Returns U
- Optional thisArg: any
Returns IterableX

max

max(source: AsyncIterable<number>, selector?: undefined | function): Promise<number>
max<T>(source: AsyncIterable<T>, selector: function): Promise<number>
max(source: Iterable<number>, fn?: undefined | function): number
max<T>(source: Iterable<T>, fn: function): number

- Defined in asynciterable/max.ts:3
Parameters
- source: AsyncIterable<number>
- Optional selector: undefined | function
Returns Promise<number>
- Defined in asynciterable/max.ts:7
Type parameters
- T
Parameters
- source: AsyncIterable<T>
- selector: function
 - - (x: T): number | Promise<number>
 - Parameters
 - x: T
 Returns number | Promise<number>
Returns Promise<number>
- Defined in iterable/max.ts:3
Parameters
- source: Iterable<number>
- Optional fn: undefined | function
Returns number
- Defined in iterable/max.ts:4
Type parameters
- T
Parameters
- source: Iterable<T>
- fn: function
 - - (x: T): number
 - Parameters
 - x: T
 Returns number
Returns number

maxBy

maxBy<TSource, TKey>(source: AsyncIterable<TSource>, keySelector: function, comparer?: function): AsyncIterableX<TSource>

- Defined in asynciterable/maxby.ts:4
Type parameters
- TSource
- TKey
Parameters
- source: AsyncIterable<TSource>
- keySelector: function
 - - (x: TSource): TKey | Promise<TKey>
 - Parameters
 - x: TSource
 Returns TKey | Promise<TKey>
- Default value comparer: function = defaultCompareAsync
 - - (x: TKey, y: TKey): number | Promise<number>
 - Parameters
 - x: TKey
 - y: TKey
 Returns number | Promise<number>
Returns AsyncIterableX<TSource>

maxByProto

maxByProto<TSource, TKey>(this: IterableX<TSource>, keyFn: function, cmp?: undefined | function): IterableX<TSource>

- Defined in add/iterable-operators/maxby.ts:7
ignore

Type parameters
- TSource
- TKey
Parameters
- this: IterableX<TSource>
- keyFn: function
 - - (x: TSource): TKey
 - Parameters
 - x: TSource
 Returns TKey
- Optional cmp: undefined | function
Returns IterableX<TSource>

maxProto

maxProto(this: IterableX<number>, fn?: undefined | function): number
maxProto<T>(this: IterableX<T>, fn: function): number
maxProto(this: AsyncIterableX<number>, selector?: undefined | function): Promise<number>
maxProto<T>(this: AsyncIterableX<T>, selector: function): Promise<number>

- Defined in add/iterable-operators/max.ts:4
Parameters
- this: IterableX<number>
- Optional fn: undefined | function
Returns number
- Defined in add/iterable-operators/max.ts:5
Type parameters
- T
Parameters
- this: IterableX<T>
- fn: function
 - - (x: T): number
 - Parameters
 - x: T
 Returns number
Returns number
- Defined in add/asynciterable-operators/max.ts:5
Parameters
- this: AsyncIterableX<number>
- Optional selector: undefined | function
Returns Promise<number>
- Defined in add/asynciterable-operators/max.ts:9
Type parameters
- T
Parameters
- this: AsyncIterableX<T>
- selector: function
 - - (x: T): number
 - Parameters
 - x: T
 Returns number
Returns Promise<number>

memoize

memoize<TSource>(source: AsyncIterable<TSource>, readerCount?: undefined | number): AsyncIterableX<TSource>
memoize<TSource, TResult>(source: AsyncIterable<TSource>, readerCount?: undefined | number, selector?: undefined | function): AsyncIterableX<TResult>
memoize<TSource>(source: Iterable<TSource>, readerCount?: undefined | number): IterableX<TSource>
memoize<TSource, TResult>(source: Iterable<TSource>, readerCount?: undefined | number, selector?: undefined | function): IterableX<TResult>
memoize<TSource>(readerCount?: undefined | number): OperatorFunction<TSource, TSource>
memoize<TSource, TResult>(readerCount?: undefined | number, selector?: undefined | function): OperatorFunction<TSource, TResult>
memoize<TSource>(readerCount?: undefined | number): OperatorAsyncFunction<TSource, TSource>
memoize<TSource, TResult>(readerCount?: undefined | number, selector?: undefined | function): OperatorAsyncFunction<TSource, TResult>

- Defined in asynciterable/memoize.ts:62
Type parameters
- TSource
Parameters
- source: AsyncIterable<TSource>
- Optional readerCount: undefined | number
Returns AsyncIterableX<TSource>
- Defined in asynciterable/memoize.ts:66
Type parameters
- TSource
- TResult
Parameters
- source: AsyncIterable<TSource>
- Optional readerCount: undefined | number
- Optional selector: undefined | function
Returns AsyncIterableX<TResult>
- Defined in iterable/memoize.ts:61
Type parameters
- TSource
Parameters
- source: Iterable<TSource>
- Optional readerCount: undefined | number
Returns IterableX<TSource>
- Defined in iterable/memoize.ts:65
Type parameters
- TSource
- TResult
Parameters
- source: Iterable<TSource>
- Optional readerCount: undefined | number
- Optional selector: undefined | function
Returns IterableX<TResult>
- Defined in iterable/pipe/memoize.ts:5
Type parameters
- TSource
Parameters
- Optional readerCount: undefined | number
Returns OperatorFunction<TSource, TSource>
- Defined in iterable/pipe/memoize.ts:6
Type parameters
- TSource
- TResult
Parameters
- Optional readerCount: undefined | number
- Optional selector: undefined | function
Returns OperatorFunction<TSource, TResult>
- Defined in asynciterable/pipe/memoize.ts:5
Type parameters
- TSource
Parameters
- Optional readerCount: undefined | number
Returns OperatorAsyncFunction<TSource, TSource>
- Defined in asynciterable/pipe/memoize.ts:6
Type parameters
- TSource
- TResult
Parameters
- Optional readerCount: undefined | number
- Optional selector: undefined | function
Returns OperatorAsyncFunction<TSource, TResult>

memoizeProto

memoizeProto<TSource>(this: IterableX<TSource>, readerCount?: undefined | number): IterableX<TSource>
memoizeProto<TSource, TResult>(this: IterableX<TSource>, readerCount?: undefined | number, selector?: undefined | function): IterableX<TResult>
memoizeProto<TSource>(this: AsyncIterableX<TSource>, readerCount?: undefined | number): AsyncIterableX<TSource>
memoizeProto<TSource, TResult>(this: AsyncIterableX<TSource>, readerCount?: undefined | number, selector?: undefined | function): AsyncIterableX<TResult>

- Defined in add/iterable-operators/memoize.ts:4
Type parameters
- TSource
Parameters
- this: IterableX<TSource>
- Optional readerCount: undefined | number
Returns IterableX<TSource>
- Defined in add/iterable-operators/memoize.ts:8
Type parameters
- TSource
- TResult
Parameters
- this: IterableX<TSource>
- Optional readerCount: undefined | number
- Optional selector: undefined | function
Returns IterableX<TResult>
- Defined in add/asynciterable-operators/memoize.ts:4
Type parameters
- TSource
Parameters
- this: AsyncIterableX<TSource>
- Optional readerCount: undefined | number
Returns AsyncIterableX<TSource>
- Defined in add/asynciterable-operators/memoize.ts:8
Type parameters
- TSource
- TResult
Parameters
- this: AsyncIterableX<TSource>
- Optional readerCount: undefined | number
- Optional selector: undefined | function
Returns AsyncIterableX<TResult>

merge

merge<T>(source: AsyncIterable<T>): AsyncIterableX<T>
merge<T, T2>(source: AsyncIterable<T>, v2: AsyncIterable<T2>): AsyncIterableX<T | T2>
merge<T, T2, T3>(source: AsyncIterable<T>, v2: AsyncIterable<T2>, v3: AsyncIterable<T3>): AsyncIterableX<T | T2 | T3>
merge<T, T2, T3, T4>(source: AsyncIterable<T>, v2: AsyncIterable<T2>, v3: AsyncIterable<T3>, v4: AsyncIterable<T4>): AsyncIterableX<T | T2 | T3 | T4>
merge<T, T2, T3, T4, T5>(source: AsyncIterable<T>, v2: AsyncIterable<T2>, v3: AsyncIterable<T3>, v4: AsyncIterable<T4>, v5: AsyncIterable<T5>): AsyncIterable<T | T2 | T3 | T4 | T5>
merge<T, T2, T3, T4, T5, T6>(source: AsyncIterable<T>, v2: AsyncIterable<T2>, v3: AsyncIterable<T3>, v4: AsyncIterable<T4>, v5: AsyncIterable<T5>, v6: AsyncIterable<T6>): AsyncIterable<T | T2 | T3 | T4 | T5 | T6>
merge<T>(source: AsyncIterable<T>, ...args: AsyncIterable<T>[]): AsyncIterableX<T>
merge<T, T2>(v2: AsyncIterable<T2>): MonoTypeOperatorAsyncFunction<T | T2>
merge<T, T2, T3>(v2: AsyncIterable<T2>, v3: AsyncIterable<T3>): MonoTypeOperatorAsyncFunction<T | T2 | T3>
merge<T, T2, T3, T4>(v2: AsyncIterable<T2>, v3: AsyncIterable<T3>, v4: AsyncIterable<T4>): MonoTypeOperatorAsyncFunction<T | T2 | T3 | T4>
merge<T, T2, T3, T4, T5>(v2: AsyncIterable<T2>, v3: AsyncIterable<T3>, v4: AsyncIterable<T4>, v5: AsyncIterable<T5>): MonoTypeOperatorAsyncFunction<T | T2 | T3 | T4 | T5>
merge<T, T2, T3, T4, T5, T6>(v2: AsyncIterable<T2>, v3: AsyncIterable<T3>, v4: AsyncIterable<T4>, v5: AsyncIterable<T5>, v6: AsyncIterable<T6>): MonoTypeOperatorAsyncFunction<T | T2 | T3 | T4 | T5 | T6>

- Defined in asynciterable/merge.ts:47
Type parameters
- T
Parameters
- source: AsyncIterable<T>
Returns AsyncIterableX<T>
- Defined in asynciterable/merge.ts:48
Type parameters
- T
- T2
Parameters
- source: AsyncIterable<T>
- v2: AsyncIterable<T2>
Returns AsyncIterableX<T | T2>
- Defined in asynciterable/merge.ts:52
Type parameters
- T
- T2
- T3
Parameters
- source: AsyncIterable<T>
- v2: AsyncIterable<T2>
- v3: AsyncIterable<T3>
Returns AsyncIterableX<T | T2 | T3>
- Defined in asynciterable/merge.ts:57
Type parameters
- T
- T2
- T3
- T4
Parameters
- source: AsyncIterable<T>
- v2: AsyncIterable<T2>
- v3: AsyncIterable<T3>
- v4: AsyncIterable<T4>
Returns AsyncIterableX<T | T2 | T3 | T4>
- Defined in asynciterable/merge.ts:63
Type parameters
- T
- T2
- T3
- T4
- T5
Parameters
- source: AsyncIterable<T>
- v2: AsyncIterable<T2>
- v3: AsyncIterable<T3>
- v4: AsyncIterable<T4>
- v5: AsyncIterable<T5>
Returns AsyncIterable<T | T2 | T3 | T4 | T5>
- Defined in asynciterable/merge.ts:70
Type parameters
- T
- T2
- T3
- T4
- T5
- T6
Parameters
- source: AsyncIterable<T>
- v2: AsyncIterable<T2>
- v3: AsyncIterable<T3>
- v4: AsyncIterable<T4>
- v5: AsyncIterable<T5>
- v6: AsyncIterable<T6>
Returns AsyncIterable<T | T2 | T3 | T4 | T5 | T6>
- Defined in asynciterable/merge.ts:78
Type parameters
- T
Parameters
- source: AsyncIterable<T>
- Rest ...args: AsyncIterable<T>[]
Returns AsyncIterableX<T>
- Defined in asynciterable/pipe/merge.ts:6
Type parameters
- T
- T2
Parameters
- v2: AsyncIterable<T2>
Returns MonoTypeOperatorAsyncFunction<T | T2>
- Defined in asynciterable/pipe/merge.ts:7
Type parameters
- T
- T2
- T3
Parameters
- v2: AsyncIterable<T2>
- v3: AsyncIterable<T3>
Returns MonoTypeOperatorAsyncFunction<T | T2 | T3>
- Defined in asynciterable/pipe/merge.ts:11
Type parameters
- T
- T2
- T3
- T4
Parameters
- v2: AsyncIterable<T2>
- v3: AsyncIterable<T3>
- v4: AsyncIterable<T4>
Returns MonoTypeOperatorAsyncFunction<T | T2 | T3 | T4>
- Defined in asynciterable/pipe/merge.ts:16
Type parameters
- T
- T2
- T3
- T4
- T5
Parameters
- v2: AsyncIterable<T2>
- v3: AsyncIterable<T3>
- v4: AsyncIterable<T4>
- v5: AsyncIterable<T5>
Returns MonoTypeOperatorAsyncFunction<T | T2 | T3 | T4 | T5>
- Defined in asynciterable/pipe/merge.ts:22
Type parameters
- T
- T2
- T3
- T4
- T5
- T6
Parameters
- v2: AsyncIterable<T2>
- v3: AsyncIterable<T3>
- v4: AsyncIterable<T4>
- v5: AsyncIterable<T5>
- v6: AsyncIterable<T6>
Returns MonoTypeOperatorAsyncFunction<T | T2 | T3 | T4 | T5 | T6>

mergeAll

mergeAll<TSource>(source: AsyncIterable<AsyncIterable<TSource>>): AsyncIterableX<TSource>

- Defined in asynciterable/mergeall.ts:4
Type parameters
- TSource
Parameters
- source: AsyncIterable<AsyncIterable<TSource>>
Returns AsyncIterableX<TSource>

mergeAllProto

mergeAllProto<T>(this: AsyncIterableX<AsyncIterable<T>>): AsyncIterableX<T>

- Defined in add/asynciterable-operators/mergeall.ts:7
ignore

Type parameters
- T
Parameters
- this: AsyncIterableX<AsyncIterable<T>>
Returns AsyncIterableX<T>

mergeProto

mergeProto<T>(this: AsyncIterableX<T>): AsyncIterableX<T>
mergeProto<T, T2>(this: AsyncIterableX<T>, v2: AsyncIterable<T2>): AsyncIterableX<T | T2>
mergeProto<T, T2, T3>(this: AsyncIterableX<T>, v2: AsyncIterable<T2>, v3: AsyncIterable<T3>): AsyncIterableX<T | T2 | T3>
mergeProto<T, T2, T3, T4>(this: AsyncIterableX<T>, v2: AsyncIterable<T2>, v3: AsyncIterable<T3>, v4: AsyncIterable<T4>): AsyncIterableX<T | T2 | T3 | T4>
mergeProto<T, T2, T3, T4, T5>(this: AsyncIterableX<T>, v2: AsyncIterable<T2>, v3: AsyncIterable<T3>, v4: AsyncIterable<T4>, v5: AsyncIterable<T5>): AsyncIterable<T | T2 | T3 | T4 | T5>
mergeProto<T, T2, T3, T4, T5, T6>(this: AsyncIterableX<T>, v2: AsyncIterable<T2>, v3: AsyncIterable<T3>, v4: AsyncIterable<T4>, v5: AsyncIterable<T5>, v6: AsyncIterable<T6>): AsyncIterable<T | T2 | T3 | T4 | T5 | T6>

- Defined in add/asynciterable-operators/merge.ts:8
ignore

Type parameters
- T
Parameters
- this: AsyncIterableX<T>
Returns AsyncIterableX<T>
- Defined in add/asynciterable-operators/merge.ts:12
ignore

Type parameters
- T
- T2
Parameters
- this: AsyncIterableX<T>
- v2: AsyncIterable<T2>
Returns AsyncIterableX<T | T2>
- Defined in add/asynciterable-operators/merge.ts:19
ignore

Type parameters
- T
- T2
- T3
Parameters
- this: AsyncIterableX<T>
- v2: AsyncIterable<T2>
- v3: AsyncIterable<T3>
Returns AsyncIterableX<T | T2 | T3>
- Defined in add/asynciterable-operators/merge.ts:27
ignore

Type parameters
- T
- T2
- T3
- T4
Parameters
- this: AsyncIterableX<T>
- v2: AsyncIterable<T2>
- v3: AsyncIterable<T3>
- v4: AsyncIterable<T4>
Returns AsyncIterableX<T | T2 | T3 | T4>
- Defined in add/asynciterable-operators/merge.ts:36
ignore

Type parameters
- T
- T2
- T3
- T4
- T5
Parameters
- this: AsyncIterableX<T>
- v2: AsyncIterable<T2>
- v3: AsyncIterable<T3>
- v4: AsyncIterable<T4>
- v5: AsyncIterable<T5>
Returns AsyncIterable<T | T2 | T3 | T4 | T5>
- Defined in add/asynciterable-operators/merge.ts:46
ignore

Type parameters
- T
- T2
- T3
- T4
- T5
- T6
Parameters
- this: AsyncIterableX<T>
- v2: AsyncIterable<T2>
- v3: AsyncIterable<T3>
- v4: AsyncIterable<T4>
- v5: AsyncIterable<T5>
- v6: AsyncIterable<T6>
Returns AsyncIterable<T | T2 | T3 | T4 | T5 | T6>

mergeStatic

mergeStatic<T>(v1: AsyncIterable<T>): AsyncIterableX<T>
mergeStatic<T, T2>(v1: AsyncIterable<T>, v2: AsyncIterable<T2>): AsyncIterableX<T | T2>
mergeStatic<T, T2, T3>(v1: AsyncIterable<T>, v2: AsyncIterable<T2>, v3: AsyncIterable<T3>): AsyncIterableX<T | T2 | T3>
mergeStatic<T, T2, T3, T4>(v1: AsyncIterable<T>, v2: AsyncIterable<T2>, v3: AsyncIterable<T3>, v4: AsyncIterable<T4>): AsyncIterableX<T | T2 | T3 | T4>
mergeStatic<T, T2, T3, T4, T5>(v1: AsyncIterable<T>, v2: AsyncIterable<T2>, v3: AsyncIterable<T3>, v4: AsyncIterable<T4>, v5: AsyncIterable<T5>): AsyncIterable<T | T2 | T3 | T4 | T5>
mergeStatic<T, T2, T3, T4, T5, T6>(v1: AsyncIterable<T>, v2: AsyncIterable<T2>, v3: AsyncIterable<T3>, v4: AsyncIterable<T4>, v5: AsyncIterable<T5>, v6: AsyncIterable<T6>): AsyncIterable<T | T2 | T3 | T4 | T5 | T6>

- Defined in asynciterable/merge.ts:86
Type parameters
- T
Parameters
- v1: AsyncIterable<T>
Returns AsyncIterableX<T>
- Defined in asynciterable/merge.ts:87
Type parameters
- T
- T2
Parameters
- v1: AsyncIterable<T>
- v2: AsyncIterable<T2>
Returns AsyncIterableX<T | T2>
- Defined in asynciterable/merge.ts:91
Type parameters
- T
- T2
- T3
Parameters
- v1: AsyncIterable<T>
- v2: AsyncIterable<T2>
- v3: AsyncIterable<T3>
Returns AsyncIterableX<T | T2 | T3>
- Defined in asynciterable/merge.ts:96
Type parameters
- T
- T2
- T3
- T4
Parameters
- v1: AsyncIterable<T>
- v2: AsyncIterable<T2>
- v3: AsyncIterable<T3>
- v4: AsyncIterable<T4>
Returns AsyncIterableX<T | T2 | T3 | T4>
- Defined in asynciterable/merge.ts:102
Type parameters
- T
- T2
- T3
- T4
- T5
Parameters
- v1: AsyncIterable<T>
- v2: AsyncIterable<T2>
- v3: AsyncIterable<T3>
- v4: AsyncIterable<T4>
- v5: AsyncIterable<T5>
Returns AsyncIterable<T | T2 | T3 | T4 | T5>
- Defined in asynciterable/merge.ts:109
Type parameters
- T
- T2
- T3
- T4
- T5
- T6
Parameters
- v1: AsyncIterable<T>
- v2: AsyncIterable<T2>
- v3: AsyncIterable<T3>
- v4: AsyncIterable<T4>
- v5: AsyncIterable<T5>
- v6: AsyncIterable<T6>
Returns AsyncIterable<T | T2 | T3 | T4 | T5 | T6>

min

min(source: AsyncIterable<number>, selector?: undefined | function): Promise<number>
min<T>(source: AsyncIterable<T>, selector: function): Promise<number>
min(source: Iterable<number>, fn?: undefined | function): number
min<T>(source: Iterable<T>, fn: function): number

- Defined in asynciterable/min.ts:4
Parameters
- source: AsyncIterable<number>
- Optional selector: undefined | function
Returns Promise<number>
- Defined in asynciterable/min.ts:8
Type parameters
- T
Parameters
- source: AsyncIterable<T>
- selector: function
 - - (x: T): number | Promise<number>
 - Parameters
 - x: T
 Returns number | Promise<number>
Returns Promise<number>
- Defined in iterable/min.ts:4
Parameters
- source: Iterable<number>
- Optional fn: undefined | function
Returns number
- Defined in iterable/min.ts:5
Type parameters
- T
Parameters
- source: Iterable<T>
- fn: function
 - - (x: T): number
 - Parameters
 - x: T
 Returns number
Returns number

minBy

minBy<TSource, TKey>(source: AsyncIterable<TSource>, keySelector: function, comparer?: function): AsyncIterableX<TSource>

- Defined in asynciterable/minby.ts:4
Type parameters
- TSource
- TKey
Parameters
- source: AsyncIterable<TSource>
- keySelector: function
 - - (x: TSource): TKey | Promise<TKey>
 - Parameters
 - x: TSource
 Returns TKey | Promise<TKey>
- Default value comparer: function = defaultCompareAsync
 - - (x: TKey, y: TKey): number | Promise<number>
 - Parameters
 - x: TKey
 - y: TKey
 Returns number | Promise<number>
Returns AsyncIterableX<TSource>

minByProto

minByProto<TSource, TKey>(this: IterableX<TSource>, keyFn: function, cmp?: undefined | function): IterableX<TSource>

- Defined in add/iterable-operators/minby.ts:7
ignore

Type parameters
- TSource
- TKey
Parameters
- this: IterableX<TSource>
- keyFn: function
 - - (x: TSource): TKey
 - Parameters
 - x: TSource
 Returns TKey
- Optional cmp: undefined | function
Returns IterableX<TSource>

minProto

minProto(this: IterableX<number>, fn?: undefined | function): number
minProto<T>(this: IterableX<T>, fn: function): number
minProto(this: AsyncIterableX<number>, selector?: undefined | function): Promise<number>
minProto<T>(this: AsyncIterableX<T>, selector: function): Promise<number>

- Defined in add/iterable-operators/min.ts:4
Parameters
- this: IterableX<number>
- Optional fn: undefined | function
Returns number
- Defined in add/iterable-operators/min.ts:5
Type parameters
- T
Parameters
- this: IterableX<T>
- fn: function
 - - (x: T): number
 - Parameters
 - x: T
 Returns number
Returns number
- Defined in add/asynciterable-operators/min.ts:5
Parameters
- this: AsyncIterableX<number>
- Optional selector: undefined | function
Returns Promise<number>
- Defined in add/asynciterable-operators/min.ts:9
Type parameters
- T
Parameters
- this: AsyncIterableX<T>
- selector: function
 - - (x: T): number | Promise<number>
 - Parameters
 - x: T
 Returns number | Promise<number>
Returns Promise<number>

ofEntries

ofEntries<TSource>(source: object): AsyncIterableX<[string, TSource]>

- Defined in asynciterable/ofentries.ts:22
Type parameters
- TSource
Parameters
- source: object
 - [key: string]: TSource
Returns AsyncIterableX<[string, TSource]>

ofKeys

ofKeys<TSource>(source: object): AsyncIterableX<string>

- Defined in asynciterable/ofkeys.ts:16
Type parameters
- TSource
Parameters
- source: object
 - [key: string]: TSource
Returns AsyncIterableX<string>

ofValues

ofValues<TSource>(source: object): AsyncIterableX<TSource>

- Defined in asynciterable/ofvalues.ts:18
Type parameters
- TSource
Parameters
- source: object
 - [key: string]: TSource
Returns AsyncIterableX<TSource>

onErrorResumeNext

onErrorResumeNext<T>(source: AsyncIterable<T>, ...args: AsyncIterable<T>[]): AsyncIterableX<T>

- Defined in asynciterable/onerrorresumenext.ts:31
Type parameters
- T
Parameters
- source: AsyncIterable<T>
- Rest ...args: AsyncIterable<T>[]
Returns AsyncIterableX<T>

onErrorResumeNextProto

onErrorResumeNextProto<TSource>(this: IterableX<TSource>, ...args: Iterable<TSource>[]): IterableX<TSource>

- Defined in add/iterable-operators/onerrorresumenext.ts:7
ignore

Type parameters
- TSource
Parameters
- this: IterableX<TSource>
- Rest ...args: Iterable<TSource>[]
Returns IterableX<TSource>

onErrorResumeNextStatic

onErrorResumeNextStatic<T>(...source: AsyncIterable<T>[]): AsyncIterableX<T>

- Defined in asynciterable/onerrorresumenext.ts:38
Type parameters
- T
Parameters
- Rest ...source: AsyncIterable<T>[]
Returns AsyncIterableX<T>

orderBy

orderBy<TKey, TSource>(source: AsyncIterable<TSource>, keySelector: function, comparer?: function): OrderedAsyncIterableX<TKey, TSource>

- Defined in asynciterable/orderby.ts:102
Type parameters
- TKey
- TSource
Parameters
- source: AsyncIterable<TSource>
- keySelector: function
 - - (item: TSource): TKey
 - Parameters
 - item: TSource
 Returns TKey
- Default value comparer: function = defaultSorter
 - - (fst: TKey, snd: TKey): number
 - Parameters
 - fst: TKey
 - snd: TKey
 Returns number
Returns OrderedAsyncIterableX<TKey, TSource>

orderByDescending

orderByDescending<TKey, TSource>(source: AsyncIterable<TSource>, keySelector: function, comparer?: function): OrderedAsyncIterableX<TKey, TSource>

- Defined in asynciterable/orderby.ts:110
Type parameters
- TKey
- TSource
Parameters
- source: AsyncIterable<TSource>
- keySelector: function
 - - (item: TSource): TKey
 - Parameters
 - item: TSource
 Returns TKey
- Default value comparer: function = defaultSorter
 - - (fst: TKey, snd: TKey): number
 - Parameters
 - fst: TKey
 - snd: TKey
 Returns number
Returns OrderedAsyncIterableX<TKey, TSource>

orderByDescendingProto

orderByDescendingProto<TKey, TSource>(this: IterableX<TSource>, keySelector: function, comparer?: undefined | function): OrderedIterableX<TKey, TSource>

- Defined in add/iterable-operators/orderby.ts:19
ignore

Type parameters
- TKey
- TSource
Parameters
- this: IterableX<TSource>
- keySelector: function
 - - (item: TSource): TKey
 - Parameters
 - item: TSource
 Returns TKey
- Optional comparer: undefined | function
Returns OrderedIterableX<TKey, TSource>

orderByProto

orderByProto<TKey, TSource>(this: IterableX<TSource>, keySelector: function, comparer?: undefined | function): OrderedIterableX<TKey, TSource>

- Defined in add/iterable-operators/orderby.ts:8
ignore

Type parameters
- TKey
- TSource
Parameters
- this: IterableX<TSource>
- keySelector: function
 - - (item: TSource): TKey
 - Parameters
 - item: TSource
 Returns TKey
- Optional comparer: undefined | function
Returns OrderedIterableX<TKey, TSource>

pairwise

pairwise<TSource>(source: AsyncIterable<TSource>): AsyncIterableX<TSource[]>

- Defined in asynciterable/pairwise.ts:30
Returns a new sequence that triggers on the second and subsequent triggerings of the input sequence.

Type parameters
- TSource
Parameters
- source: AsyncIterable<TSource>
 
 Source sequence.
Returns AsyncIterableX<TSource[]>

A sequence that triggers on successive pairs of iterations from the input sequence.

pairwiseProto

pairwiseProto<TSource>(this: IterableX<TSource>): IterableX<TSource[]>

- Defined in add/iterable-operators/pairwise.ts:7
ignore

Type parameters
- TSource
Parameters
- this: IterableX<TSource>
Returns IterableX<TSource[]>

partition

partition<T, S>(source: AsyncIterable<T>, predicate: function, thisArg?: any): AsyncIterableX<S>[]
partition<T>(source: AsyncIterable<T>, predicate: function, thisArg?: any): AsyncIterableX<T>[]
partition<T, S>(source: Iterable<T>, predicate: function, thisArg?: any): IterableX<S>[]
partition<T>(source: Iterable<T>, predicate: function, thisArg?: any): IterableX<T>[]

- Defined in asynciterable/partition.ts:4
Type parameters
- T
- S: T
Parameters
- source: AsyncIterable<T>
- predicate: function
 - - (value: T, index: number): boolean
 - Parameters
 - value: T
 - index: number
 Returns boolean
- Optional thisArg: any
Returns AsyncIterableX<S>[]
- Defined in asynciterable/partition.ts:9
Type parameters
- T
Parameters
- source: AsyncIterable<T>
- predicate: function
 - - (value: T, index: number): boolean | Promise<boolean>
 - Parameters
 - value: T
 - index: number
 Returns boolean | Promise<boolean>
- Optional thisArg: any
Returns AsyncIterableX<T>[]
- Defined in iterable/partition.ts:4
Type parameters
- T
- S: T
Parameters
- source: Iterable<T>
- predicate: function
 - - (value: T, index: number): boolean
 - Parameters
 - value: T
 - index: number
 Returns boolean
- Optional thisArg: any
Returns IterableX<S>[]
- Defined in iterable/partition.ts:9
Type parameters
- T
Parameters
- source: Iterable<T>
- predicate: function
 - - (value: T, index: number): boolean
 - Parameters
 - value: T
 - index: number
 Returns boolean
- Optional thisArg: any
Returns IterableX<T>[]

partitionProto

partitionProto<T, S>(this: IterableX<T>, predicate: function, thisArg?: any): IterableX<S>[]
partitionProto<T>(this: IterableX<T>, predicate: function, thisArg?: any): IterableX<T>[]
partitionProto<T, S>(this: AsyncIterableX<T>, predicate: function, thisArg?: any): AsyncIterableX<S>[]
partitionProto<T>(this: AsyncIterableX<T>, predicate: function, thisArg?: any): AsyncIterableX<T>[]

- Defined in add/iterable-operators/partition.ts:8
ignore

Type parameters
- T
- S: T
Parameters
- this: IterableX<T>
- predicate: function
 - - (value: T, index: number): boolean
 - Parameters
 - value: T
 - index: number
 Returns boolean
- Optional thisArg: any
Returns IterableX<S>[]
- Defined in add/iterable-operators/partition.ts:13
Type parameters
- T
Parameters
- this: IterableX<T>
- predicate: function
 - - (value: T, index: number): boolean
 - Parameters
 - value: T
 - index: number
 Returns boolean
- Optional thisArg: any
Returns IterableX<T>[]
- Defined in add/asynciterable-operators/partition.ts:8
ignore

Type parameters
- T
- S: T
Parameters
- this: AsyncIterableX<T>
- predicate: function
 - - (value: T, index: number): boolean
 - Parameters
 - value: T
 - index: number
 Returns boolean
- Optional thisArg: any
Returns AsyncIterableX<S>[]
- Defined in add/asynciterable-operators/partition.ts:13
Type parameters
- T
Parameters
- this: AsyncIterableX<T>
- predicate: function
 - - (value: T, index: number): boolean | Promise<boolean>
 - Parameters
 - value: T
 - index: number
 Returns boolean | Promise<boolean>
- Optional thisArg: any
Returns AsyncIterableX<T>[]

pipe

pipe<T>(source: Iterable<T>): IterableX<T>
pipe<T, A>(source: Iterable<T>, op1: OperatorFunction<T, A>): IterableX<A>
pipe<T, A, B>(source: Iterable<T>, op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>): IterableX
pipe<T, A, B, C>(source: Iterable<T>, op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>): IterableX<C>
pipe<T, A, B, C, D>(source: Iterable<T>, op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>): IterableX<D>
pipe<T, A, B, C, D, E>(source: Iterable<T>, op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>): IterableX<E>
pipe<T, A, B, C, D, E, F>(source: Iterable<T>, op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>): IterableX<F>
pipe<T, A, B, C, D, E, F, G>(source: Iterable<T>, 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>): IterableX<G>
pipe<T, A, B, C, D, E, F, G, H>(source: Iterable<T>, 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>): IterableX<H>
pipe<T, A, B, C, D, E, F, G, H, I>(source: Iterable<T>, 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>): IterableX
pipe<T>(source: AsyncIterable<T>): AsyncIterableX<T>
pipe<T, A>(source: AsyncIterable<T>, op1: OperatorAsyncFunction<T, A>): AsyncIterableX<A>
pipe<T, A, B>(source: AsyncIterable<T>, op1: OperatorAsyncFunction<T, A>, op2: OperatorAsyncFunction<A, B>): AsyncIterableX
pipe<T, A, B, C>(source: AsyncIterable<T>, op1: OperatorAsyncFunction<T, A>, op2: OperatorAsyncFunction<A, B>, op3: OperatorAsyncFunction<B, C>): AsyncIterableX<C>
pipe<T, A, B, C, D>(source: AsyncIterable<T>, op1: OperatorAsyncFunction<T, A>, op2: OperatorAsyncFunction<A, B>, op3: OperatorAsyncFunction<B, C>, op4: OperatorAsyncFunction<C, D>): AsyncIterableX<D>
pipe<T, A, B, C, D, E>(source: AsyncIterable<T>, op1: OperatorAsyncFunction<T, A>, op2: OperatorAsyncFunction<A, B>, op3: OperatorAsyncFunction<B, C>, op4: OperatorAsyncFunction<C, D>, op5: OperatorAsyncFunction<D, E>): AsyncIterableX<E>
pipe<T, A, B, C, D, E, F>(source: AsyncIterable<T>, op1: OperatorAsyncFunction<T, A>, op2: OperatorAsyncFunction<A, B>, op3: OperatorAsyncFunction<B, C>, op4: OperatorAsyncFunction<C, D>, op5: OperatorAsyncFunction<D, E>, op6: OperatorAsyncFunction<E, F>): AsyncIterableX<F>
pipe<T, A, B, C, D, E, F, G>(source: AsyncIterable<T>, op1: OperatorAsyncFunction<T, A>, op2: OperatorAsyncFunction<A, B>, op3: OperatorAsyncFunction<B, C>, op4: OperatorAsyncFunction<C, D>, op5: OperatorAsyncFunction<D, E>, op6: OperatorAsyncFunction<E, F>, op7: OperatorAsyncFunction<F, G>): AsyncIterableX<G>
pipe<T, A, B, C, D, E, F, G, H>(source: AsyncIterable<T>, op1: OperatorAsyncFunction<T, A>, op2: OperatorAsyncFunction<A, B>, op3: OperatorAsyncFunction<B, C>, op4: OperatorAsyncFunction<C, D>, op5: OperatorAsyncFunction<D, E>, op6: OperatorAsyncFunction<E, F>, op7: OperatorAsyncFunction<F, G>, op8: OperatorAsyncFunction<G, H>): AsyncIterableX<H>
pipe<T, A, B, C, D, E, F, G, H, I>(source: AsyncIterable<T>, op1: OperatorAsyncFunction<T, A>, op2: OperatorAsyncFunction<A, B>, op3: OperatorAsyncFunction<B, C>, op4: OperatorAsyncFunction<C, D>, op5: OperatorAsyncFunction<D, E>, op6: OperatorAsyncFunction<E, F>, op7: OperatorAsyncFunction<F, G>, op8: OperatorAsyncFunction<G, H>, op9: OperatorAsyncFunction<H, I>): AsyncIterableX

- Defined in iterable/pipe.ts:5
Type parameters
- T
Parameters
- source: Iterable<T>
Returns IterableX<T>
- Defined in iterable/pipe.ts:6
Type parameters
- T
- A
Parameters
- source: Iterable<T>
- op1: OperatorFunction<T, A>
Returns IterableX<A>
- Defined in iterable/pipe.ts:7
Type parameters
- T
- A
- B
Parameters
- source: Iterable<T>
- op1: OperatorFunction<T, A>
- op2: OperatorFunction<A, B>
Returns IterableX
- Defined in iterable/pipe.ts:12
Type parameters
- T
- A
- B
- C
Parameters
- source: Iterable<T>
- op1: OperatorFunction<T, A>
- op2: OperatorFunction<A, B>
- op3: OperatorFunction<B, C>
Returns IterableX<C>
- Defined in iterable/pipe.ts:18
Type parameters
- T
- A
- B
- C
- D
Parameters
- source: Iterable<T>
- op1: OperatorFunction<T, A>
- op2: OperatorFunction<A, B>
- op3: OperatorFunction<B, C>
- op4: OperatorFunction<C, D>
Returns IterableX<D>
- Defined in iterable/pipe.ts:25
Type parameters
- T
- A
- B
- C
- D
- E
Parameters
- source: Iterable<T>
- op1: OperatorFunction<T, A>
- op2: OperatorFunction<A, B>
- op3: OperatorFunction<B, C>
- op4: OperatorFunction<C, D>
- op5: OperatorFunction<D, E>
Returns IterableX<E>
- Defined in iterable/pipe.ts:33
Type parameters
- T
- A
- B
- C
- D
- E
- F
Parameters
- source: Iterable<T>
- 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 IterableX<F>
- Defined in iterable/pipe.ts:42
Type parameters
- T
- A
- B
- C
- D
- E
- F
- G
Parameters
- source: Iterable<T>
- 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 IterableX<G>
- Defined in iterable/pipe.ts:52
Type parameters
- T
- A
- B
- C
- D
- E
- F
- G
- H
Parameters
- source: Iterable<T>
- 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 IterableX<H>
- Defined in iterable/pipe.ts:63
Type parameters
- T
- A
- B
- C
- D
- E
- F
- G
- H
- I
Parameters
- source: Iterable<T>
- 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 IterableX
- Defined in asynciterable/pipe.ts:5
Type parameters
- T
Parameters
- source: AsyncIterable<T>
Returns AsyncIterableX<T>
- Defined in asynciterable/pipe.ts:6
Type parameters
- T
- A
Parameters
- source: AsyncIterable<T>
- op1: OperatorAsyncFunction<T, A>
Returns AsyncIterableX<A>
- Defined in asynciterable/pipe.ts:10
Type parameters
- T
- A
- B
Parameters
- source: AsyncIterable<T>
- op1: OperatorAsyncFunction<T, A>
- op2: OperatorAsyncFunction<A, B>
Returns AsyncIterableX
- Defined in asynciterable/pipe.ts:15
Type parameters
- T
- A
- B
- C
Parameters
- source: AsyncIterable<T>
- op1: OperatorAsyncFunction<T, A>
- op2: OperatorAsyncFunction<A, B>
- op3: OperatorAsyncFunction<B, C>
Returns AsyncIterableX<C>
- Defined in asynciterable/pipe.ts:21
Type parameters
- T
- A
- B
- C
- D
Parameters
- source: AsyncIterable<T>
- op1: OperatorAsyncFunction<T, A>
- op2: OperatorAsyncFunction<A, B>
- op3: OperatorAsyncFunction<B, C>
- op4: OperatorAsyncFunction<C, D>
Returns AsyncIterableX<D>
- Defined in asynciterable/pipe.ts:28
Type parameters
- T
- A
- B
- C
- D
- E
Parameters
- source: AsyncIterable<T>
- op1: OperatorAsyncFunction<T, A>
- op2: OperatorAsyncFunction<A, B>
- op3: OperatorAsyncFunction<B, C>
- op4: OperatorAsyncFunction<C, D>
- op5: OperatorAsyncFunction<D, E>
Returns AsyncIterableX<E>
- Defined in asynciterable/pipe.ts:36
Type parameters
- T
- A
- B
- C
- D
- E
- F
Parameters
- source: AsyncIterable<T>
- op1: OperatorAsyncFunction<T, A>
- op2: OperatorAsyncFunction<A, B>
- op3: OperatorAsyncFunction<B, C>
- op4: OperatorAsyncFunction<C, D>
- op5: OperatorAsyncFunction<D, E>
- op6: OperatorAsyncFunction<E, F>
Returns AsyncIterableX<F>
- Defined in asynciterable/pipe.ts:45
Type parameters
- T
- A
- B
- C
- D
- E
- F
- G
Parameters
- source: AsyncIterable<T>
- op1: OperatorAsyncFunction<T, A>
- op2: OperatorAsyncFunction<A, B>
- op3: OperatorAsyncFunction<B, C>
- op4: OperatorAsyncFunction<C, D>
- op5: OperatorAsyncFunction<D, E>
- op6: OperatorAsyncFunction<E, F>
- op7: OperatorAsyncFunction<F, G>
Returns AsyncIterableX<G>
- Defined in asynciterable/pipe.ts:55
Type parameters
- T
- A
- B
- C
- D
- E
- F
- G
- H
Parameters
- source: AsyncIterable<T>
- op1: OperatorAsyncFunction<T, A>
- op2: OperatorAsyncFunction<A, B>
- op3: OperatorAsyncFunction<B, C>
- op4: OperatorAsyncFunction<C, D>
- op5: OperatorAsyncFunction<D, E>
- op6: OperatorAsyncFunction<E, F>
- op7: OperatorAsyncFunction<F, G>
- op8: OperatorAsyncFunction<G, H>
Returns AsyncIterableX<H>
- Defined in asynciterable/pipe.ts:66
Type parameters
- T
- A
- B
- C
- D
- E
- F
- G
- H
- I
Parameters
- source: AsyncIterable<T>
- op1: OperatorAsyncFunction<T, A>
- op2: OperatorAsyncFunction<A, B>
- op3: OperatorAsyncFunction<B, C>
- op4: OperatorAsyncFunction<C, D>
- op5: OperatorAsyncFunction<D, E>
- op6: OperatorAsyncFunction<E, F>
- op7: OperatorAsyncFunction<F, G>
- op8: OperatorAsyncFunction<G, H>
- op9: OperatorAsyncFunction<H, I>
Returns AsyncIterableX

pluck

pluck<TSource, TResult>(source: AsyncIterable<TSource>, ...args: string[]): AsyncIterableX<TResult>

- Defined in asynciterable/pluck.ts:21
Type parameters
- TSource
- TResult
Parameters
- source: AsyncIterable<TSource>
- Rest ...args: string[]
Returns AsyncIterableX<TResult>

pluckProto

pluckProto<TSource, TResult>(this: IterableX<TSource>, ...args: string[]): IterableX<TResult>

- Defined in add/iterable-operators/pluck.ts:7
ignore

Type parameters
- TSource
- TResult
Parameters
- this: IterableX<TSource>
- Rest ...args: string[]
Returns IterableX<TResult>

plucker

plucker(props: string[], length: number): function

- Defined in asynciterable/pluck.ts:4
Parameters
- props: string[]
- length: number
Returns function
- - (x: any): any
  - Parameters
    - x: any
    Returns any

publish

publish<TSource>(source: AsyncIterable<TSource>): AsyncIterableX<TSource>
publish<TSource, TResult>(source: AsyncIterable<TSource>, selector?: undefined | function): AsyncIterableX<TResult>
publish<TSource>(source: Iterable<TSource>): IterableX<TSource>
publish<TSource, TResult>(source: Iterable<TSource>, selector?: undefined | function): IterableX<TResult>
publish<TSource>(): OperatorFunction<TSource, TSource>
publish<TSource, TResult>(selector?: undefined | function): OperatorFunction<TSource, TResult>
publish<TSource>(): OperatorAsyncFunction<TSource, TSource>
publish<TSource, TResult>(selector?: undefined | function): OperatorAsyncFunction<TSource, TResult>

- Defined in asynciterable/publish.ts:70
Type parameters
- TSource
Parameters
- source: AsyncIterable<TSource>
Returns AsyncIterableX<TSource>
- Defined in asynciterable/publish.ts:71
Type parameters
- TSource
- TResult
Parameters
- source: AsyncIterable<TSource>
- Optional selector: undefined | function
Returns AsyncIterableX<TResult>
- Defined in iterable/publish.ts:70
Type parameters
- TSource
Parameters
- source: Iterable<TSource>
Returns IterableX<TSource>
- Defined in iterable/publish.ts:71
Type parameters
- TSource
- TResult
Parameters
- source: Iterable<TSource>
- Optional selector: undefined | function
Returns IterableX<TResult>
- Defined in iterable/pipe/publish.ts:5
Type parameters
- TSource
Returns OperatorFunction<TSource, TSource>
- Defined in iterable/pipe/publish.ts:6
Type parameters
- TSource
- TResult
Parameters
- Optional selector: undefined | function
Returns OperatorFunction<TSource, TResult>
- Defined in asynciterable/pipe/publish.ts:5
Type parameters
- TSource
Returns OperatorAsyncFunction<TSource, TSource>
- Defined in asynciterable/pipe/publish.ts:6
Type parameters
- TSource
- TResult
Parameters
- Optional selector: undefined | function
Returns OperatorAsyncFunction<TSource, TResult>

publishProto

publishProto<TSource>(this: IterableX<TSource>): IterableX<TSource>
publishProto<TSource, TResult>(this: IterableX<TSource>, selector?: undefined | function): IterableX<TResult>
publishProto<TSource>(this: AsyncIterableX<TSource>): AsyncIterableX<TSource>
publishProto<TSource, TResult>(this: AsyncIterableX<TSource>, selector?: undefined | function): AsyncIterableX<TResult>

- Defined in add/iterable-operators/publish.ts:4
Type parameters
- TSource
Parameters
- this: IterableX<TSource>
Returns IterableX<TSource>
- Defined in add/iterable-operators/publish.ts:5
Type parameters
- TSource
- TResult
Parameters
- this: IterableX<TSource>
- Optional selector: undefined | function
Returns IterableX<TResult>
- Defined in add/asynciterable-operators/publish.ts:4
Type parameters
- TSource
Parameters
- this: AsyncIterableX<TSource>
Returns AsyncIterableX<TSource>
- Defined in add/asynciterable-operators/publish.ts:5
Type parameters
- TSource
- TResult
Parameters
- this: AsyncIterableX<TSource>
- Optional selector: undefined | function
Returns AsyncIterableX<TResult>

race

race<TSource>(left: AsyncIterable<TSource>, right: AsyncIterable<TSource>): AsyncIterableX<TSource>

- Defined in asynciterable/race.ts:60
Propagates the async sequence that reacts first.

Type parameters
- TSource
Parameters
- left: AsyncIterable<TSource>
 
 First async sequence.
- right: AsyncIterable<TSource>
 
 Second async sequence.
Returns AsyncIterableX<TSource>

An async sequence that surfaces either of the given sequences, whichever reacted first.

range

range(start: number, count: number): AsyncIterableX<number>

- Defined in asynciterable/range.ts:20
Parameters
- start: number
- count: number
Returns AsyncIterableX<number>

reduce

reduce<T, R>(source: AsyncIterable<T>, accumulator: function, seed?: never[]): Promise<R>
reduce<T, R>(source: AsyncIterable<T>, accumulator: function, seed?: R): Promise<R>
reduce<T, R>(source: Iterable<T>, accumulator: function, seed?: never[]): R
reduce<T, R>(source: Iterable<T>, accumulator: function, seed?: R): R

- Defined in asynciterable/reduce.ts:1
Type parameters
- T
- R
Parameters
- source: AsyncIterable<T>
- accumulator: function
 - - (previousValue: R, currentValue: T, currentIndex: number): R | Promise<R>
 - Parameters
 - previousValue: R
 - currentValue: T
 - currentIndex: number
 Returns R | Promise<R>
- Optional seed: never[]
Returns Promise<R>
- Defined in asynciterable/reduce.ts:6
Type parameters
- T
- R
Parameters
- source: AsyncIterable<T>
- accumulator: function
 - - (previousValue: R, currentValue: T, currentIndex: number): R | Promise<R>
 - Parameters
 - previousValue: R
 - currentValue: T
 - currentIndex: number
 Returns R | Promise<R>
- Optional seed: R
Returns Promise<R>
- Defined in iterable/reduce.ts:1
Type parameters
- T
- R
Parameters
- source: Iterable<T>
- accumulator: function
 - - (previousValue: R, currentValue: T, currentIndex: number): R
 - Parameters
 - previousValue: R
 - currentValue: T
 - currentIndex: number
 Returns R
- Optional seed: never[]
Returns R
- Defined in iterable/reduce.ts:6
Type parameters
- T
- R
Parameters
- source: Iterable<T>
- accumulator: function
 - - (previousValue: R, currentValue: T, currentIndex: number): R
 - Parameters
 - previousValue: R
 - currentValue: T
 - currentIndex: number
 Returns R
- Optional seed: R
Returns R

reduceProto

reduceProto<T, R>(this: IterableX<T>, accumulator: function, seed?: never[]): R
reduceProto<T, R>(this: IterableX<T>, accumulator: function, seed?: R): R
reduceProto<T, R>(this: AsyncIterableX<T>, accumulator: function, seed?: never[]): Promise<R>
reduceProto<T, R>(this: AsyncIterableX<T>, accumulator: function, seed?: R): Promise<R>

- Defined in add/iterable-operators/reduce.ts:4
Type parameters
- T
- R
Parameters
- this: IterableX<T>
- accumulator: function
 - - (previousValue: R, currentValue: T, currentIndex: number): R
 - Parameters
 - previousValue: R
 - currentValue: T
 - currentIndex: number
 Returns R
- Optional seed: never[]
Returns R
- Defined in add/iterable-operators/reduce.ts:9
Type parameters
- T
- R
Parameters
- this: IterableX<T>
- accumulator: function
 - - (previousValue: R, currentValue: T, currentIndex: number): R
 - Parameters
 - previousValue: R
 - currentValue: T
 - currentIndex: number
 Returns R
- Optional seed: R
Returns R
- Defined in add/asynciterable-operators/reduce.ts:4
Type parameters
- T
- R
Parameters
- this: AsyncIterableX<T>
- accumulator: function
 - - (previousValue: R, currentValue: T, currentIndex: number): R | Promise<R>
 - Parameters
 - previousValue: R
 - currentValue: T
 - currentIndex: number
 Returns R | Promise<R>
- Optional seed: never[]
Returns Promise<R>
- Defined in add/asynciterable-operators/reduce.ts:9
Type parameters
- T
- R
Parameters
- this: AsyncIterableX<T>
- accumulator: function
 - - (previousValue: R, currentValue: T, currentIndex: number): R | Promise<R>
 - Parameters
 - previousValue: R
 - currentValue: T
 - currentIndex: number
 Returns R | Promise<R>
- Optional seed: R
Returns Promise<R>

reduceRight

reduceRight<T, R>(source: AsyncIterable<T>, accumulator: function, seed?: never[]): Promise<R>
reduceRight<T, R>(source: AsyncIterable<T>, accumulator: function, seed?: R): Promise<R>
reduceRight<T, R>(source: Iterable<T>, accumulator: function, seed?: never[]): R
reduceRight<T, R>(source: Iterable<T>, accumulator: function, seed?: R): R

- Defined in asynciterable/reduceright.ts:2
Type parameters
- T
- R
Parameters
- source: AsyncIterable<T>
- accumulator: function
 - - (previousValue: R, currentValue: T, currentIndex: number): R | Promise<R>
 - Parameters
 - previousValue: R
 - currentValue: T
 - currentIndex: number
 Returns R | Promise<R>
- Optional seed: never[]
Returns Promise<R>
- Defined in asynciterable/reduceright.ts:7
Type parameters
- T
- R
Parameters
- source: AsyncIterable<T>
- accumulator: function
 - - (previousValue: R, currentValue: T, currentIndex: number): R | Promise<R>
 - Parameters
 - previousValue: R
 - currentValue: T
 - currentIndex: number
 Returns R | Promise<R>
- Optional seed: R
Returns Promise<R>
- Defined in iterable/reduceright.ts:2
Type parameters
- T
- R
Parameters
- source: Iterable<T>
- accumulator: function
 - - (previousValue: R, currentValue: T, currentIndex: number): R
 - Parameters
 - previousValue: R
 - currentValue: T
 - currentIndex: number
 Returns R
- Optional seed: never[]
Returns R
- Defined in iterable/reduceright.ts:7
Type parameters
- T
- R
Parameters
- source: Iterable<T>
- accumulator: function
 - - (previousValue: R, currentValue: T, currentIndex: number): R
 - Parameters
 - previousValue: R
 - currentValue: T
 - currentIndex: number
 Returns R
- Optional seed: R
Returns R

reduceRightProto

reduceRightProto<T, R>(this: IterableX<T>, accumulator: function, seed?: never[]): R
reduceRightProto<T, R>(this: IterableX<T>, accumulator: function, seed?: R): R
reduceRightProto<T, R>(this: AsyncIterableX<T>, accumulator: function, seed?: never[]): Promise<R>
reduceRightProto<T, R>(this: AsyncIterableX<T>, accumulator: function, seed?: R): Promise<R>

- Defined in add/iterable-operators/reduceright.ts:4
Type parameters
- T
- R
Parameters
- this: IterableX<T>
- accumulator: function
 - - (previousValue: R, currentValue: T, currentIndex: number): R
 - Parameters
 - previousValue: R
 - currentValue: T
 - currentIndex: number
 Returns R
- Optional seed: never[]
Returns R
- Defined in add/iterable-operators/reduceright.ts:9
Type parameters
- T
- R
Parameters
- this: IterableX<T>
- accumulator: function
 - - (previousValue: R, currentValue: T, currentIndex: number): R
 - Parameters
 - previousValue: R
 - currentValue: T
 - currentIndex: number
 Returns R
- Optional seed: R
Returns R
- Defined in add/asynciterable-operators/reduceright.ts:4
Type parameters
- T
- R
Parameters
- this: AsyncIterableX<T>
- accumulator: function
 - - (previousValue: R, currentValue: T, currentIndex: number): R | Promise<R>
 - Parameters
 - previousValue: R
 - currentValue: T
 - currentIndex: number
 Returns R | Promise<R>
- Optional seed: never[]
Returns Promise<R>
- Defined in add/asynciterable-operators/reduceright.ts:9
Type parameters
- T
- R
Parameters
- this: AsyncIterableX<T>
- accumulator: function
 - - (previousValue: R, currentValue: T, currentIndex: number): R | Promise<R>
 - Parameters
 - previousValue: R
 - currentValue: T
 - currentIndex: number
 Returns R | Promise<R>
- Optional seed: R
Returns Promise<R>

repeat

repeat<TSource>(source: AsyncIterable<TSource>, count?: number): AsyncIterableX<TSource>

- Defined in asynciterable/repeat.ts:30
Type parameters
- TSource
Parameters
- source: AsyncIterable<TSource>
- Default value count: number = -1
Returns AsyncIterableX<TSource>

repeatProto

repeatProto<TSource>(this: IterableX<TSource>, count?: number): IterableX<TSource>

- Defined in add/iterable-operators/repeat.ts:7
ignore

Type parameters
- TSource
Parameters
- this: IterableX<TSource>
- Default value count: number = -1
Returns IterableX<TSource>

repeatStatic

repeatStatic<TSource>(value: TSource, count?: number): AsyncIterableX<TSource>

- Defined in asynciterable/repeat.ts:37
Type parameters
- TSource
Parameters
- value: TSource
- Default value count: number = -1
Returns AsyncIterableX<TSource>

retry

retry<TSource>(source: AsyncIterable<TSource>, count?: number): AsyncIterableX<TSource>

- Defined in asynciterable/retry.ts:5
Type parameters
- TSource
Parameters
- source: AsyncIterable<TSource>
- Default value count: number = -1
Returns AsyncIterableX<TSource>

retryProto

retryProto<TSource>(this: IterableX<TSource>, count?: number): IterableX<TSource>

- Defined in add/iterable-operators/retry.ts:7
ignore

Type parameters
- TSource
Parameters
- this: IterableX<TSource>
- Default value count: number = -1
Returns IterableX<TSource>

returnAsyncIterator

returnAsyncIterator<T>(it: AsyncIterator<T>): Promise<void>

- Defined in internal/returniterator.ts:13
ignore

Type parameters
- T
Parameters
- it: AsyncIterator<T>
Returns Promise<void>

returnIterator

returnIterator<T>(it: Iterator<T>): void

- Defined in internal/returniterator.ts:4
ignore

Type parameters
- T
Parameters
- it: Iterator<T>
Returns void

reverse

reverse<TSource>(source: AsyncIterable<TSource>): AsyncIterableX<TSource>

- Defined in asynciterable/reverse.ts:20
Type parameters
- TSource
Parameters
- source: AsyncIterable<TSource>
Returns AsyncIterableX<TSource>

reverseProto

reverseProto<TSource>(this: IterableX<TSource>): IterableX<TSource>

- Defined in add/iterable-operators/reverse.ts:7
ignore

Type parameters
- TSource
Parameters
- this: IterableX<TSource>
Returns IterableX<TSource>

scan

scan<T, R>(source: AsyncIterable<T>, accumulator: function, seed?: never[]): AsyncIterableX<R>
scan<T, R>(source: AsyncIterable<T>, accumulator: function, seed?: R): AsyncIterableX<R>
scan<T, R>(source: Iterable<T>, accumulator: function, seed?: never[]): IterableX<R>
scan<T, R>(source: Iterable<T>, accumulator: function, seed?: R): IterableX<R>
scan<T, R>(accumulator: function, seed?: never[]): OperatorFunction<T, R>
scan<T, R>(accumulator: function, seed?: R): OperatorFunction<T, R>
scan<T, R>(accumulator: function, seed?: never[]): OperatorAsyncFunction<T, R>
scan<T, R>(accumulator: function, seed?: R): OperatorAsyncFunction<T, R>

- Defined in asynciterable/scan.ts:38
Type parameters
- T
- R
Parameters
- source: AsyncIterable<T>
- accumulator: function
 - - (previousValue: R, currentValue: T, currentIndex: number): R | Promise<R>
 - Parameters
 - previousValue: R
 - currentValue: T
 - currentIndex: number
 Returns R | Promise<R>
- Optional seed: never[]
Returns AsyncIterableX<R>
- Defined in asynciterable/scan.ts:43
Type parameters
- T
- R
Parameters
- source: AsyncIterable<T>
- accumulator: function
 - - (previousValue: R, currentValue: T, currentIndex: number): R | Promise<R>
 - Parameters
 - previousValue: R
 - currentValue: T
 - currentIndex: number
 Returns R | Promise<R>
- Optional seed: R
Returns AsyncIterableX<R>
- Defined in iterable/scan.ts:34
Type parameters
- T
- R
Parameters
- source: Iterable<T>
- accumulator: function
 - - (previousValue: R, currentValue: T, currentIndex: number): R
 - Parameters
 - previousValue: R
 - currentValue: T
 - currentIndex: number
 Returns R
- Optional seed: never[]
Returns IterableX<R>
- Defined in iterable/scan.ts:39
Type parameters
- T
- R
Parameters
- source: Iterable<T>
- accumulator: function
 - - (previousValue: R, currentValue: T, currentIndex: number): R
 - Parameters
 - previousValue: R
 - currentValue: T
 - currentIndex: number
 Returns R
- Optional seed: R
Returns IterableX<R>
- Defined in iterable/pipe/scan.ts:5
Type parameters
- T
- R
Parameters
- accumulator: function
 - - (previousValue: R, currentValue: T, currentIndex: number): R
 - Parameters
 - previousValue: R
 - currentValue: T
 - currentIndex: number
 Returns R
- Optional seed: never[]
Returns OperatorFunction<T, R>
- Defined in iterable/pipe/scan.ts:9
Type parameters
- T
- R
Parameters
- accumulator: function
 - - (previousValue: R, currentValue: T, currentIndex: number): R
 - Parameters
 - previousValue: R
 - currentValue: T
 - currentIndex: number
 Returns R
- Optional seed: R
Returns OperatorFunction<T, R>
- Defined in asynciterable/pipe/scan.ts:5
Type parameters
- T
- R
Parameters
- accumulator: function
 - - (previousValue: R, currentValue: T, currentIndex: number): R | Promise<R>
 - Parameters
 - previousValue: R
 - currentValue: T
 - currentIndex: number
 Returns R | Promise<R>
- Optional seed: never[]
Returns OperatorAsyncFunction<T, R>
- Defined in asynciterable/pipe/scan.ts:9
Type parameters
- T
- R
Parameters
- accumulator: function
 - - (previousValue: R, currentValue: T, currentIndex: number): R | Promise<R>
 - Parameters
 - previousValue: R
 - currentValue: T
 - currentIndex: number
 Returns R | Promise<R>
- Optional seed: R
Returns OperatorAsyncFunction<T, R>

scanProto

scanProto<T, R>(this: IterableX<T>, accumulator: function, seed?: never[]): IterableX<R>
scanProto<T, R>(this: IterableX<T>, accumulator: function, seed?: R): IterableX<R>
scanProto<T, R>(this: AsyncIterableX<T>, accumulator: function, seed?: never[]): AsyncIterableX<R>
scanProto<T, R>(this: AsyncIterableX<T>, accumulator: function, seed?: R): AsyncIterableX<R>

- Defined in add/iterable-operators/scan.ts:4
Type parameters
- T
- R
Parameters
- this: IterableX<T>
- accumulator: function
 - - (previousValue: R, currentValue: T, currentIndex: number): R
 - Parameters
 - previousValue: R
 - currentValue: T
 - currentIndex: number
 Returns R
- Optional seed: never[]
Returns IterableX<R>
- Defined in add/iterable-operators/scan.ts:9
Type parameters
- T
- R
Parameters
- this: IterableX<T>
- accumulator: function
 - - (previousValue: R, currentValue: T, currentIndex: number): R
 - Parameters
 - previousValue: R
 - currentValue: T
 - currentIndex: number
 Returns R
- Optional seed: R
Returns IterableX<R>
- Defined in add/asynciterable-operators/scan.ts:4
Type parameters
- T
- R
Parameters
- this: AsyncIterableX<T>
- accumulator: function
 - - (previousValue: R, currentValue: T, currentIndex: number): R
 - Parameters
 - previousValue: R
 - currentValue: T
 - currentIndex: number
 Returns R
- Optional seed: never[]
Returns AsyncIterableX<R>
- Defined in add/asynciterable-operators/scan.ts:9
Type parameters
- T
- R
Parameters
- this: AsyncIterableX<T>
- accumulator: function
 - - (previousValue: R, currentValue: T, currentIndex: number): R
 - Parameters
 - previousValue: R
 - currentValue: T
 - currentIndex: number
 Returns R
- Optional seed: R
Returns AsyncIterableX<R>

scanRight

scanRight<T, R>(source: AsyncIterable<T>, accumulator: function, seed?: never[]): AsyncIterableX<R>
scanRight<T, R>(source: AsyncIterable<T>, accumulator: function, seed?: R): AsyncIterableX<R>
scanRight<T, R>(source: Iterable<T>, accumulator: function, seed?: never[]): IterableX<R>
scanRight<T, R>(source: Iterable<T>, accumulator: function, seed?: R): IterableX<R>
scanRight<T, R>(accumulator: function, seed?: never[]): OperatorFunction<T, R>
scanRight<T, R>(accumulator: function, seed?: R): OperatorFunction<T, R>
scanRight<T, R>(accumulator: function, seed?: never[]): OperatorAsyncFunction<T, R>
scanRight<T, R>(accumulator: function, seed?: R): OperatorAsyncFunction<T, R>

- Defined in asynciterable/scanright.ts:39
Type parameters
- T
- R
Parameters
- source: AsyncIterable<T>
- accumulator: function
 - - (previousValue: R, currentValue: T, currentIndex: number): R | Promise<R>
 - Parameters
 - previousValue: R
 - currentValue: T
 - currentIndex: number
 Returns R | Promise<R>
- Optional seed: never[]
Returns AsyncIterableX<R>
- Defined in asynciterable/scanright.ts:44
Type parameters
- T
- R
Parameters
- source: AsyncIterable<T>
- accumulator: function
 - - (previousValue: R, currentValue: T, currentIndex: number): R | Promise<R>
 - Parameters
 - previousValue: R
 - currentValue: T
 - currentIndex: number
 Returns R | Promise<R>
- Optional seed: R
Returns AsyncIterableX<R>
- Defined in iterable/scanright.ts:35
Type parameters
- T
- R
Parameters
- source: Iterable<T>
- accumulator: function
 - - (previousValue: R, currentValue: T, currentIndex: number): R
 - Parameters
 - previousValue: R
 - currentValue: T
 - currentIndex: number
 Returns R
- Optional seed: never[]
Returns IterableX<R>
- Defined in iterable/scanright.ts:40
Type parameters
- T
- R
Parameters
- source: Iterable<T>
- accumulator: function
 - - (previousValue: R, currentValue: T, currentIndex: number): R
 - Parameters
 - previousValue: R
 - currentValue: T
 - currentIndex: number
 Returns R
- Optional seed: R
Returns IterableX<R>
- Defined in iterable/pipe/scanright.ts:5
Type parameters
- T
- R
Parameters
- accumulator: function
 - - (previousValue: R, currentValue: T, currentIndex: number): R
 - Parameters
 - previousValue: R
 - currentValue: T
 - currentIndex: number
 Returns R
- Optional seed: never[]
Returns OperatorFunction<T, R>
- Defined in iterable/pipe/scanright.ts:9
Type parameters
- T
- R
Parameters
- accumulator: function
 - - (previousValue: R, currentValue: T, currentIndex: number): R
 - Parameters
 - previousValue: R
 - currentValue: T
 - currentIndex: number
 Returns R
- Optional seed: R
Returns OperatorFunction<T, R>
- Defined in asynciterable/pipe/scanright.ts:5
Type parameters
- T
- R
Parameters
- accumulator: function
 - - (previousValue: R, currentValue: T, currentIndex: number): R | Promise<R>
 - Parameters
 - previousValue: R
 - currentValue: T
 - currentIndex: number
 Returns R | Promise<R>
- Optional seed: never[]
Returns OperatorAsyncFunction<T, R>
- Defined in asynciterable/pipe/scanright.ts:9
Type parameters
- T
- R
Parameters
- accumulator: function
 - - (previousValue: R, currentValue: T, currentIndex: number): R | Promise<R>
 - Parameters
 - previousValue: R
 - currentValue: T
 - currentIndex: number
 Returns R | Promise<R>
- Optional seed: R
Returns OperatorAsyncFunction<T, R>

scanRightProto

scanRightProto<T, R>(this: IterableX<T>, accumulator: function, seed?: never[]): IterableX<R>
scanRightProto<T, R>(this: IterableX<T>, accumulator: function, seed?: R): IterableX<R>
scanRightProto<T, R>(this: AsyncIterableX<T>, accumulator: function, seed?: never[]): AsyncIterableX<R>
scanRightProto<T, R>(this: AsyncIterableX<T>, accumulator: function, seed?: R): AsyncIterableX<R>

- Defined in add/iterable-operators/scanright.ts:4
Type parameters
- T
- R
Parameters
- this: IterableX<T>
- accumulator: function
 - - (previousValue: R, currentValue: T, currentIndex: number): R
 - Parameters
 - previousValue: R
 - currentValue: T
 - currentIndex: number
 Returns R
- Optional seed: never[]
Returns IterableX<R>
- Defined in add/iterable-operators/scanright.ts:9
Type parameters
- T
- R
Parameters
- this: IterableX<T>
- accumulator: function
 - - (previousValue: R, currentValue: T, currentIndex: number): R
 - Parameters
 - previousValue: R
 - currentValue: T
 - currentIndex: number
 Returns R
- Optional seed: R
Returns IterableX<R>
- Defined in add/asynciterable-operators/scanright.ts:4
Type parameters
- T
- R
Parameters
- this: AsyncIterableX<T>
- accumulator: function
 - - (previousValue: R, currentValue: T, currentIndex: number): R
 - Parameters
 - previousValue: R
 - currentValue: T
 - currentIndex: number
 Returns R
- Optional seed: never[]
Returns AsyncIterableX<R>
- Defined in add/asynciterable-operators/scanright.ts:9
Type parameters
- T
- R
Parameters
- this: AsyncIterableX<T>
- accumulator: function
 - - (previousValue: R, currentValue: T, currentIndex: number): R
 - Parameters
 - previousValue: R
 - currentValue: T
 - currentIndex: number
 Returns R
- Optional seed: R
Returns AsyncIterableX<R>

sequenceEqual

sequenceEqual<T>(source: AsyncIterable<T>, other: AsyncIterable<T>, comparer?: function): Promise<boolean>

- Defined in asynciterable/sequenceequal.ts:3
Type parameters
- T
Parameters
- source: AsyncIterable<T>
- other: AsyncIterable<T>
- Default value comparer: function = comparerAsync
 - - (first: T, second: T): boolean | Promise<boolean>
 - Parameters
 - first: T
 - second: T
 Returns boolean | Promise<boolean>
Returns Promise<boolean>

sequenceEqualProto

sequenceEqualProto<T>(this: IterableX<T>, other: Iterable<T>, cmp?: function): boolean

- Defined in add/iterable-operators/sequenceequal.ts:7
ignore

Type parameters
- T
Parameters
- this: IterableX<T>
- other: Iterable<T>
- Default value cmp: function = (x, y) => x === y
 - - (first: T, second: T): boolean
 - Parameters
 - first: T
 - second: T
 Returns boolean
Returns boolean

share<TSource>(source: AsyncIterable<TSource>): AsyncIterableX<TSource>
share<TSource, TResult>(source: AsyncIterable<TSource>, selector?: undefined | function): AsyncIterableX<TResult>
share<TSource>(source: Iterable<TSource>): IterableX<TSource>
share<TSource, TResult>(source: Iterable<TSource>, fn?: undefined | function): IterableX<TResult>
share<TSource>(): OperatorFunction<TSource, TSource>
share<TSource, TResult>(selector?: undefined | function): OperatorFunction<TSource, TResult>
share<TSource>(): OperatorAsyncFunction<TSource, TSource>
share<TSource, TResult>(selector?: undefined | function): OperatorAsyncFunction<TSource, TResult>

- Defined in asynciterable/share.ts:17
Type parameters
- TSource
Parameters
- source: AsyncIterable<TSource>
Returns AsyncIterableX<TSource>
- Defined in asynciterable/share.ts:18
Type parameters
- TSource
- TResult
Parameters
- source: AsyncIterable<TSource>
- Optional selector: undefined | function
Returns AsyncIterableX<TResult>
- Defined in iterable/share.ts:17
Type parameters
- TSource
Parameters
- source: Iterable<TSource>
Returns IterableX<TSource>
- Defined in iterable/share.ts:18
Type parameters
- TSource
- TResult
Parameters
- source: Iterable<TSource>
- Optional fn: undefined | function
Returns IterableX<TResult>
- Defined in iterable/pipe/share.ts:5
Type parameters
- TSource
Returns OperatorFunction<TSource, TSource>
- Defined in iterable/pipe/share.ts:6
Type parameters
- TSource
- TResult
Parameters
- Optional selector: undefined | function
Returns OperatorFunction<TSource, TResult>
- Defined in asynciterable/pipe/share.ts:5
Type parameters
- TSource
Returns OperatorAsyncFunction<TSource, TSource>
- Defined in asynciterable/pipe/share.ts:6
Type parameters
- TSource
- TResult
Parameters
- Optional selector: undefined | function
Returns OperatorAsyncFunction<TSource, TResult>

shareProto

shareProto<TSource>(this: IterableX<TSource>): IterableX<TSource>
shareProto<TSource, TResult>(this: IterableX<TSource>, fn?: undefined | function): IterableX<TResult>
shareProto<TSource>(this: AsyncIterableX<TSource>): AsyncIterableX<TSource>
shareProto<TSource, TResult>(this: AsyncIterableX<TSource>, selector?: undefined | function): AsyncIterableX<TResult>

- Defined in add/iterable-operators/share.ts:4
Type parameters
- TSource
Parameters
- this: IterableX<TSource>
Returns IterableX<TSource>
- Defined in add/iterable-operators/share.ts:5
Type parameters
- TSource
- TResult
Parameters
- this: IterableX<TSource>
- Optional fn: undefined | function
Returns IterableX<TResult>
- Defined in add/asynciterable-operators/share.ts:4
Type parameters
- TSource
Parameters
- this: AsyncIterableX<TSource>
Returns AsyncIterableX<TSource>
- Defined in add/asynciterable-operators/share.ts:5
Type parameters
- TSource
- TResult
Parameters
- this: AsyncIterableX<TSource>
- Optional selector: undefined | function
Returns AsyncIterableX<TResult>

single

single<T, S>(source: AsyncIterable<T>, predicate: function): Promise<S | undefined>
single<T>(source: AsyncIterable<T>, predicate?: undefined | function): Promise<T | undefined>
single<T, S>(source: Iterable<T>, predicate: function): S | undefined
single<T>(source: Iterable<T>, predicate?: undefined | function): T | undefined

- Defined in asynciterable/single.ts:1
Type parameters
- T
- S: T
Parameters
- source: AsyncIterable<T>
- predicate: function
 - - (value: T, index: number): boolean
 - Parameters
 - value: T
 - index: number
 Returns boolean
Returns Promise<S | undefined>
- Defined in asynciterable/single.ts:5
Type parameters
- T
Parameters
- source: AsyncIterable<T>
- Optional predicate: undefined | function
Returns Promise<T | undefined>
- Defined in iterable/single.ts:1
Type parameters
- T
- S: T
Parameters
- source: Iterable<T>
- predicate: function
 - - (value: T, index: number): boolean
 - Parameters
 - value: T
 - index: number
 Returns boolean
Returns S | undefined
- Defined in iterable/single.ts:5
Type parameters
- T
Parameters
- source: Iterable<T>
- Optional predicate: undefined | function
Returns T | undefined

singleProto

singleProto<T, S>(this: IterableX<T>, predicate: function): S | undefined
singleProto<T>(this: IterableX<T>, predicate?: undefined | function): T | undefined
singleProto<T, S>(this: AsyncIterableX<T>, predicate: function): Promise<S | undefined>
singleProto<T>(this: AsyncIterableX<T>, predicate?: undefined | function): Promise<T | undefined>

- Defined in add/iterable-operators/single.ts:7
ignore

Type parameters
- T
- S: T
Parameters
- this: IterableX<T>
- predicate: function
 - - (value: T, index: number): boolean
 - Parameters
 - value: T
 - index: number
 Returns boolean
Returns S | undefined
- Defined in add/iterable-operators/single.ts:11
Type parameters
- T
Parameters
- this: IterableX<T>
- Optional predicate: undefined | function
Returns T | undefined
- Defined in add/asynciterable-operators/single.ts:8
ignore

Type parameters
- T
- S: T
Parameters
- this: AsyncIterableX<T>
- predicate: function
 - - (value: T, index: number): boolean
 - Parameters
 - value: T
 - index: number
 Returns boolean
Returns Promise<S | undefined>
- Defined in add/asynciterable-operators/single.ts:12
Type parameters
- T
Parameters
- this: AsyncIterableX<T>
- Optional predicate: undefined | function
Returns Promise<T | undefined>

skip

skip<TSource>(source: AsyncIterable<TSource>, count: number): AsyncIterableX<TSource>

- Defined in asynciterable/skip.ts:28
Type parameters
- TSource
Parameters
- source: AsyncIterable<TSource>
- count: number
Returns AsyncIterableX<TSource>

skipLast

skipLast<TSource>(source: AsyncIterable<TSource>, count: number): AsyncIterableX<TSource>

- Defined in asynciterable/skiplast.ts:24
Type parameters
- TSource
Parameters
- source: AsyncIterable<TSource>
- count: number
Returns AsyncIterableX<TSource>

skipLastProto

skipLastProto<T>(this: IterableX<T>, count: number): IterableX<T>

- Defined in add/iterable-operators/skiplast.ts:7
ignore

Type parameters
- T
Parameters
- this: IterableX<T>
- count: number
Returns IterableX<T>

skipProto

skipProto<T>(this: IterableX<T>, count: number): IterableX<T>

- Defined in add/iterable-operators/skip.ts:7
ignore

Type parameters
- T
Parameters
- this: IterableX<T>
- count: number
Returns IterableX<T>

skipUntil

skipUntil<TSource>(source: AsyncIterable<TSource>, other: function): AsyncIterableX<TSource>

- Defined in asynciterable/skipuntil.ts:24
Type parameters
- TSource
Parameters
- source: AsyncIterable<TSource>
- other: function
 - - (): Promise<any>
 - Returns Promise<any>
Returns AsyncIterableX<TSource>

skipUntilProto

skipUntilProto<TSource>(this: AsyncIterableX<TSource>, other: function): AsyncIterableX<TSource>

- Defined in add/asynciterable-operators/skipuntil.ts:7
ignore

Type parameters
- TSource
Parameters
- this: AsyncIterableX<TSource>
- other: function
 - - (): Promise<any>
 - Returns Promise<any>
Returns AsyncIterableX<TSource>

skipWhile

skipWhile<T, S>(source: AsyncIterable<T>, predicate: function): AsyncIterableX<S>
skipWhile<T>(source: AsyncIterable<T>, predicate: function): AsyncIterableX<T>
skipWhile<T, S>(source: Iterable<T>, predicate: function): IterableX<S>
skipWhile<TSource>(source: Iterable<TSource>, predicate: function): IterableX<TSource>
skipWhile<T, S>(predicate: function): OperatorFunction<T, S>
skipWhile<T>(predicate: function): OperatorFunction<T, T>
skipWhile<T, S>(predicate: function): OperatorAsyncFunction<T, S>
skipWhile<T>(predicate: function): OperatorAsyncFunction<T, T>

- Defined in asynciterable/skipwhile.ts:30
Type parameters
- T
- S: T
Parameters
- source: AsyncIterable<T>
- predicate: function
 - - (value: T, index: number): boolean
 - Parameters
 - value: T
 - index: number
 Returns boolean
Returns AsyncIterableX<S>
- Defined in asynciterable/skipwhile.ts:34
Type parameters
- T
Parameters
- source: AsyncIterable<T>
- predicate: function
 - - (value: T, index: number): boolean | Promise<boolean>
 - Parameters
 - value: T
 - index: number
 Returns boolean | Promise<boolean>
Returns AsyncIterableX<T>
- Defined in iterable/skipwhile.ts:27
Type parameters
- T
- S: T
Parameters
- source: Iterable<T>
- predicate: function
 - - (value: T, index: number): boolean
 - Parameters
 - value: T
 - index: number
 Returns boolean
Returns IterableX<S>
- Defined in iterable/skipwhile.ts:31
Type parameters
- TSource
Parameters
- source: Iterable<TSource>
- predicate: function
 - - (value: TSource, index: number): boolean
 - Parameters
 - value: TSource
 - index: number
 Returns boolean
Returns IterableX<TSource>
- Defined in iterable/pipe/skipwhile.ts:5
Type parameters
- T
- S: T
Parameters
- predicate: function
 - - (value: T, index: number): boolean
 - Parameters
 - value: T
 - index: number
 Returns boolean
Returns OperatorFunction<T, S>
- Defined in iterable/pipe/skipwhile.ts:8
Type parameters
- T
Parameters
- predicate: function
 - - (value: T, index: number): boolean
 - Parameters
 - value: T
 - index: number
 Returns boolean
Returns OperatorFunction<T, T>
- Defined in asynciterable/pipe/skipwhile.ts:5
Type parameters
- T
- S: T
Parameters
- predicate: function
 - - (value: T, index: number): boolean
 - Parameters
 - value: T
 - index: number
 Returns boolean
Returns OperatorAsyncFunction<T, S>
- Defined in asynciterable/pipe/skipwhile.ts:8
Type parameters
- T
Parameters
- predicate: function
 - - (value: T, index: number): boolean | Promise<boolean>
 - Parameters
 - value: T
 - index: number
 Returns boolean | Promise<boolean>
Returns OperatorAsyncFunction<T, T>

skipWhileProto

skipWhileProto<T, S>(this: IterableX<T>, predicate: function): IterableX<S>
skipWhileProto<TSource>(this: IterableX<TSource>, predicate: function): IterableX<TSource>
skipWhileProto<T, S>(this: AsyncIterableX<T>, predicate: function): AsyncIterableX<S>
skipWhileProto<T>(this: AsyncIterableX<T>, predicate: function): AsyncIterableX<T>

- Defined in add/iterable-operators/skipwhile.ts:7
ignore

Type parameters
- T
- S: T
Parameters
- this: IterableX<T>
- predicate: function
 - - (value: T, index: number): boolean
 - Parameters
 - value: T
 - index: number
 Returns boolean
Returns IterableX<S>
- Defined in add/iterable-operators/skipwhile.ts:11
Type parameters
- TSource
Parameters
- this: IterableX<TSource>
- predicate: function
 - - (value: TSource, index: number): boolean
 - Parameters
 - value: TSource
 - index: number
 Returns boolean
Returns IterableX<TSource>
- Defined in add/asynciterable-operators/skipwhile.ts:8
ignore

Type parameters
- T
- S: T
Parameters
- this: AsyncIterableX<T>
- predicate: function
 - - (value: T, index: number): boolean
 - Parameters
 - value: T
 - index: number
 Returns boolean
Returns AsyncIterableX<S>
- Defined in add/asynciterable-operators/skipwhile.ts:12
Type parameters
- T
Parameters
- this: AsyncIterableX<T>
- predicate: function
 - - (value: T, index: number): boolean | Promise<boolean>
 - Parameters
 - value: T
 - index: number
 Returns boolean | Promise<boolean>
Returns AsyncIterableX<T>

sleep

sleep(dueTime: number): Promise<void>

- Defined in asynciterable/_sleep.ts:1
Parameters
- dueTime: number
Returns Promise<void>

slice

slice<TSource>(source: AsyncIterable<TSource>, begin: number, end?: number): AsyncIterableX<TSource>

- Defined in asynciterable/slice.ts:35
Type parameters
- TSource
Parameters
- source: AsyncIterable<TSource>
- begin: number
- Default value end: number = Infinity
Returns AsyncIterableX<TSource>

sliceProto

sliceProto<T>(this: IterableX<T>, begin: number, end: number): IterableX<T>

- Defined in add/iterable-operators/slice.ts:7
ignore

Type parameters
- T
Parameters
- this: IterableX<T>
- begin: number
- end: number
Returns IterableX<T>

some

some<T, S>(source: AsyncIterable<T>, predicate: function): Promise<boolean>
some<T>(source: AsyncIterable<T>, predicate: function): Promise<boolean>
some<T, S>(source: Iterable<T>, comparer: function): boolean
some<T>(source: Iterable<T>, comparer: function): boolean

- Defined in asynciterable/some.ts:1
Type parameters
- T
- S: T
Parameters
- source: AsyncIterable<T>
- predicate: function
 - - (value: T, index: number): boolean
 - Parameters
 - value: T
 - index: number
 Returns boolean
Returns Promise<boolean>
- Defined in asynciterable/some.ts:5
Type parameters
- T
Parameters
- source: AsyncIterable<T>
- predicate: function
 - - (value: T, index: number): boolean | Promise<boolean>
 - Parameters
 - value: T
 - index: number
 Returns boolean | Promise<boolean>
Returns Promise<boolean>
- Defined in iterable/some.ts:1
Type parameters
- T
- S: T
Parameters
- source: Iterable<T>
- comparer: function
 - - (value: T, index: number): boolean
 - Parameters
 - value: T
 - index: number
 Returns boolean
Returns boolean
- Defined in iterable/some.ts:5
Type parameters
- T
Parameters
- source: Iterable<T>
- comparer: function
 - - (value: T, index: number): boolean
 - Parameters
 - value: T
 - index: number
 Returns boolean
Returns boolean

someProto

someProto<T, S>(this: IterableX<T>, comparer: function): boolean
someProto<T>(this: IterableX<T>, comparer: function): boolean
someProto<T, S>(this: AsyncIterableX<T>, predicate: function): Promise<boolean>
someProto<T>(this: AsyncIterableX<T>, predicate: function): Promise<boolean>

- Defined in add/iterable-operators/some.ts:7
ignore

Type parameters
- T
- S: T
Parameters
- this: IterableX<T>
- comparer: function
 - - (value: T, index: number): boolean
 - Parameters
 - value: T
 - index: number
 Returns boolean
Returns boolean
- Defined in add/iterable-operators/some.ts:11
Type parameters
- T
Parameters
- this: IterableX<T>
- comparer: function
 - - (value: T, index: number): boolean
 - Parameters
 - value: T
 - index: number
 Returns boolean
Returns boolean
- Defined in add/asynciterable-operators/some.ts:8
ignore

Type parameters
- T
- S: T
Parameters
- this: AsyncIterableX<T>
- predicate: function
 - - (value: T, index: number): boolean
 - Parameters
 - value: T
 - index: number
 Returns boolean
Returns Promise<boolean>
- Defined in add/asynciterable-operators/some.ts:12
Type parameters
- T
Parameters
- this: AsyncIterableX<T>
- predicate: function
 - - (value: T, index: number): boolean | Promise<boolean>
 - Parameters
 - value: T
 - index: number
 Returns boolean | Promise<boolean>
Returns Promise<boolean>

sorter

sorter<TElement>(fst: TElement, snd: TElement): number

- Defined in internal/sorter.ts:4
ignore

Type parameters
- TElement
Parameters
- fst: TElement
- snd: TElement
Returns number

startWith

startWith<TSource>(source: AsyncIterable<TSource>, ...args: TSource[]): AsyncIterableX<TSource>

- Defined in asynciterable/startwith.ts:23
Type parameters
- TSource
Parameters
- source: AsyncIterable<TSource>
- Rest ...args: TSource[]
Returns AsyncIterableX<TSource>

startWithProto

startWithProto<T>(this: IterableX<T>, ...args: T[]): IterableX<T>

- Defined in add/iterable-operators/startwith.ts:7
ignore

Type parameters
- T
Parameters
- this: IterableX<T>
- Rest ...args: T[]
Returns IterableX<T>

sum

sum(source: AsyncIterable<number>, selector?: undefined | function): Promise<number>
sum<T>(source: AsyncIterable<T>, selector: function): Promise<number>
sum(source: Iterable<number>, fn?: undefined | function): number
sum<T>(source: Iterable<T>, fn: function): number

- Defined in asynciterable/sum.ts:3
Parameters
- source: AsyncIterable<number>
- Optional selector: undefined | function
Returns Promise<number>
- Defined in asynciterable/sum.ts:7
Type parameters
- T
Parameters
- source: AsyncIterable<T>
- selector: function
 - - (x: T): number | Promise<number>
 - Parameters
 - x: T
 Returns number | Promise<number>
Returns Promise<number>
- Defined in iterable/sum.ts:3
Parameters
- source: Iterable<number>
- Optional fn: undefined | function
Returns number
- Defined in iterable/sum.ts:4
Type parameters
- T
Parameters
- source: Iterable<T>
- fn: function
 - - (x: T): number
 - Parameters
 - x: T
 Returns number
Returns number

sumProto

sumProto(this: IterableX<number>, fn?: undefined | function): number
sumProto<T>(this: IterableX<T>, fn: function): number
sumProto(this: AsyncIterableX<number>, selector?: undefined | function): Promise<number>
sumProto<T>(this: AsyncIterableX<T>, selector: function): Promise<number>

- Defined in add/iterable-operators/sum.ts:4
Parameters
- this: IterableX<number>
- Optional fn: undefined | function
Returns number
- Defined in add/iterable-operators/sum.ts:5
Type parameters
- T
Parameters
- this: IterableX<T>
- fn: function
 - - (x: T): number
 - Parameters
 - x: T
 Returns number
Returns number
- Defined in add/asynciterable-operators/sum.ts:5
Parameters
- this: AsyncIterableX<number>
- Optional selector: undefined | function
Returns Promise<number>
- Defined in add/asynciterable-operators/sum.ts:9
Type parameters
- T
Parameters
- this: AsyncIterableX<T>
- selector: function
 - - (x: T): number | Promise<number>
 - Parameters
 - x: T
 Returns number | Promise<number>
Returns Promise<number>

take

take<TSource>(source: AsyncIterable<TSource>, count: number): AsyncIterableX<TSource>

- Defined in asynciterable/take.ts:26
Type parameters
- TSource
Parameters
- source: AsyncIterable<TSource>
- count: number
Returns AsyncIterableX<TSource>

takeLast

takeLast<TSource>(source: AsyncIterable<TSource>, count: number): AsyncIterableX<TSource>

- Defined in asynciterable/takelast.ts:30
Type parameters
- TSource
Parameters
- source: AsyncIterable<TSource>
- count: number
Returns AsyncIterableX<TSource>

takeLastProto

takeLastProto<T>(this: IterableX<T>, count: number): IterableX<T>

- Defined in add/iterable-operators/takelast.ts:7
ignore

Type parameters
- T
Parameters
- this: IterableX<T>
- count: number
Returns IterableX<T>

takeProto

takeProto<T>(this: IterableX<T>, count: number): IterableX<T>

- Defined in add/iterable-operators/take.ts:7
ignore

Type parameters
- T
Parameters
- this: IterableX<T>
- count: number
Returns IterableX<T>

takeUntil

takeUntil<TSource>(source: AsyncIterable<TSource>, other: function): AsyncIterableX<TSource>

- Defined in asynciterable/takeuntil.ts:25
Type parameters
- TSource
Parameters
- source: AsyncIterable<TSource>
- other: function
 - - (): Promise<any>
 - Returns Promise<any>
Returns AsyncIterableX<TSource>

takeUntilProto

takeUntilProto<TSource>(this: AsyncIterableX<TSource>, other: function): AsyncIterableX<TSource>

- Defined in add/asynciterable-operators/takeuntil.ts:7
ignore

Type parameters
- TSource
Parameters
- this: AsyncIterableX<TSource>
- other: function
 - - (): Promise<any>
 - Returns Promise<any>
Returns AsyncIterableX<TSource>

takeWhile

takeWhile<T, S>(source: AsyncIterable<T>, predicate: function): AsyncIterableX<S>
takeWhile<T>(source: AsyncIterable<T>, predicate: function): AsyncIterableX<T>
takeWhile<T, S>(source: Iterable<T>, predicate: function): IterableX<S>
takeWhile<TSource>(source: Iterable<TSource>, predicate: function): IterableX<TSource>
takeWhile<T, S>(predicate: function): OperatorFunction<T, S>
takeWhile<T>(predicate: function): OperatorFunction<T, T>
takeWhile<T, S>(predicate: function): OperatorAsyncFunction<T, S>
takeWhile<T>(predicate: function): OperatorAsyncFunction<T, T>

- Defined in asynciterable/takewhile.ts:27
Type parameters
- T
- S: T
Parameters
- source: AsyncIterable<T>
- predicate: function
 - - (value: T, index: number): boolean
 - Parameters
 - value: T
 - index: number
 Returns boolean
Returns AsyncIterableX<S>
- Defined in asynciterable/takewhile.ts:31
Type parameters
- T
Parameters
- source: AsyncIterable<T>
- predicate: function
 - - (value: T, index: number): boolean | Promise<boolean>
 - Parameters
 - value: T
 - index: number
 Returns boolean | Promise<boolean>
Returns AsyncIterableX<T>
- Defined in iterable/takewhile.ts:24
Type parameters
- T
- S: T
Parameters
- source: Iterable<T>
- predicate: function
 - - (value: T, index: number): boolean
 - Parameters
 - value: T
 - index: number
 Returns boolean
Returns IterableX<S>
- Defined in iterable/takewhile.ts:28
Type parameters
- TSource
Parameters
- source: Iterable<TSource>
- predicate: function
 - - (value: TSource, index: number): boolean
 - Parameters
 - value: TSource
 - index: number
 Returns boolean
Returns IterableX<TSource>
- Defined in iterable/pipe/takewhile.ts:5
Type parameters
- T
- S: T
Parameters
- predicate: function
 - - (value: T, index: number): boolean
 - Parameters
 - value: T
 - index: number
 Returns boolean
Returns OperatorFunction<T, S>
- Defined in iterable/pipe/takewhile.ts:8
Type parameters
- T
Parameters
- predicate: function
 - - (value: T, index: number): boolean
 - Parameters
 - value: T
 - index: number
 Returns boolean
Returns OperatorFunction<T, T>
- Defined in asynciterable/pipe/takewhile.ts:5
Type parameters
- T
- S: T
Parameters
- predicate: function
 - - (value: T, index: number): boolean
 - Parameters
 - value: T
 - index: number
 Returns boolean
Returns OperatorAsyncFunction<T, S>
- Defined in asynciterable/pipe/takewhile.ts:8
Type parameters
- T
Parameters
- predicate: function
 - - (value: T, index: number): boolean | Promise<boolean>
 - Parameters
 - value: T
 - index: number
 Returns boolean | Promise<boolean>
Returns OperatorAsyncFunction<T, T>

takeWhileProto

takeWhileProto<T, S>(this: IterableX<T>, predicate: function): IterableX<S>
takeWhileProto<TSource>(this: IterableX<TSource>, predicate: function): IterableX<TSource>
takeWhileProto<T, S>(this: AsyncIterableX<T>, predicate: function): AsyncIterableX<S>
takeWhileProto<T>(this: AsyncIterableX<T>, predicate: function): AsyncIterableX<T>

- Defined in add/iterable-operators/takewhile.ts:7
ignore

Type parameters
- T
- S: T
Parameters
- this: IterableX<T>
- predicate: function
 - - (value: T, index: number): boolean
 - Parameters
 - value: T
 - index: number
 Returns boolean
Returns IterableX<S>
- Defined in add/iterable-operators/takewhile.ts:11
Type parameters
- TSource
Parameters
- this: IterableX<TSource>
- predicate: function
 - - (value: TSource, index: number): boolean
 - Parameters
 - value: TSource
 - index: number
 Returns boolean
Returns IterableX<TSource>
- Defined in add/asynciterable-operators/takewhile.ts:8
ignore

Type parameters
- T
- S: T
Parameters
- this: AsyncIterableX<T>
- predicate: function
 - - (value: T, index: number): boolean
 - Parameters
 - value: T
 - index: number
 Returns boolean
Returns AsyncIterableX<S>
- Defined in add/asynciterable-operators/takewhile.ts:12
Type parameters
- T
Parameters
- this: AsyncIterableX<T>
- predicate: function
 - - (value: T, index: number): boolean | Promise<boolean>
 - Parameters
 - value: T
 - index: number
 Returns boolean | Promise<boolean>
Returns AsyncIterableX<T>

tap

tap<TSource>(source: AsyncIterable<TSource>, observer: PartialAsyncObserver<TSource>): AsyncIterableX<TSource>

- Defined in asynciterable/tap.ts:42
Lazily invokes observer methods for each value in the sequence, and upon successful or exceptional termination.

Type parameters
- TSource
Parameters
- source: AsyncIterable<TSource>
 
 Source sequence.
- observer: PartialAsyncObserver<TSource>
 
 Observer to invoke notification calls on.<
Returns AsyncIterableX<TSource>

Sequence exhibiting the side-effects of observer method invocation upon iteration.

tapProto

tapProto<T>(this: IterableX<T>, observer: PartialObserver<T>): IterableX<T>

- Defined in add/iterable-operators/tap.ts:8
ignore

Type parameters
- T
Parameters
- this: IterableX<T>
- observer: PartialObserver<T>
Returns IterableX<T>

thenBy

thenBy<TKey, TSource>(source: OrderedAsyncIterableBaseX<TSource>, keySelector: function, comparer?: function): OrderedAsyncIterableX<TKey, TSource>

- Defined in asynciterable/orderby.ts:118
Type parameters
- TKey
- TSource
Parameters
- source: OrderedAsyncIterableBaseX<TSource>
- keySelector: function
 - - (item: TSource): TKey
 - Parameters
 - item: TSource
 Returns TKey
- Default value comparer: function = defaultSorter
 - - (fst: TKey, snd: TKey): number
 - Parameters
 - fst: TKey
 - snd: TKey
 Returns number
Returns OrderedAsyncIterableX<TKey, TSource>

thenByDescending

thenByDescending<TKey, TSource>(source: OrderedAsyncIterableBaseX<TSource>, keySelector: function, comparer?: function): OrderedAsyncIterableX<TKey, TSource>

- Defined in asynciterable/orderby.ts:132
Type parameters
- TKey
- TSource
Parameters
- source: OrderedAsyncIterableBaseX<TSource>
- keySelector: function
 - - (item: TSource): TKey
 - Parameters
 - item: TSource
 Returns TKey
- Default value comparer: function = defaultSorter
 - - (fst: TKey, snd: TKey): number
 - Parameters
 - fst: TKey
 - snd: TKey
 Returns number
Returns OrderedAsyncIterableX<TKey, TSource>

throttle

throttle<TSource>(source: AsyncIterable<TSource>, time: number): AsyncIterableX<TSource>

- Defined in asynciterable/throttle.ts:25
Type parameters
- TSource
Parameters
- source: AsyncIterable<TSource>
- time: number
Returns AsyncIterableX<TSource>

throttleProto

throttleProto<T>(this: AsyncIterableX<T>, time: number): AsyncIterableX<T>

- Defined in add/asynciterable-operators/throttle.ts:7
ignore

Type parameters
- T
Parameters
- this: AsyncIterableX<T>
- time: number
Returns AsyncIterableX<T>

timeInterval

timeInterval<TSource>(source: AsyncIterable<TSource>): AsyncIterableX<TimeInterval<TSource>>

- Defined in asynciterable/timeinterval.ts:27
Type parameters
- TSource
Parameters
- source: AsyncIterable<TSource>
Returns AsyncIterableX<TimeInterval<TSource>>

timeout

timeout<TSource>(source: AsyncIterable<TSource>, dueTime: number): AsyncIterableX<TSource>

- Defined in asynciterable/timeout.ts:54
Type parameters
- TSource
Parameters
- source: AsyncIterable<TSource>
- dueTime: number
Returns AsyncIterableX<TSource>

timestamp

timestamp<TSource>(source: AsyncIterable<TSource>): AsyncIterableX<Timestamp<TSource>>

- Defined in asynciterable/timestamp.ts:23
Type parameters
- TSource
Parameters
- source: AsyncIterable<TSource>
Returns AsyncIterableX<Timestamp<TSource>>

toArray

toArray<TSource>(source: AsyncIterable<TSource>): Promise<TSource[]>

- Defined in asynciterable/toarray.ts:1
Type parameters
- TSource
Parameters
- source: AsyncIterable<TSource>
Returns Promise<TSource[]>

toArrayProto

toArrayProto<TSource>(this: IterableX<TSource>): TSource[]

- Defined in add/iterable-operators/toarray.ts:7
ignore

Type parameters
- TSource
Parameters
- this: IterableX<TSource>
Returns TSource[]

toInteger

toInteger(value: any): number

- Defined in internal/tointeger.ts:4
ignore

Parameters
- value: any
Returns number

toLength

toLength(value: any): number

- Defined in internal/tolength.ts:7
ignore

Parameters
- value: any
Returns number

toMap

toMap<TSource, TKey>(source: AsyncIterable<TSource>, keySelector: function): Promise<Map<TKey, TSource>>
toMap<TSource, TKey, TElement>(source: AsyncIterable<TSource>, keySelector: function, elementSelector?: undefined | function): Promise<Map<TKey, TElement>>
toMap<TSource, TKey>(source: Iterable<TSource>, keySelector: function): Map<TKey, TSource>
toMap<TSource, TKey, TElement>(source: Iterable<TSource>, keySelector: function, elementSelector?: undefined | function): Map<TKey, TElement>

- Defined in asynciterable/tomap.ts:3
Type parameters
- TSource
- TKey
Parameters
- source: AsyncIterable<TSource>
- keySelector: function
 - - (item: TSource): TKey | Promise<TKey>
 - Parameters
 - item: TSource
 Returns TKey | Promise<TKey>
Returns Promise<Map<TKey, TSource>>
- Defined in asynciterable/tomap.ts:7
Type parameters
- TSource
- TKey
- TElement
Parameters
- source: AsyncIterable<TSource>
- keySelector: function
 - - (item: TSource): TKey | Promise<TKey>
 - Parameters
 - item: TSource
 Returns TKey | Promise<TKey>
- Optional elementSelector: undefined | function
Returns Promise<Map<TKey, TElement>>
- Defined in iterable/tomap.ts:1
Type parameters
- TSource
- TKey
Parameters
- source: Iterable<TSource>
- keySelector: function
 - - (item: TSource): TKey
 - Parameters
 - item: TSource
 Returns TKey
Returns Map<TKey, TSource>
- Defined in iterable/tomap.ts:5
Type parameters
- TSource
- TKey
- TElement
Parameters
- source: Iterable<TSource>
- keySelector: function
 - - (item: TSource): TKey
 - Parameters
 - item: TSource
 Returns TKey
- Optional elementSelector: undefined | function
Returns Map<TKey, TElement>

toMapProto

toMapProto<TSource, TKey>(this: IterableX<TSource>, keySelector: function): Map<TKey, TSource>
toMapProto<TSource, TKey, TElement>(this: IterableX<TSource>, keySelector: function, elementSelector?: undefined | function): Map<TKey, TElement>
toMapProto<TSource, TKey>(this: AsyncIterableX<TSource>, keySelector: function): Promise<Map<TKey, TSource>>
toMapProto<TSource, TKey, TElement>(this: AsyncIterableX<TSource>, keySelector: function, elementSelector?: undefined | function): Promise<Map<TKey, TElement>>

- Defined in add/iterable-operators/tomap.ts:4
Type parameters
- TSource
- TKey
Parameters
- this: IterableX<TSource>
- keySelector: function
 - - (item: TSource): TKey
 - Parameters
 - item: TSource
 Returns TKey
Returns Map<TKey, TSource>
- Defined in add/iterable-operators/tomap.ts:8
Type parameters
- TSource
- TKey
- TElement
Parameters
- this: IterableX<TSource>
- keySelector: function
 - - (item: TSource): TKey
 - Parameters
 - item: TSource
 Returns TKey
- Optional elementSelector: undefined | function
Returns Map<TKey, TElement>
- Defined in add/asynciterable-operators/tomap.ts:4
Type parameters
- TSource
- TKey
Parameters
- this: AsyncIterableX<TSource>
- keySelector: function
 - - (item: TSource): TKey | Promise<TKey>
 - Parameters
 - item: TSource
 Returns TKey | Promise<TKey>
Returns Promise<Map<TKey, TSource>>
- Defined in add/asynciterable-operators/tomap.ts:8
Type parameters
- TSource
- TKey
- TElement
Parameters
- this: AsyncIterableX<TSource>
- keySelector: function
 - - (item: TSource): TKey | Promise<TKey>
 - Parameters
 - item: TSource
 Returns TKey | Promise<TKey>
- Optional elementSelector: undefined | function
Returns Promise<Map<TKey, TElement>>

toObservable

toObservable<TSource>(source: AsyncIterable<TSource>): Observable<TSource>

- Defined in asynciterable/toobservable.ts:48
Type parameters
- TSource
Parameters
- source: AsyncIterable<TSource>
Returns Observable<TSource>

toObservableProto

toObservableProto<TSource>(this: AsyncIterableX<TSource>): Observable<TSource>

- Defined in add/asynciterable-operators/toobservable.ts:8
ignore

Type parameters
- TSource
Parameters
- this: AsyncIterableX<TSource>
Returns Observable<TSource>

toSet

toSet<TSource>(source: AsyncIterable<TSource>): Promise<Set<TSource>>

- Defined in asynciterable/toset.ts:1
Type parameters
- TSource
Parameters
- source: AsyncIterable<TSource>
Returns Promise<Set<TSource>>

toSetProto

toSetProto<TSource>(this: IterableX<TSource>): Set<TSource>

- Defined in add/iterable-operators/toset.ts:7
ignore

Type parameters
- TSource
Parameters
- this: IterableX<TSource>
Returns Set<TSource>

union

union<TSource>(left: AsyncIterable<TSource>, right: AsyncIterable<TSource>, comparer?: function): AsyncIterableX<TSource>

- Defined in asynciterable/union.ts:39
Type parameters
- TSource
Parameters
- left: AsyncIterable<TSource>
- right: AsyncIterable<TSource>
- Default value comparer: function = comparerAsync
 - - (x: TSource, y: TSource): boolean | Promise<boolean>
 - Parameters
 - x: TSource
 - y: TSource
 Returns boolean | Promise<boolean>
Returns AsyncIterableX<TSource>

unionProto

unionProto<T>(this: IterableX<T>, right: Iterable<T>, comparer?: undefined | function): IterableX<T>

- Defined in add/iterable-operators/union.ts:7
ignore

Type parameters
- T
Parameters
- this: IterableX<T>
- right: Iterable<T>
- Optional comparer: undefined | function
Returns IterableX<T>

wrapPromiseWithIndex

wrapPromiseWithIndex<T>(promise: Promise<T>, index: number): Promise<object>

- Defined in asynciterable/combinelatest.ts:9
Type parameters
- T
Parameters
- promise: Promise<T>
- index: number
Returns Promise<object>

zip

zip<T, T2>(source: AsyncIterable<T>, source2: AsyncIterable<T2>): AsyncIterableX<[T, T2]>
zip<T, T2, T3>(source: AsyncIterable<T>, source2: AsyncIterable<T2>, source3: AsyncIterable<T3>): AsyncIterableX<[T, T2, T3]>
zip<T, T2, T3, T4>(source: AsyncIterable<T>, source2: AsyncIterable<T2>, source3: AsyncIterable<T3>, source4: AsyncIterable<T4>): AsyncIterableX<[T, T2, T3, T4]>
zip<T, T2, T3, T4, T5>(source: AsyncIterable<T>, source2: AsyncIterable<T2>, source3: AsyncIterable<T3>, source4: AsyncIterable<T4>, source5: AsyncIterable<T5>): AsyncIterableX<[T, T2, T3, T4, T5]>
zip<T, T2, T3, T4, T5, T6>(source: AsyncIterable<T>, source2: AsyncIterable<T2>, source3: AsyncIterable<T3>, source4: AsyncIterable<T4>, source5: AsyncIterable<T5>, source6: AsyncIterable<T6>): AsyncIterableX<[T, T2, T3, T4, T5, T6]>
zip<T, R>(project: function, source: AsyncIterable<T>): AsyncIterableX<R>
zip<T, T2, R>(project: function, source: AsyncIterable<T>, source2: AsyncIterable<T2>): AsyncIterableX<R>
zip<T, T2, T3, R>(project: function, source: AsyncIterable<T>, source2: AsyncIterable<T2>, source3: AsyncIterable<T3>): AsyncIterableX<R>
zip<T, T2, T3, T4, R>(project: function, source: AsyncIterable<T>, source2: AsyncIterable<T2>, source3: AsyncIterable<T3>, source4: AsyncIterable<T4>): AsyncIterableX<R>
zip<T, T2, T3, T4, T5, R>(project: function, source: AsyncIterable<T>, source2: AsyncIterable<T2>, source3: AsyncIterable<T3>, source4: AsyncIterable<T4>, source5: AsyncIterable<T5>): AsyncIterableX<R>
zip<T, T2, T3, T4, T5, T6, R>(project: function, source: AsyncIterable<T>, source2: AsyncIterable<T2>, source3: AsyncIterable<T3>, source4: AsyncIterable<T4>, source5: AsyncIterable<T5>, source6: AsyncIterable<T6>): AsyncIterableX<R>
zip<T>(...sources: AsyncIterable<T>[]): AsyncIterableX<T[]>
zip<T, R>(project: function, ...sources: AsyncIterable<T>[]): AsyncIterableX<R>
zip<T, T2>(source: Iterable<T>, source2: Iterable<T2>): IterableX<[T, T2]>
zip<T, T2, T3>(source: Iterable<T>, source2: Iterable<T2>, source3: Iterable<T3>): IterableX<[T, T2, T3]>
zip<T, T2, T3, T4>(source: Iterable<T>, source2: Iterable<T2>, source3: Iterable<T3>, source4: Iterable<T4>): IterableX<[T, T2, T3, T4]>
zip<T, T2, T3, T4, T5>(source: Iterable<T>, source2: Iterable<T2>, source3: Iterable<T3>, source4: Iterable<T4>, source5: Iterable<T5>): IterableX<[T, T2, T3, T4, T5]>
zip<T, T2, T3, T4, T5, T6>(source: Iterable<T>, source2: Iterable<T2>, source3: Iterable<T3>, source4: Iterable<T4>, source5: Iterable<T5>, source6: Iterable<T6>): IterableX<[T, T2, T3, T4, T5, T6]>
zip<T, R>(project: function, source: Iterable<T>): IterableX<R>
zip<T, T2, R>(project: function, source: Iterable<T>, source2: Iterable<T2>): IterableX<R>
zip<T, T2, T3, R>(project: function, source: Iterable<T>, source2: Iterable<T2>, source3: Iterable<T3>): IterableX<R>
zip<T, T2, T3, T4, R>(project: function, source: Iterable<T>, source2: Iterable<T2>, source3: Iterable<T3>, source4: Iterable<T4>): IterableX<R>
zip<T, T2, T3, T4, T5, R>(project: function, source: Iterable<T>, source2: Iterable<T2>, source3: Iterable<T3>, source4: Iterable<T4>, source5: Iterable<T5>): IterableX<R>
zip<T, T2, T3, T4, T5, T6, R>(project: function, source: Iterable<T>, source2: Iterable<T2>, source3: Iterable<T3>, source4: Iterable<T4>, source5: Iterable<T5>, source6: Iterable<T6>): IterableX<R>
zip<T>(...sources: Iterable<T>[]): IterableX<T[]>
zip<T, R>(project: function, ...sources: Iterable<T>[]): IterableX<R>
zip<T, T2>(source: Iterable<T>, source2: Iterable<T2>): OperatorFunction<T, [T, T2]>
zip<T, T2, T3>(source2: Iterable<T2>, source3: Iterable<T3>): OperatorFunction<T, [T, T2, T3]>
zip<T, T2, T3, T4>(source2: Iterable<T2>, source3: Iterable<T3>, source4: Iterable<T4>): OperatorFunction<T, [T, T2, T3, T4]>
zip<T, T2, T3, T4, T5>(source2: Iterable<T2>, source3: Iterable<T3>, source4: Iterable<T4>, source5: Iterable<T5>): OperatorFunction<T, [T, T2, T3, T4, T5]>
zip<T, T2, T3, T4, T5, T6>(source2: Iterable<T2>, source3: Iterable<T3>, source4: Iterable<T4>, source5: Iterable<T5>, source6: Iterable<T6>): OperatorFunction<T, [T, T2, T3, T4, T5, T6]>
zip<T, T2, R>(project: function, source2: Iterable<T2>): OperatorFunction<T, R>
zip<T, T2, T3, R>(project: function, source2: Iterable<T2>, source3: Iterable<T3>): OperatorFunction<T, R>
zip<T, T2, T3, T4, R>(project: function, source2: Iterable<T2>, source3: Iterable<T3>, source4: Iterable<T4>): OperatorFunction<T, R>
zip<T, T2, T3, T4, T5, R>(project: function, source2: Iterable<T2>, source3: Iterable<T3>, source4: Iterable<T4>, source5: Iterable<T5>): OperatorFunction<T, R>
zip<T, T2, T3, T4, T5, T6, R>(project: function, source2: Iterable<T2>, source3: Iterable<T3>, source4: Iterable<T4>, source5: Iterable<T5>, source6: Iterable<T6>): OperatorFunction<T, R>
zip<T>(...sources: Iterable<T>[]): OperatorFunction<T, T[]>
zip<T, R>(project: function, ...sources: Iterable<T>[]): OperatorFunction<T, R>
zip<T, T2>(source: AsyncIterable<T>, source2: AsyncIterable<T2>): OperatorAsyncFunction<T, [T, T2]>
zip<T, T2, T3>(source2: AsyncIterable<T2>, source3: AsyncIterable<T3>): OperatorAsyncFunction<T, [T, T2, T3]>
zip<T, T2, T3, T4>(source2: AsyncIterable<T2>, source3: AsyncIterable<T3>, source4: AsyncIterable<T4>): OperatorAsyncFunction<T, [T, T2, T3, T4]>
zip<T, T2, T3, T4, T5>(source2: AsyncIterable<T2>, source3: AsyncIterable<T3>, source4: AsyncIterable<T4>, source5: AsyncIterable<T5>): OperatorAsyncFunction<T, [T, T2, T3, T4, T5]>
zip<T, T2, T3, T4, T5, T6>(source2: AsyncIterable<T2>, source3: AsyncIterable<T3>, source4: AsyncIterable<T4>, source5: AsyncIterable<T5>, source6: AsyncIterable<T6>): OperatorAsyncFunction<T, [T, T2, T3, T4, T5, T6]>
zip<T, T2, R>(project: function, source2: AsyncIterable<T2>): OperatorAsyncFunction<T, R>
zip<T, T2, T3, R>(project: function, source2: AsyncIterable<T2>, source3: AsyncIterable<T3>): OperatorAsyncFunction<T, R>
zip<T, T2, T3, T4, R>(project: function, source2: AsyncIterable<T2>, source3: AsyncIterable<T3>, source4: AsyncIterable<T4>): OperatorAsyncFunction<T, R>
zip<T, T2, T3, T4, T5, R>(project: function, source2: AsyncIterable<T2>, source3: AsyncIterable<T3>, source4: AsyncIterable<T4>, source5: AsyncIterable<T5>): OperatorAsyncFunction<T, R>
zip<T, T2, T3, T4, T5, T6, R>(project: function, source2: AsyncIterable<T2>, source3: AsyncIterable<T3>, source4: AsyncIterable<T4>, source5: AsyncIterable<T5>, source6: AsyncIterable<T6>): OperatorAsyncFunction<T, R>
zip<T>(...sources: AsyncIterable<T>[]): OperatorAsyncFunction<T, T[]>
zip<T, R>(project: function, ...sources: AsyncIterable<T>[]): OperatorAsyncFunction<T, R>

- Defined in asynciterable/zip.ts:37
Type parameters
- T
- T2
Parameters
- source: AsyncIterable<T>
- source2: AsyncIterable<T2>
Returns AsyncIterableX<[T, T2]>
- Defined in asynciterable/zip.ts:41
Type parameters
- T
- T2
- T3
Parameters
- source: AsyncIterable<T>
- source2: AsyncIterable<T2>
- source3: AsyncIterable<T3>
Returns AsyncIterableX<[T, T2, T3]>
- Defined in asynciterable/zip.ts:46
Type parameters
- T
- T2
- T3
- T4
Parameters
- source: AsyncIterable<T>
- source2: AsyncIterable<T2>
- source3: AsyncIterable<T3>
- source4: AsyncIterable<T4>
Returns AsyncIterableX<[T, T2, T3, T4]>
- Defined in asynciterable/zip.ts:52
Type parameters
- T
- T2
- T3
- T4
- T5
Parameters
- source: AsyncIterable<T>
- source2: AsyncIterable<T2>
- source3: AsyncIterable<T3>
- source4: AsyncIterable<T4>
- source5: AsyncIterable<T5>
Returns AsyncIterableX<[T, T2, T3, T4, T5]>
- Defined in asynciterable/zip.ts:59
Type parameters
- T
- T2
- T3
- T4
- T5
- T6
Parameters
- source: AsyncIterable<T>
- source2: AsyncIterable<T2>
- source3: AsyncIterable<T3>
- source4: AsyncIterable<T4>
- source5: AsyncIterable<T5>
- source6: AsyncIterable<T6>
Returns AsyncIterableX<[T, T2, T3, T4, T5, T6]>
- Defined in asynciterable/zip.ts:68
Type parameters
- T
- R
Parameters
- project: function
 - - (values: [T]): R | Promise<R>
 - Parameters
 - values: [T]
 Returns R | Promise<R>
- source: AsyncIterable<T>
Returns AsyncIterableX<R>
- Defined in asynciterable/zip.ts:72
Type parameters
- T
- T2
- R
Parameters
- project: function
 - - (values: [T, T2]): R | Promise<R>
 - Parameters
 - values: [T, T2]
 Returns R | Promise<R>
- source: AsyncIterable<T>
- source2: AsyncIterable<T2>
Returns AsyncIterableX<R>
- Defined in asynciterable/zip.ts:77
Type parameters
- T
- T2
- T3
- R
Parameters
- project: function
 - - (values: [T, T2, T3]): R | Promise<R>
 - Parameters
 - values: [T, T2, T3]
 Returns R | Promise<R>
- source: AsyncIterable<T>
- source2: AsyncIterable<T2>
- source3: AsyncIterable<T3>
Returns AsyncIterableX<R>
- Defined in asynciterable/zip.ts:83
Type parameters
- T
- T2
- T3
- T4
- R
Parameters
- project: function
 - - (values: [T, T2, T3, T4]): R | Promise<R>
 - Parameters
 - values: [T, T2, T3, T4]
 Returns R | Promise<R>
- source: AsyncIterable<T>
- source2: AsyncIterable<T2>
- source3: AsyncIterable<T3>
- source4: AsyncIterable<T4>
Returns AsyncIterableX<R>
- Defined in asynciterable/zip.ts:90
Type parameters
- T
- T2
- T3
- T4
- T5
- R
Parameters
- project: function
 - - (values: [T, T2, T3, T4, T5]): R | Promise<R>
 - Parameters
 - values: [T, T2, T3, T4, T5]
 Returns R | Promise<R>
- source: AsyncIterable<T>
- source2: AsyncIterable<T2>
- source3: AsyncIterable<T3>
- source4: AsyncIterable<T4>
- source5: AsyncIterable<T5>
Returns AsyncIterableX<R>
- Defined in asynciterable/zip.ts:98
Type parameters
- T
- T2
- T3
- T4
- T5
- T6
- R
Parameters
- project: function
 - - (values: [T, T2, T3, T4, T5, T6]): R | Promise<R>
 - Parameters
 - values: [T, T2, T3, T4, T5, T6]
 Returns R | Promise<R>
- source: AsyncIterable<T>
- source2: AsyncIterable<T2>
- source3: AsyncIterable<T3>
- source4: AsyncIterable<T4>
- source5: AsyncIterable<T5>
- source6: AsyncIterable<T6>
Returns AsyncIterableX<R>
- Defined in asynciterable/zip.ts:108
Type parameters
- T
Parameters
- Rest ...sources: AsyncIterable<T>[]
Returns AsyncIterableX<T[]>
- Defined in asynciterable/zip.ts:109
Type parameters
- T
- R
Parameters
- project: function
 - - (values: T[]): R | Promise<R>
 - Parameters
 - values: T[]
 Returns R | Promise<R>
- Rest ...sources: AsyncIterable<T>[]
Returns AsyncIterableX<R>
- Defined in iterable/zip.ts:33
Type parameters
- T
- T2
Parameters
- source: Iterable<T>
- source2: Iterable<T2>
Returns IterableX<[T, T2]>
- Defined in iterable/zip.ts:34
Type parameters
- T
- T2
- T3
Parameters
- source: Iterable<T>
- source2: Iterable<T2>
- source3: Iterable<T3>
Returns IterableX<[T, T2, T3]>
- Defined in iterable/zip.ts:39
Type parameters
- T
- T2
- T3
- T4
Parameters
- source: Iterable<T>
- source2: Iterable<T2>
- source3: Iterable<T3>
- source4: Iterable<T4>
Returns IterableX<[T, T2, T3, T4]>
- Defined in iterable/zip.ts:45
Type parameters
- T
- T2
- T3
- T4
- T5
Parameters
- source: Iterable<T>
- source2: Iterable<T2>
- source3: Iterable<T3>
- source4: Iterable<T4>
- source5: Iterable<T5>
Returns IterableX<[T, T2, T3, T4, T5]>
- Defined in iterable/zip.ts:52
Type parameters
- T
- T2
- T3
- T4
- T5
- T6
Parameters
- source: Iterable<T>
- source2: Iterable<T2>
- source3: Iterable<T3>
- source4: Iterable<T4>
- source5: Iterable<T5>
- source6: Iterable<T6>
Returns IterableX<[T, T2, T3, T4, T5, T6]>
- Defined in iterable/zip.ts:61
Type parameters
- T
- R
Parameters
- project: function
 - - (values: [T]): R
 - Parameters
 - values: [T]
 Returns R
- source: Iterable<T>
Returns IterableX<R>
- Defined in iterable/zip.ts:62
Type parameters
- T
- T2
- R
Parameters
- project: function
 - - (values: [T, T2]): R
 - Parameters
 - values: [T, T2]
 Returns R
- source: Iterable<T>
- source2: Iterable<T2>
Returns IterableX<R>
- Defined in iterable/zip.ts:67
Type parameters
- T
- T2
- T3
- R
Parameters
- project: function
 - - (values: [T, T2, T3]): R
 - Parameters
 - values: [T, T2, T3]
 Returns R
- source: Iterable<T>
- source2: Iterable<T2>
- source3: Iterable<T3>
Returns IterableX<R>
- Defined in iterable/zip.ts:73
Type parameters
- T
- T2
- T3
- T4
- R
Parameters
- project: function
 - - (values: [T, T2, T3, T4]): R
 - Parameters
 - values: [T, T2, T3, T4]
 Returns R
- source: Iterable<T>
- source2: Iterable<T2>
- source3: Iterable<T3>
- source4: Iterable<T4>
Returns IterableX<R>
- Defined in iterable/zip.ts:80
Type parameters
- T
- T2
- T3
- T4
- T5
- R
Parameters
- project: function
 - - (values: [T, T2, T3, T4, T5]): R
 - Parameters
 - values: [T, T2, T3, T4, T5]
 Returns R
- source: Iterable<T>
- source2: Iterable<T2>
- source3: Iterable<T3>
- source4: Iterable<T4>
- source5: Iterable<T5>
Returns IterableX<R>
- Defined in iterable/zip.ts:88
Type parameters
- T
- T2
- T3
- T4
- T5
- T6
- R
Parameters
- project: function
 - - (values: [T, T2, T3, T4, T5, T6]): R
 - Parameters
 - values: [T, T2, T3, T4, T5, T6]
 Returns R
- source: Iterable<T>
- source2: Iterable<T2>
- source3: Iterable<T3>
- source4: Iterable<T4>
- source5: Iterable<T5>
- source6: Iterable<T6>
Returns IterableX<R>
- Defined in iterable/zip.ts:98
Type parameters
- T
Parameters
- Rest ...sources: Iterable<T>[]
Returns IterableX<T[]>
- Defined in iterable/zip.ts:99
Type parameters
- T
- R
Parameters
- project: function
 - - (values: T[]): R
 - Parameters
 - values: T[]
 Returns R
- Rest ...sources: Iterable<T>[]
Returns IterableX<R>
- Defined in iterable/pipe/zip.ts:6
Type parameters
- T
- T2
Parameters
- source: Iterable<T>
- source2: Iterable<T2>
Returns OperatorFunction<T, [T, T2]>
- Defined in iterable/pipe/zip.ts:10
Type parameters
- T
- T2
- T3
Parameters
- source2: Iterable<T2>
- source3: Iterable<T3>
Returns OperatorFunction<T, [T, T2, T3]>
- Defined in iterable/pipe/zip.ts:14
Type parameters
- T
- T2
- T3
- T4
Parameters
- source2: Iterable<T2>
- source3: Iterable<T3>
- source4: Iterable<T4>
Returns OperatorFunction<T, [T, T2, T3, T4]>
- Defined in iterable/pipe/zip.ts:19
Type parameters
- T
- T2
- T3
- T4
- T5
Parameters
- source2: Iterable<T2>
- source3: Iterable<T3>
- source4: Iterable<T4>
- source5: Iterable<T5>
Returns OperatorFunction<T, [T, T2, T3, T4, T5]>
- Defined in iterable/pipe/zip.ts:25
Type parameters
- T
- T2
- T3
- T4
- T5
- T6
Parameters
- source2: Iterable<T2>
- source3: Iterable<T3>
- source4: Iterable<T4>
- source5: Iterable<T5>
- source6: Iterable<T6>
Returns OperatorFunction<T, [T, T2, T3, T4, T5, T6]>
- Defined in iterable/pipe/zip.ts:33
Type parameters
- T
- T2
- R
Parameters
- project: function
 - - (values: [T, T2]): R
 - Parameters
 - values: [T, T2]
 Returns R
- source2: Iterable<T2>
Returns OperatorFunction<T, R>
- Defined in iterable/pipe/zip.ts:37
Type parameters
- T
- T2
- T3
- R
Parameters
- project: function
 - - (values: [T, T2, T3]): R
 - Parameters
 - values: [T, T2, T3]
 Returns R
- source2: Iterable<T2>
- source3: Iterable<T3>
Returns OperatorFunction<T, R>
- Defined in iterable/pipe/zip.ts:42
Type parameters
- T
- T2
- T3
- T4
- R
Parameters
- project: function
 - - (values: [T, T2, T3, T4]): R
 - Parameters
 - values: [T, T2, T3, T4]
 Returns R
- source2: Iterable<T2>
- source3: Iterable<T3>
- source4: Iterable<T4>
Returns OperatorFunction<T, R>
- Defined in iterable/pipe/zip.ts:48
Type parameters
- T
- T2
- T3
- T4
- T5
- R
Parameters
- project: function
 - - (values: [T, T2, T3, T4, T5]): R
 - Parameters
 - values: [T, T2, T3, T4, T5]
 Returns R
- source2: Iterable<T2>
- source3: Iterable<T3>
- source4: Iterable<T4>
- source5: Iterable<T5>
Returns OperatorFunction<T, R>
- Defined in iterable/pipe/zip.ts:55
Type parameters
- T
- T2
- T3
- T4
- T5
- T6
- R
Parameters
- project: function
 - - (values: [T, T2, T3, T4, T5, T6]): R
 - Parameters
 - values: [T, T2, T3, T4, T5, T6]
 Returns R
- source2: Iterable<T2>
- source3: Iterable<T3>
- source4: Iterable<T4>
- source5: Iterable<T5>
- source6: Iterable<T6>
Returns OperatorFunction<T, R>
- Defined in iterable/pipe/zip.ts:64
Type parameters
- T
Parameters
- Rest ...sources: Iterable<T>[]
Returns OperatorFunction<T, T[]>
- Defined in iterable/pipe/zip.ts:65
Type parameters
- T
- R
Parameters
- project: function
 - - (values: T[]): R
 - Parameters
 - values: T[]
 Returns R
- Rest ...sources: Iterable<T>[]
Returns OperatorFunction<T, R>
- Defined in asynciterable/pipe/zip.ts:6
Type parameters
- T
- T2
Parameters
- source: AsyncIterable<T>
- source2: AsyncIterable<T2>
Returns OperatorAsyncFunction<T, [T, T2]>
- Defined in asynciterable/pipe/zip.ts:10
Type parameters
- T
- T2
- T3
Parameters
- source2: AsyncIterable<T2>
- source3: AsyncIterable<T3>
Returns OperatorAsyncFunction<T, [T, T2, T3]>
- Defined in asynciterable/pipe/zip.ts:14
Type parameters
- T
- T2
- T3
- T4
Parameters
- source2: AsyncIterable<T2>
- source3: AsyncIterable<T3>
- source4: AsyncIterable<T4>
Returns OperatorAsyncFunction<T, [T, T2, T3, T4]>
- Defined in asynciterable/pipe/zip.ts:19
Type parameters
- T
- T2
- T3
- T4
- T5
Parameters
- source2: AsyncIterable<T2>
- source3: AsyncIterable<T3>
- source4: AsyncIterable<T4>
- source5: AsyncIterable<T5>
Returns OperatorAsyncFunction<T, [T, T2, T3, T4, T5]>
- Defined in asynciterable/pipe/zip.ts:25
Type parameters
- T
- T2
- T3
- T4
- T5
- T6
Parameters
- source2: AsyncIterable<T2>
- source3: AsyncIterable<T3>
- source4: AsyncIterable<T4>
- source5: AsyncIterable<T5>
- source6: AsyncIterable<T6>
Returns OperatorAsyncFunction<T, [T, T2, T3, T4, T5, T6]>
- Defined in asynciterable/pipe/zip.ts:33
Type parameters
- T
- T2
- R
Parameters
- project: function
 - - (values: [T, T2]): R | Promise<R>
 - Parameters
 - values: [T, T2]
 Returns R | Promise<R>
- source2: AsyncIterable<T2>
Returns OperatorAsyncFunction<T, R>
- Defined in asynciterable/pipe/zip.ts:37
Type parameters
- T
- T2
- T3
- R
Parameters
- project: function
 - - (values: [T, T2, T3]): R | Promise<R>
 - Parameters
 - values: [T, T2, T3]
 Returns R | Promise<R>
- source2: AsyncIterable<T2>
- source3: AsyncIterable<T3>
Returns OperatorAsyncFunction<T, R>
- Defined in asynciterable/pipe/zip.ts:42
Type parameters
- T
- T2
- T3
- T4
- R
Parameters
- project: function
 - - (values: [T, T2, T3, T4]): R | Promise<R>
 - Parameters
 - values: [T, T2, T3, T4]
 Returns R | Promise<R>
- source2: AsyncIterable<T2>
- source3: AsyncIterable<T3>
- source4: AsyncIterable<T4>
Returns OperatorAsyncFunction<T, R>
- Defined in asynciterable/pipe/zip.ts:48
Type parameters
- T
- T2
- T3
- T4
- T5
- R
Parameters
- project: function
 - - (values: [T, T2, T3, T4, T5]): R | Promise<R>
 - Parameters
 - values: [T, T2, T3, T4, T5]
 Returns R | Promise<R>
- source2: AsyncIterable<T2>
- source3: AsyncIterable<T3>
- source4: AsyncIterable<T4>
- source5: AsyncIterable<T5>
Returns OperatorAsyncFunction<T, R>
- Defined in asynciterable/pipe/zip.ts:55
Type parameters
- T
- T2
- T3
- T4
- T5
- T6
- R
Parameters
- project: function
 - - (values: [T, T2, T3, T4, T5, T6]): R | Promise<R>
 - Parameters
 - values: [T, T2, T3, T4, T5, T6]
 Returns R | Promise<R>
- source2: AsyncIterable<T2>
- source3: AsyncIterable<T3>
- source4: AsyncIterable<T4>
- source5: AsyncIterable<T5>
- source6: AsyncIterable<T6>
Returns OperatorAsyncFunction<T, R>
- Defined in asynciterable/pipe/zip.ts:64
Type parameters
- T
Parameters
- Rest ...sources: AsyncIterable<T>[]
Returns OperatorAsyncFunction<T, T[]>
- Defined in asynciterable/pipe/zip.ts:65
Type parameters
- T
- R
Parameters
- project: function
 - - (values: T[]): R | Promise<R>
 - Parameters
 - values: T[]
 Returns R | Promise<R>
- Rest ...sources: AsyncIterable<T>[]
Returns OperatorAsyncFunction<T, R>

zipProto

zipProto<T, T2>(this: IterableX<T>, source2: Iterable<T2>): IterableX<[T, T2]>
zipProto<T, T2, T3>(this: IterableX<T>, source2: Iterable<T2>, source3: Iterable<T3>): IterableX<[T, T2, T3]>
zipProto<T, T2, T3, T4>(this: IterableX<T>, source2: Iterable<T2>, source3: Iterable<T3>, source4: Iterable<T4>): IterableX<[T, T2, T3, T4]>
zipProto<T, T2, T3, T4, T5>(this: IterableX<T>, source2: Iterable<T2>, source3: Iterable<T3>, source4: Iterable<T4>, source5: Iterable<T5>): IterableX<[T, T2, T3, T4, T5]>
zipProto<T, T2, T3, T4, T5, T6>(this: IterableX<T>, source2: Iterable<T2>, source3: Iterable<T3>, source4: Iterable<T4>, source5: Iterable<T5>, source6: Iterable<T6>): IterableX<[T, T2, T3, T4, T5, T6]>
zipProto<T, R>(this: IterableX<T>, project: function): IterableX<R>
zipProto<T, T2, R>(this: IterableX<T>, project: function, source2: Iterable<T2>): IterableX<R>
zipProto<T, T2, T3, R>(this: IterableX<T>, project: function, source2: Iterable<T2>, source3: Iterable<T3>): IterableX<R>
zipProto<T, T2, T3, T4, R>(this: IterableX<T>, project: function, source2: Iterable<T2>, source3: Iterable<T3>, source4: Iterable<T4>): IterableX<R>
zipProto<T, T2, T3, T4, T5, R>(this: IterableX<T>, project: function, source2: Iterable<T2>, source3: Iterable<T3>, source4: Iterable<T4>, source5: Iterable<T5>): IterableX<R>
zipProto<T, T2, T3, T4, T5, T6, R>(this: IterableX<T>, project: function, source2: Iterable<T2>, source3: Iterable<T3>, source4: Iterable<T4>, source5: Iterable<T5>, source6: Iterable<T6>): IterableX<R>
zipProto<T>(this: IterableX<T>, ...sources: Iterable<T>[]): IterableX<T[]>
zipProto<T, R>(this: IterableX<T>, project: function, ...sources: Iterable<T>[]): IterableX<R>
zipProto<T, T2>(this: AsyncIterableX<T>, source2: AsyncIterable<T2>): AsyncIterableX<[T, T2]>
zipProto<T, T2, T3>(this: AsyncIterableX<T>, source2: AsyncIterable<T2>, source3: AsyncIterable<T3>): AsyncIterableX<[T, T2, T3]>
zipProto<T, T2, T3, T4>(this: AsyncIterableX<T>, source2: AsyncIterable<T2>, source3: AsyncIterable<T3>, source4: AsyncIterable<T4>): AsyncIterableX<[T, T2, T3, T4]>
zipProto<T, T2, T3, T4, T5>(this: AsyncIterableX<T>, source2: AsyncIterable<T2>, source3: AsyncIterable<T3>, source4: AsyncIterable<T4>, source5: AsyncIterable<T5>): AsyncIterableX<[T, T2, T3, T4, T5]>
zipProto<T, T2, T3, T4, T5, T6>(this: AsyncIterableX<T>, source2: AsyncIterable<T2>, source3: AsyncIterable<T3>, source4: AsyncIterable<T4>, source5: AsyncIterable<T5>, source6: AsyncIterable<T6>): AsyncIterableX<[T, T2, T3, T4, T5, T6]>
zipProto<T, R>(this: AsyncIterableX<T>, project: function): AsyncIterableX<R>
zipProto<T, T2, R>(this: AsyncIterableX<T>, project: function, source2: AsyncIterable<T2>): AsyncIterableX<R>
zipProto<T, T2, T3, R>(this: AsyncIterableX<T>, project: function, source2: AsyncIterable<T2>, source3: AsyncIterable<T3>): AsyncIterableX<R>
zipProto<T, T2, T3, T4, R>(this: AsyncIterableX<T>, project: function, source2: AsyncIterable<T2>, source3: AsyncIterable<T3>, source4: AsyncIterable<T4>): AsyncIterableX<R>
zipProto<T, T2, T3, T4, T5, R>(this: AsyncIterableX<T>, project: function, source2: AsyncIterable<T2>, source3: AsyncIterable<T3>, source4: AsyncIterable<T4>, source5: AsyncIterable<T5>): AsyncIterableX<R>
zipProto<T, T2, T3, T4, T5, T6, R>(this: AsyncIterableX<T>, project: function, source2: AsyncIterable<T2>, source3: AsyncIterable<T3>, source4: AsyncIterable<T4>, source5: AsyncIterable<T5>, source6: AsyncIterable<T6>): AsyncIterableX<R>
zipProto<T>(this: AsyncIterableX<T>, ...sources: AsyncIterable<T>[]): AsyncIterableX<T[]>
zipProto<T, R>(this: AsyncIterableX<T>, project: function, ...sources: AsyncIterable<T>[]): AsyncIterableX<R>

- Defined in add/iterable-operators/zip.ts:8
ignore

Type parameters
- T
- T2
Parameters
- this: IterableX<T>
- source2: Iterable<T2>
Returns IterableX<[T, T2]>
- Defined in add/iterable-operators/zip.ts:9
Type parameters
- T
- T2
- T3
Parameters
- this: IterableX<T>
- source2: Iterable<T2>
- source3: Iterable<T3>
Returns IterableX<[T, T2, T3]>
- Defined in add/iterable-operators/zip.ts:14
Type parameters
- T
- T2
- T3
- T4
Parameters
- this: IterableX<T>
- source2: Iterable<T2>
- source3: Iterable<T3>
- source4: Iterable<T4>
Returns IterableX<[T, T2, T3, T4]>
- Defined in add/iterable-operators/zip.ts:20
Type parameters
- T
- T2
- T3
- T4
- T5
Parameters
- this: IterableX<T>
- source2: Iterable<T2>
- source3: Iterable<T3>
- source4: Iterable<T4>
- source5: Iterable<T5>
Returns IterableX<[T, T2, T3, T4, T5]>
- Defined in add/iterable-operators/zip.ts:27
Type parameters
- T
- T2
- T3
- T4
- T5
- T6
Parameters
- this: IterableX<T>
- source2: Iterable<T2>
- source3: Iterable<T3>
- source4: Iterable<T4>
- source5: Iterable<T5>
- source6: Iterable<T6>
Returns IterableX<[T, T2, T3, T4, T5, T6]>
- Defined in add/iterable-operators/zip.ts:36
Type parameters
- T
- R
Parameters
- this: IterableX<T>
- project: function
 - - (values: [T]): R
 - Parameters
 - values: [T]
 Returns R
Returns IterableX<R>
- Defined in add/iterable-operators/zip.ts:37
Type parameters
- T
- T2
- R
Parameters
- this: IterableX<T>
- project: function
 - - (values: [T, T2]): R
 - Parameters
 - values: [T, T2]
 Returns R
- source2: Iterable<T2>
Returns IterableX<R>
- Defined in add/iterable-operators/zip.ts:42
Type parameters
- T
- T2
- T3
- R
Parameters
- this: IterableX<T>
- project: function
 - - (values: [T, T2, T3]): R
 - Parameters
 - values: [T, T2, T3]
 Returns R
- source2: Iterable<T2>
- source3: Iterable<T3>
Returns IterableX<R>
- Defined in add/iterable-operators/zip.ts:48
Type parameters
- T
- T2
- T3
- T4
- R
Parameters
- this: IterableX<T>
- project: function
 - - (values: [T, T2, T3, T4]): R
 - Parameters
 - values: [T, T2, T3, T4]
 Returns R
- source2: Iterable<T2>
- source3: Iterable<T3>
- source4: Iterable<T4>
Returns IterableX<R>
- Defined in add/iterable-operators/zip.ts:55
Type parameters
- T
- T2
- T3
- T4
- T5
- R
Parameters
- this: IterableX<T>
- project: function
 - - (values: [T, T2, T3, T4, T5]): R
 - Parameters
 - values: [T, T2, T3, T4, T5]
 Returns R
- source2: Iterable<T2>
- source3: Iterable<T3>
- source4: Iterable<T4>
- source5: Iterable<T5>
Returns IterableX<R>
- Defined in add/iterable-operators/zip.ts:63
Type parameters
- T
- T2
- T3
- T4
- T5
- T6
- R
Parameters
- this: IterableX<T>
- project: function
 - - (values: [T, T2, T3, T4, T5, T6]): R
 - Parameters
 - values: [T, T2, T3, T4, T5, T6]
 Returns R
- source2: Iterable<T2>
- source3: Iterable<T3>
- source4: Iterable<T4>
- source5: Iterable<T5>
- source6: Iterable<T6>
Returns IterableX<R>
- Defined in add/iterable-operators/zip.ts:73
Type parameters
- T
Parameters
- this: IterableX<T>
- Rest ...sources: Iterable<T>[]
Returns IterableX<T[]>
- Defined in add/iterable-operators/zip.ts:74
Type parameters
- T
- R
Parameters
- this: IterableX<T>
- project: function
 - - (values: T[]): R
 - Parameters
 - values: T[]
 Returns R
- Rest ...sources: Iterable<T>[]
Returns IterableX<R>
- Defined in add/asynciterable-operators/zip.ts:8
ignore

Type parameters
- T
- T2
Parameters
- this: AsyncIterableX<T>
- source2: AsyncIterable<T2>
Returns AsyncIterableX<[T, T2]>
- Defined in add/asynciterable-operators/zip.ts:12
Type parameters
- T
- T2
- T3
Parameters
- this: AsyncIterableX<T>
- source2: AsyncIterable<T2>
- source3: AsyncIterable<T3>
Returns AsyncIterableX<[T, T2, T3]>
- Defined in add/asynciterable-operators/zip.ts:17
Type parameters
- T
- T2
- T3
- T4
Parameters
- this: AsyncIterableX<T>
- source2: AsyncIterable<T2>
- source3: AsyncIterable<T3>
- source4: AsyncIterable<T4>
Returns AsyncIterableX<[T, T2, T3, T4]>
- Defined in add/asynciterable-operators/zip.ts:23
Type parameters
- T
- T2
- T3
- T4
- T5
Parameters
- this: AsyncIterableX<T>
- source2: AsyncIterable<T2>
- source3: AsyncIterable<T3>
- source4: AsyncIterable<T4>
- source5: AsyncIterable<T5>
Returns AsyncIterableX<[T, T2, T3, T4, T5]>
- Defined in add/asynciterable-operators/zip.ts:30
Type parameters
- T
- T2
- T3
- T4
- T5
- T6
Parameters
- this: AsyncIterableX<T>
- source2: AsyncIterable<T2>
- source3: AsyncIterable<T3>
- source4: AsyncIterable<T4>
- source5: AsyncIterable<T5>
- source6: AsyncIterable<T6>
Returns AsyncIterableX<[T, T2, T3, T4, T5, T6]>
- Defined in add/asynciterable-operators/zip.ts:39
Type parameters
- T
- R
Parameters
- this: AsyncIterableX<T>
- project: function
 - - (values: [T]): R
 - Parameters
 - values: [T]
 Returns R
Returns AsyncIterableX<R>
- Defined in add/asynciterable-operators/zip.ts:43
Type parameters
- T
- T2
- R
Parameters
- this: AsyncIterableX<T>
- project: function
 - - (values: [T, T2]): R
 - Parameters
 - values: [T, T2]
 Returns R
- source2: AsyncIterable<T2>
Returns AsyncIterableX<R>
- Defined in add/asynciterable-operators/zip.ts:48
Type parameters
- T
- T2
- T3
- R
Parameters
- this: AsyncIterableX<T>
- project: function
 - - (values: [T, T2, T3]): R
 - Parameters
 - values: [T, T2, T3]
 Returns R
- source2: AsyncIterable<T2>
- source3: AsyncIterable<T3>
Returns AsyncIterableX<R>
- Defined in add/asynciterable-operators/zip.ts:54
Type parameters
- T
- T2
- T3
- T4
- R
Parameters
- this: AsyncIterableX<T>
- project: function
 - - (values: [T, T2, T3, T4]): R
 - Parameters
 - values: [T, T2, T3, T4]
 Returns R
- source2: AsyncIterable<T2>
- source3: AsyncIterable<T3>
- source4: AsyncIterable<T4>
Returns AsyncIterableX<R>
- Defined in add/asynciterable-operators/zip.ts:61
Type parameters
- T
- T2
- T3
- T4
- T5
- R
Parameters
- this: AsyncIterableX<T>
- project: function
 - - (values: [T, T2, T3, T4, T5]): R
 - Parameters
 - values: [T, T2, T3, T4, T5]
 Returns R
- source2: AsyncIterable<T2>
- source3: AsyncIterable<T3>
- source4: AsyncIterable<T4>
- source5: AsyncIterable<T5>
Returns AsyncIterableX<R>
- Defined in add/asynciterable-operators/zip.ts:69
Type parameters
- T
- T2
- T3
- T4
- T5
- T6
- R
Parameters
- this: AsyncIterableX<T>
- project: function
 - - (values: [T, T2, T3, T4, T5, T6]): R
 - Parameters
 - values: [T, T2, T3, T4, T5, T6]
 Returns R
- source2: AsyncIterable<T2>
- source3: AsyncIterable<T3>
- source4: AsyncIterable<T4>
- source5: AsyncIterable<T5>
- source6: AsyncIterable<T6>
Returns AsyncIterableX<R>
- Defined in add/asynciterable-operators/zip.ts:79
Type parameters
- T
Parameters
- this: AsyncIterableX<T>
- Rest ...sources: AsyncIterable<T>[]
Returns AsyncIterableX<T[]>
- Defined in add/asynciterable-operators/zip.ts:83
Type parameters
- T
- R
Parameters
- this: AsyncIterableX<T>
- project: function
 - - (values: T[]): R
 - Parameters
 - values: T[]
 Returns R
- Rest ...sources: AsyncIterable<T>[]
Returns AsyncIterableX<R>

Generated using TypeDoc

The Interactive Extensions for JavaScript (IxJS)

Install IxJS from npm

Iterable

AsyncIterable

Converting from Iterable to AsyncIterable

Contributing

Code Of Conduct

Contributing Guide

Packaging

Why we package like this

License

Index

Modules

Classes

Interfaces

Type aliases

Variables

Functions

Type aliases

AsyncIterableInput

EventListenerOptions

EventedTarget

MergeResult

Type declaration

index: number

value: T

MonoTypeOperatorAsyncFunction

MonoTypeOperatorFunction

NodeEventEmitter

Type declaration

addListener: function

Parameters

eventName: string

handler: Function

Returns void

removeListener: function

Parameters

eventName: string

handler: Function

Returns void

OperatorAsyncFunction

OperatorFunction

PartialAsyncObserver

PartialObserver

UnaryFunction

Type declaration

Parameters

source: T

Returns R

Variables

Const ARRAY_ERROR

Const ARRAY_VALUE

Const ENDED

Const ERRORED

Const ERROR_TYPE

Const NEVER_PROMISE

Const NON_FLOWING

Const READABLE

Const VALUE_TYPE

Const maxSafeInteger

Functions

_case

Type parameters

TSource

TResult

Parameters

selector: function

Returns TSource | Promise<TSource>

sources: Map<TSource, AsyncIterable<TResult>>

Default value defaultSource: AsyncIterable<TResult> = empty<TResult>()

Returns AsyncIterableX<TResult>

_catch

Type parameters

T

Parameters

source: AsyncIterable<T>

Rest ...args: AsyncIterable<T>[]

Returns AsyncIterableX<T>

_catchAll

Type parameters

`Iterable`

`AsyncIterable`