@types/when

function all

all: <T>(promisesOrValues: any[]) => Promise<T>;

• Return a promise that will resolve only once all the supplied promisesOrValues have resolved. The resolution value of the returned promise will be an array containing the resolution values of each of the promisesOrValues.

  Parameter promisesOrValues

  array of anything, may contain a mix of Promises and values

function attempt

attempt: {
    <T>(f: _.Fn0<T>): Promise<T>;
    <A1, T>(f: _.Fn1<A1, T>, arg1: A1 | Promise<A1>): Promise<T>;
    <A1, A2, T>(
        f: _.Fn2<A1, A2, T>,
        arg1: A1 | Promise<A1>,
        arg2: A2 | Promise<A2>
    ): Promise<T>;
    <A1, A2, A3, T>(
        f: _.Fn3<A1, A2, A3, T>,
        arg1: A1 | Promise<A1>,
        arg2: A2 | Promise<A2>,
        arg3: A3 | Promise<A3>
    ): Promise<T>;
    <A1, A2, A3, A4, T>(
        f: _.Fn4<A1, A2, A3, A4, T>,
        arg1: A1 | Promise<A1>,
        arg2: A2 | Promise<A2>,
        arg3: A3 | Promise<A3>,
        arg4: A4 | Promise<A4>
    ): Promise<T>;
    <A1, A2, A3, A4, A5, T>(
        f: _.Fn5<A1, A2, A3, A4, A5, T>,
        arg1: A1 | Promise<A1>,
        arg2: A2 | Promise<A2>,
        arg3: A3 | Promise<A3>,
        arg4: A4 | Promise<A4>,
        arg5: A5 | Promise<A5>
    ): Promise<T>;
};

function defer

defer: <T>() => Deferred<T>;

• Creates a {promise, resolver} pair, either or both of which may be given out safely to consumers. The resolver has resolve, reject, and progress. The promise has then plus extended promise API.

function iterate

iterate: <U>(
    f: (seed: U) => U | Promise<U>,
    predicate: (value: U) => boolean,
    handler: (value: U) => Promise<any> | void,
    seed: U | Promise<U>
) => Promise<U>;

• Generates a potentially infinite stream of promises by repeatedly calling f until predicate becomes true.

  Parameter f

  function that, given a seed, returns the next value or a promise for it.

  Parameter predicate

  function that receives the current iteration value, and should return truthy when the iterating should stop

  Parameter handler

  function that receives each value as it is produced by f. It may return a promise to delay the next iteration.

  Parameter seed

  initial value provided to the handler, and first f invocation. May be a promise.

function join

join: {
    <T>(...promises: Array<Promise<T>>): Promise<T[]>;
    <T>(...promises: any[]): Promise<T[]>;
};

• Joins multiple promises into a single returned promise. a promise that will fulfill when *all* the input promises have fulfilled, or will reject when *any one* of the input promises rejects.

function lift

lift: {
    <T>(f: _.Fn0<T>): _.LiftedFn0<T>;
    <A1, T>(f: _.Fn1<A1, T>): _.LiftedFn1<A1, T>;
    <A1, A2, T>(f: _.Fn2<A1, A2, T>): _.LiftedFn2<A1, A2, T>;
    <A1, A2, A3, T>(f: _.Fn3<A1, A2, A3, T>): _.LiftedFn3<A1, A2, A3, T>;
    <A1, A2, A3, A4, T>(f: _.Fn4<A1, A2, A3, A4, T>): _.LiftedFn4<A1, A2, A3, A4, T>;
    <A1, A2, A3, A4, A5, T>(f: _.Fn5<A1, A2, A3, A4, A5, T>): _.LiftedFn5<
        A1,
        A2,
        A3,
        A4,
        A5,
        T
    >;
};

function map

map: <T>(
    promisesOrValues: any[],
    mapFunc: (value: any, index: number) => any
) => Promise<T>;

• Promise-aware array map function, similar to Array.prototype.map(), but input array may contain promises or values.

  Parameter promisesOrValues

  array of anything, may contain a mix of Promises and values

  Parameter mapFunc

  map function which may return a promise or value

  Returns

  a promise that will fulfill with an array of mapped values or reject if any input promise rejects.

function promise

promise: <T>(
    resolver: (resolve: (value: T) => void, reject: (reason: any) => void) => void
) => Promise<T>;

function reduce

reduce: <T>(
    promisesOrValues: any[],
    reduceFunc: (reduction: T, value: any, index: number) => T | Promise<T>,
    initialValue: T
) => Promise<T>;

• Traditional reduce function, similar to Array.prototype.reduce(), but input may contain promises and/or values, and reduceFunc may return either a value or a promise, *and* initialValue may be a promise for the starting value.

  Parameter promisesOrValues

  array or promise for an array of anything, may contain a mix of promises and values.

  Parameter reduceFunc

  function(accumulated:*, x:*, index:number):*} f reduce function

  Returns

  a promise that will resolve to the final reduced value

function reduceRight

reduceRight: <T>(
    promisesOrValues: any[],
    reduceFunc: (reduction: T, value: any, index: number) => T | Promise<T>,
    initialValue: T
) => Promise<T>;

• Traditional reduce function, similar to Array.prototype.reduceRight(), but input may contain promises and/or values, and reduceFunc may return either a value or a promise, *and* initialValue may be a promise for the starting value.

  Parameter promisesOrValues

  array or promise for an array of anything, may contain a mix of promises and values.

  Parameter reduceFunc

  function(accumulated:*, x:*, index:number):*} f reduce function

  Returns

  a promise that will resolve to the final reduced value

function reject

reject: <T>(reason: any) => Promise<T>;

function resolve

resolve: {
    (): Promise<void>;
    <T>(promiseOrValue: T | Promise<T> | Thenable<T>): Promise<T>;
};

• Returns a resolved promise. The returned promise will be - fulfilled with promiseOrValue if it is a value, or - if promiseOrValue is a promise - fulfilled with promiseOrValue's value after it is fulfilled - rejected with promiseOrValue's reason after it is rejected

function settle

settle: <T>(promisesOrValues: any[]) => Promise<Array<Descriptor<T>>>;

• Returns a promise for an array containing the same number of elements as the input array. Each element is a descriptor object describing of the outcome of the corresponding element in the input. The returned promise will only reject if array itself is a rejected promise. Otherwise, it will always fulfill with an array of descriptors. This is in contrast to when.all, which will reject if any element of array rejects.

  Parameter promisesOrValues

  array of anything, may contain a mix of Promises and values

function unfold

unfold: <T, U>(
    unspool: (
        seed: U
    ) =>
        | [T | Promise<T>, U | Promise<U>]
        | Promise<[T | Promise<T>, U | Promise<U>]>,
    predicate: (value: U) => boolean | Promise<boolean>,
    handler: (value: T) => Promise<any> | void,
    seed: U | Promise<U>
) => Promise<void>;

• Similar to when/iterate, when.unfold generates a potentially infinite stream of promises by repeatedly calling unspool until predicate becomes true. when.unfold allows you to thread additional state information through the iteration.

  Parameter unspool

  function that, given a seed, returns a [valueToSendToHandler, newSeed] pair. May return an array, array of promises, promise for an array, or promise for an array of promises.

  Parameter predicate

  function that receives the current seed, and should return truthy when the unfold should stop

  Parameter handler

  function that receives the valueToSendToHandler of the current iteration. This function can process valueToSendToHandler in whatever way you need. It may return a promise to delay the next iteration of the unfold.

  Parameter seed

  initial value provided to the first unspool invocation. May be a promise.

function When

When: typeof When;

type Descriptor

type Descriptor<T> = FulfilledDescriptor<T> | RejectedDescriptor;

• Describes the outcome of a promise. state may be one of: "fulfilled" - the promise has resolved "rejected" - the promise has rejected

type Snapshot

type Snapshot<T> = FulfilledDescriptor<T> | RejectedDescriptor | PendingDescriptor;

• Snapshot which describes the status of a promise. state may be one of: "fulfilled" - the promise has resolved "rejected" - the promise has rejected "pending" - the promise is still pending to resolve/reject

function all

all: <T>(promisesOrValues: any[]) => Promise<T>;

• Return a promise that will resolve only once all the supplied promisesOrValues have resolved. The resolution value of the returned promise will be an array containing the resolution values of each of the promisesOrValues.

  Parameter promisesOrValues

  array of anything, may contain a mix of Promises and values

function attempt

attempt: {
    <T>(f: _.Fn0<T>): Promise<T>;
    <A1, T>(f: _.Fn1<A1, T>, arg1: A1 | Promise<A1>): Promise<T>;
    <A1, A2, T>(
        f: _.Fn2<A1, A2, T>,
        arg1: A1 | Promise<A1>,
        arg2: A2 | Promise<A2>
    ): Promise<T>;
    <A1, A2, A3, T>(
        f: _.Fn3<A1, A2, A3, T>,
        arg1: A1 | Promise<A1>,
        arg2: A2 | Promise<A2>,
        arg3: A3 | Promise<A3>
    ): Promise<T>;
    <A1, A2, A3, A4, T>(
        f: _.Fn4<A1, A2, A3, A4, T>,
        arg1: A1 | Promise<A1>,
        arg2: A2 | Promise<A2>,
        arg3: A3 | Promise<A3>,
        arg4: A4 | Promise<A4>
    ): Promise<T>;
    <A1, A2, A3, A4, A5, T>(
        f: _.Fn5<A1, A2, A3, A4, A5, T>,
        arg1: A1 | Promise<A1>,
        arg2: A2 | Promise<A2>,
        arg3: A3 | Promise<A3>,
        arg4: A4 | Promise<A4>,
        arg5: A5 | Promise<A5>
    ): Promise<T>;
};

function defer

defer: <T>() => Deferred<T>;

• Creates a {promise, resolver} pair, either or both of which may be given out safely to consumers. The resolver has resolve, reject, and progress. The promise has then plus extended promise API.

function iterate

iterate: <U>(
    f: (seed: U) => U | Promise<U>,
    predicate: (value: U) => boolean,
    handler: (value: U) => Promise<any> | void,
    seed: U | Promise<U>
) => Promise<U>;

• Generates a potentially infinite stream of promises by repeatedly calling f until predicate becomes true.

  Parameter f

  function that, given a seed, returns the next value or a promise for it.

  Parameter predicate

  function that receives the current iteration value, and should return truthy when the iterating should stop

  Parameter handler

  function that receives each value as it is produced by f. It may return a promise to delay the next iteration.

  Parameter seed

  initial value provided to the handler, and first f invocation. May be a promise.

function join

join: {
    <T>(...promises: Array<Promise<T>>): Promise<T[]>;
    <T>(...promises: any[]): Promise<T[]>;
};

• Joins multiple promises into a single returned promise. a promise that will fulfill when *all* the input promises have fulfilled, or will reject when *any one* of the input promises rejects.

function lift

lift: {
    <T>(f: _.Fn0<T>): _.LiftedFn0<T>;
    <A1, T>(f: _.Fn1<A1, T>): _.LiftedFn1<A1, T>;
    <A1, A2, T>(f: _.Fn2<A1, A2, T>): _.LiftedFn2<A1, A2, T>;
    <A1, A2, A3, T>(f: _.Fn3<A1, A2, A3, T>): _.LiftedFn3<A1, A2, A3, T>;
    <A1, A2, A3, A4, T>(f: _.Fn4<A1, A2, A3, A4, T>): _.LiftedFn4<A1, A2, A3, A4, T>;
    <A1, A2, A3, A4, A5, T>(f: _.Fn5<A1, A2, A3, A4, A5, T>): _.LiftedFn5<
        A1,
        A2,
        A3,
        A4,
        A5,
        T
    >;
};

function map

map: <T>(
    promisesOrValues: any[],
    mapFunc: (value: any, index: number) => any
) => Promise<T>;

• Promise-aware array map function, similar to Array.prototype.map(), but input array may contain promises or values.

  Parameter promisesOrValues

  array of anything, may contain a mix of Promises and values

  Parameter mapFunc

  map function which may return a promise or value

  Returns

  a promise that will fulfill with an array of mapped values or reject if any input promise rejects.

function promise

promise: <T>(
    resolver: (resolve: (value: T) => void, reject: (reason: any) => void) => void
) => Promise<T>;

function reduce

reduce: <T>(
    promisesOrValues: any[],
    reduceFunc: (reduction: T, value: any, index: number) => T | Promise<T>,
    initialValue: T
) => Promise<T>;

• Traditional reduce function, similar to Array.prototype.reduce(), but input may contain promises and/or values, and reduceFunc may return either a value or a promise, *and* initialValue may be a promise for the starting value.

  Parameter promisesOrValues

  array or promise for an array of anything, may contain a mix of promises and values.

  Parameter reduceFunc

  function(accumulated:*, x:*, index:number):*} f reduce function

  Returns

  a promise that will resolve to the final reduced value

function reduceRight

reduceRight: <T>(
    promisesOrValues: any[],
    reduceFunc: (reduction: T, value: any, index: number) => T | Promise<T>,
    initialValue: T
) => Promise<T>;

• Traditional reduce function, similar to Array.prototype.reduceRight(), but input may contain promises and/or values, and reduceFunc may return either a value or a promise, *and* initialValue may be a promise for the starting value.

  Parameter promisesOrValues

  array or promise for an array of anything, may contain a mix of promises and values.

  Parameter reduceFunc

  function(accumulated:*, x:*, index:number):*} f reduce function

  Returns

  a promise that will resolve to the final reduced value

function reject

reject: <T>(reason: any) => Promise<T>;

function resolve

resolve: {
    (): Promise<void>;
    <T>(promiseOrValue: T | Promise<T> | Thenable<T>): Promise<T>;
};

• Returns a resolved promise. The returned promise will be - fulfilled with promiseOrValue if it is a value, or - if promiseOrValue is a promise - fulfilled with promiseOrValue's value after it is fulfilled - rejected with promiseOrValue's reason after it is rejected

function settle

settle: <T>(promisesOrValues: any[]) => Promise<Array<Descriptor<T>>>;

• Returns a promise for an array containing the same number of elements as the input array. Each element is a descriptor object describing of the outcome of the corresponding element in the input. The returned promise will only reject if array itself is a rejected promise. Otherwise, it will always fulfill with an array of descriptors. This is in contrast to when.all, which will reject if any element of array rejects.

  Parameter promisesOrValues

  array of anything, may contain a mix of Promises and values

function unfold

unfold: <T, U>(
    unspool: (
        seed: U
    ) =>
        | [T | Promise<T>, U | Promise<U>]
        | Promise<[T | Promise<T>, U | Promise<U>]>,
    predicate: (value: U) => boolean | Promise<boolean>,
    handler: (value: T) => Promise<any> | void,
    seed: U | Promise<U>
) => Promise<void>;

• Similar to when/iterate, when.unfold generates a potentially infinite stream of promises by repeatedly calling unspool until predicate becomes true. when.unfold allows you to thread additional state information through the iteration.

  Parameter unspool

  function that, given a seed, returns a [valueToSendToHandler, newSeed] pair. May return an array, array of promises, promise for an array, or promise for an array of promises.

  Parameter predicate

  function that receives the current seed, and should return truthy when the unfold should stop

  Parameter handler

  function that receives the valueToSendToHandler of the current iteration. This function can process valueToSendToHandler in whatever way you need. It may return a promise to delay the next iteration of the unfold.

  Parameter seed

  initial value provided to the first unspool invocation. May be a promise.

type Descriptor

type Descriptor<T> = FulfilledDescriptor<T> | RejectedDescriptor;

• Describes the outcome of a promise. state may be one of: "fulfilled" - the promise has resolved "rejected" - the promise has rejected

type Snapshot

type Snapshot<T> = FulfilledDescriptor<T> | RejectedDescriptor | PendingDescriptor;

• Snapshot which describes the status of a promise. state may be one of: "fulfilled" - the promise has resolved "rejected" - the promise has rejected "pending" - the promise is still pending to resolve/reject

function apply

apply: {
    <T>(fn: _.NodeFn0<T>, args: any[] | IArguments): when.Promise<T>;
    <T>(fn: _.NodeFn1<any, T>, args: IArguments | any[]): when.Promise<T>;
    <T>(fn: _.NodeFn2<any, any, T>, args: IArguments | any[]): when.Promise<T>;
    <T>(fn: _.NodeFn3<any, any, any, T>, args: IArguments | any[]): when.Promise<T>;
    <T>(
        fn: _.NodeFn4<any, any, any, any, T>,
        args: IArguments | any[]
    ): when.Promise<T>;
    <T>(
        fn: _.NodeFn5<any, any, any, any, any, T>,
        args: IArguments | any[]
    ): when.Promise<T>;
};

function bindCallback

bindCallback: <TArg>(
    arg: when.Promise<TArg>,
    callback: (err: any, arg: TArg) => void
) => when.Promise<TArg>;