kylefang/DefinitelyTyped
1
0
Fork 0
mirror of https://github.com/zhigang1992/DefinitelyTyped.git synced 2026-04-23 12:56:46 +08:00
Code Issues Packages Projects Releases Wiki Activity

Use helper interfaces and unions to define variadic functions up to 5 arguments

Browse Source
This commit is contained in:
Wim Looman
2015-01-22 16:46:16 +13:00
parent 484aff0c24
commit 892d67aa03
1 changed files with 132 additions and 71 deletions
Download Patch File Download Diff File Expand all files Collapse all files

203
when/when.d.ts vendored
View File

@@ -12,29 +12,79 @@ declare function When<T, U>(value: When.Thenable<T>, transform: (val: T) => U):
declare function When<T, U>(value: T, transform: (val: T) => U): When.Promise<U>;
declare module When {
function attempt<T>(f: () => T): Promise<T>;
// Helper interfaces
module _ {
interface Fn0<T> { (): T }
interface Fn1<A1, T> { (a1: A1): T }
interface Fn2<A1, A2, T> { (a1: A1, a2: A2): T }
interface Fn3<A1, A2, A3, T> { (a1: A1, a2: A2, a3: A3): T }
interface Fn4<A1, A2, A3, A4, T> { (a1: A1, a2: A2, a3: A3, a4: A4): T }
interface Fn5<A1, A2, A3, A4, A5, T> { (a1: A1, a2: A2, a3: A3, a4: A4, a5: A5): T }
interface Fn6<A1, A2, A3, A4, A5, A6, T> { (a1: A1, a2: A2, a3: A3, a4: A4, a5: A5, a6: A6): T }
function attempt<T, A>(f: (a: A) => T, a: Promise<A>): Promise<T>;
function attempt<T, A>(f: (a: A) => T, a: A): Promise<T>;
interface LiftedFn0<T> extends Fn0<Promise<T>> { }
interface LiftedFn1<A1, T> extends Fn1<A1 | Promise<A1>, Promise<T>> { }
interface LiftedFn2<A1, A2, T> extends Fn2<A1 | Promise<A1>, A2 | Promise<A2>, Promise<T>> { }
interface LiftedFn3<A1, A2, A3, T> extends Fn3<A1 | Promise<A1>, A2 | Promise<A2>, A3 | Promise<A3>, Promise<T>> { }
interface LiftedFn4<A1, A2, A3, A4, T> extends Fn4<A1 | Promise<A1>, A2 | Promise<A2>, A3 | Promise<A3>, A4 | Promise<A4>, Promise<T>> { }
interface LiftedFn5<A1, A2, A3, A4, A5, T> extends Fn5<A1 | Promise<A1>, A2 | Promise<A2>, A3 | Promise<A3>, A4 | Promise<A4>, A5 | Promise<A5>, Promise<T>> { }
function attempt<T, A, B>(f: (a: A, b: B) => T, a: Promise<A>, b: Promise<B>): Promise<T>;
function attempt<T, A, B>(f: (a: A, b: B) => T, a: Promise<A>, b: B): Promise<T>;
function attempt<T, A, B>(f: (a: A, b: B) => T, a: A, b: Promise<B>): Promise<T>;
function attempt<T, A, B>(f: (a: A, b: B) => T, a: A, b: B): Promise<T>;
interface NodeCallback<T> { (err: any, result: T): void }
function attempt<T, A, B, C>(f: (a: A, b: B, c: C) => T, a: Promise<A>, b: Promise<B>, c: Promise<C>): Promise<T>;
function attempt<T, A, B, C>(f: (a: A, b: B, c: C) => T, a: Promise<A>, b: Promise<B>, c: C): Promise<T>;
function attempt<T, A, B, C>(f: (a: A, b: B, c: C) => T, a: Promise<A>, b: B, c: Promise<C>): Promise<T>;
function attempt<T, A, B, C>(f: (a: A, b: B, c: C) => T, a: Promise<A>, b: B, c: C): Promise<T>;
function attempt<T, A, B, C>(f: (a: A, b: B, c: C) => T, a: A, b: Promise<B>, c: Promise<C>): Promise<T>;
function attempt<T, A, B, C>(f: (a: A, b: B, c: C) => T, a: A, b: Promise<B>, c: C): Promise<T>;
function attempt<T, A, B, C>(f: (a: A, b: B, c: C) => T, a: A, b: B, c: Promise<C>): Promise<T>;
function attempt<T, A, B, C>(f: (a: A, b: B, c: C) => T, a: A, b: B, c: C): Promise<T>;
interface NodeFn0<T> extends _.Fn1<NodeCallback<T>, void> { }
interface NodeFn1<A1, T> extends _.Fn2<A1, NodeCallback<T>, void> { }
interface NodeFn2<A1, A2, T> extends _.Fn3<A1, A2, NodeCallback<T>, void> { }
interface NodeFn3<A1, A2, A3, T> extends _.Fn4<A1, A2, A3, NodeCallback<T>, void> { }
interface NodeFn4<A1, A2, A3, A4, T> extends _.Fn5<A1, A2, A3, A4, NodeCallback<T>, void> { }
interface NodeFn5<A1, A2, A3, A4, A5, T> extends _.Fn6<A1, A2, A3, A4, A5, NodeCallback<T>, void> { }
}
function lift<T>(f: () => T): () => Promise<T>;
function lift<T, A>(f: (a: A) => T): (a: Promise<A>) => Promise<T>;
function lift<T, A, B>(f: (a: A, b: B) => T): (a: Promise<A>, b: Promise<B>) => Promise<T>;
function lift<T, A, B, C>(f: (a: A, b: B, c: C) => T): (a: Promise<A>, b: Promise<B>, c: Promise<C>) => Promise<T>;
function attempt<T>(
f: _.Fn0<T>
): Promise<T>;
function attempt<A1, T>(
f: _.Fn1<A1, T>,
arg1: A1 | Promise<A1>
): Promise<T>;
function attempt<A1, A2, T>(
f: _.Fn2<A1, A2, T>,
arg1: A1 | Promise<A1>,
arg2: A2 | Promise<A2>
): Promise<T>;
function attempt<A1, A2, A3, T>(
f: _.Fn3<A1, A2, A3, T>,
arg1: A1 | Promise<A1>,
arg2: A2 | Promise<A2>,
arg3: A3 | Promise<A3>
): Promise<T>;
function attempt<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>;
function attempt<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 lift<T>(f: _.Fn0<T>): _.LiftedFn0<T>;
function lift<A1, T>(f: _.Fn1<A1, T>): _.LiftedFn1<A1, T>;
function lift<A1, A2, T>(f: _.Fn2<A1, A2, T>): _.LiftedFn2<A1, A2, T>;
function lift<A1, A2, A3, T>(f: _.Fn3<A1, A2, A3, T>): _.LiftedFn3<A1, A2, A3, T>;
function lift<A1, A2, A3, A4, T>(f: _.Fn4<A1, A2, A3, A4, T>): _.LiftedFn4<A1, A2, A3, A4, T>;
function lift<A1, A2, A3, A4, A5, T>(f: _.Fn5<A1, A2, A3, A4, A5, T>): _.LiftedFn5<A1, A2, A3, A4, A5, T>;
function promise<T>(resolver: (resolve: (value: T) => void, reject: (reason: any) => void) => void): Promise<T>;
@@ -92,16 +142,13 @@ declare module When {
}
interface Promise<T> {
catch<U>(onRejected?: (reason: any) => Promise<U>): Promise<U>;
catch<U>(onRejected?: (reason: any) => U): Promise<U>;
catch<U>(onRejected?: (reason: any) => U | Promise<U>): Promise<U>;
catch<U>(filter: (reason: any) => boolean, onRejected?: (reason: any) => Promise<U>): Promise<U>;
catch<U>(filter: (reason: any) => boolean, onRejected?: (reason: any) => U): Promise<U>;
catch<U>(filter: (reason: any) => boolean, onRejected?: (reason: any) => U | Promise<U>): Promise<U>;
// Make sure you test any usage of these overloads, exceptionType must
// be a constructor with prototype set to an instance of Error.
catch<U>(exceptionType: any, onRejected?: (reason: any) => Promise<U>): Promise<U>;
catch<U>(exceptionType: any, onRejected?: (reason: any) => U): Promise<U>;
finally(onFulfilledOrRejected: Function): Promise<T>;
@@ -109,8 +156,7 @@ declare module When {
inspect(): Snapshot<T>;
yield<U>(value: Promise<U>): Promise<U>;
yield<U>(value: U): Promise<U>;
yield<U>(value: U | Promise<U>): Promise<U>;
else(value: T): Promise<T>;
orElse(value: T): Promise<T>;
@@ -124,29 +170,19 @@ declare module When {
with(thisArg: any): Promise<T>;
withThis(thisArg: any): Promise<T>;
otherwise<U>(onRejected?: (reason: any) => Promise<U>): Promise<U>;
otherwise<U>(onRejected?: (reason: any) => U): Promise<U>;
otherwise<U>(onRejected?: (reason: any) => U | Promise<U>): Promise<U>;
otherwise<U>(predicate: (reason: any) => boolean, onRejected?: (reason: any) => Promise<U>): Promise<U>;
otherwise<U>(predicate: (reason: any) => boolean, onRejected?: (reason: any) => U): Promise<U>;
otherwise<U>(predicate: (reason: any) => boolean, onRejected?: (reason: any) => U | Promise<U>): Promise<U>;
// Make sure you test any usage of these overloads, exceptionType must
// be a constructor with prototype set to an instance of Error.
otherwise<U>(exceptionType: any, onRejected?: (reason: any) => Promise<U>): Promise<U>;
otherwise<U>(exceptionType: any, onRejected?: (reason: any) => U): Promise<U>;
otherwise<U>(exceptionType: any, onRejected?: (reason: any) => U | Promise<U>): Promise<U>;
then<U>(onFulfilled: (value: T) => Promise<U>, onRejected?: (reason: any) => Promise<U>, onProgress?: (update: any) => void): Promise<U>;
then<U>(onFulfilled: (value: T) => Promise<U>, onRejected?: (reason: any) => U, onProgress?: (update: any) => void): Promise<U>;
then<U>(onFulfilled: (value: T) => U, onRejected?: (reason: any) => Promise<U>, onProgress?: (update: any) => void): Promise<U>;
then<U>(onFulfilled: (value: T) => U, onRejected?: (reason: any) => U, onProgress?: (update: any) => void): Promise<U>;
then<U>(onFulfilled: (value: T) => U | Promise<U>, onRejected?: (reason: any) => U | Promise<U>, onProgress?: (update: any) => void): Promise<U>;
done<U>(onFulfilled: (value: T) => void, onRejected?: (reason: any) => void): void;
fold<U, V>(combine: (value1: T, value2: V) => Promise<U>, value2: V): Promise<U>;
fold<U, V>(combine: (value1: T, value2: V) => Promise<U>, value2: Promise<V>): Promise<U>;
fold<U, V>(combine: (value1: T, value2: V) => U, value2: V): Promise<U>;
fold<U, V>(combine: (value1: T, value2: V) => U, value2: Promise<V>): Promise<U>;
fold<U, V>(combine: (value1: T, value2: V) => U | Promise<U>, value2: V | Promise<V>): Promise<U>;
}
interface Thenable<T> {
@@ -166,42 +202,67 @@ declare module "when" {
declare module "when/node" {
import when = require('when');
import _ = when._;
function lift<TResult>(fn: (callback: (err: any, result: TResult) => void) => void): () => when.Promise<TResult>;
function lift<TArg1, TResult>(fn: (arg1: TArg1, callback: (err: any, result: TResult) => void) => void): (arg1: when.Promise<TArg1>) => when.Promise<TResult>;
function lift<TArg1, TArg2, TResult>(fn: (arg1: TArg1, arg2: TArg2, callback: (err: any, result: TResult) => void) => void): (arg1: when.Promise<TArg1>, arg2: when.Promise<TArg2>) => when.Promise<TResult>;
function lift<TArg1, TArg2, TArg3, TResult>(fn: (arg1: TArg1, arg2: TArg2, arg3: TArg3, callback: (err: any, result: TResult) => void) => void): (arg1: when.Promise<TArg1>, arg2: when.Promise<TArg2>, arg3: when.Promise<TArg3>) => when.Promise<TResult>;
function lift<T>(fn: _.NodeFn0<T>): _.LiftedFn0<T>;
function lift<A1, T>(fn: _.NodeFn1<A1, T>): _.LiftedFn1<A1, T>;
function lift<A1, A2, T>(fn: _.NodeFn2<A1, A2, T>): _.LiftedFn2<A1, A2, T>;
function lift<A1, A2, A3, T>(fn: _.NodeFn3<A1, A2, A3, T>): _.LiftedFn3<A1, A2, A3, T>;
function lift<A1, A2, A3, A4, T>(fn: _.NodeFn4<A1, A2, A3, A4, T>): _.LiftedFn4<A1, A2, A3, A4, T>;
function lift<A1, A2, A3, A4, A5, T>(fn: _.NodeFn5<A1, A2, A3, A4, A5, T>): _.LiftedFn5<A1, A2, A3, A4, A5, T>;
function call<T>(
fn: _.NodeFn0<T>
): when.Promise<T>;
function call<A1, T>(
fn: _.NodeFn1<A1, T>,
arg1: A1 | when.Promise<A1>
): when.Promise<T>;
function call<A1, A2, T>(
fn: _.NodeFn2<A1, A2, T>,
arg1: A1 | when.Promise<A1>,
arg2: A2 | when.Promise<A2>
): when.Promise<T>;
function call<A1, A2, A3, T>(
fn: _.NodeFn3<A1, A2, A3, T>,
arg1: A1 | when.Promise<A1>,
arg2: A2 | when.Promise<A2>,
arg3: A3 | when.Promise<A3>
): when.Promise<T>;
function call<A1, A2, A3, A4, T>(
fn: _.NodeFn4<A1, A2, A3, A4, T>,
arg1: A1 | when.Promise<A1>,
arg2: A2 | when.Promise<A2>,
arg3: A3 | when.Promise<A3>,
arg4: A4 | when.Promise<A4>
): when.Promise<T>;
function call<A1, A2, A3, A4, A5, T>(
fn: _.NodeFn5<A1, A2, A3, A4, A5, T>,
arg1: A1 | when.Promise<A1>,
arg2: A2 | when.Promise<A2>,
arg3: A3 | when.Promise<A3>,
arg4: A4 | when.Promise<A4>,
arg5: A5 | when.Promise<A5>
): when.Promise<T>;
function apply<T>(fn: _.NodeFn0<T>, args: any[]): when.Promise<T>;
function apply<T>(fn: _.NodeFn1<any, T>, args: any[]): when.Promise<T>;
function apply<T>(fn: _.NodeFn2<any, any, T>, args: any[]): when.Promise<T>;
function apply<T>(fn: _.NodeFn3<any, any, any, T>, args: any[]): when.Promise<T>;
function apply<T>(fn: _.NodeFn4<any, any, any, any, T>, args: any[]): when.Promise<T>;
function apply<T>(fn: _.NodeFn5<any, any, any, any, any, T>, args: any[]): when.Promise<T>;
function liftAll(srcApi: any, transform?: (destApi: any, liftedFunc: Function, name: string) => any, destApi?: any): any;
function call<TResult>(fn: (callback: (err: any, result: TResult) => void) => void): when.Promise<TResult>;
function call<TArg1, TResult>(fn: (arg1: TArg1, callback: (err: any, result: TResult) => void) => void, arg1: TArg1): when.Promise<TResult>;
function call<TArg1, TResult>(fn: (arg1: TArg1, callback: (err: any, result: TResult) => void) => void, arg1: when.Promise<TArg1>): when.Promise<TResult>;
function call<TArg1, TArg2, TResult>(fn: (arg1: TArg1, arg2: TArg2, callback: (err: any, result: TResult) => void) => void, arg1: TArg1, arg2: TArg2): when.Promise<TResult>;
function call<TArg1, TArg2, TResult>(fn: (arg1: TArg1, arg2: TArg2, callback: (err: any, result: TResult) => void) => void, arg1: when.Promise<TArg1>, arg2: TArg2): when.Promise<TResult>;
function call<TArg1, TArg2, TResult>(fn: (arg1: TArg1, arg2: TArg2, callback: (err: any, result: TResult) => void) => void, arg1: TArg1, arg2: when.Promise<TArg2>): when.Promise<TResult>;
function call<TArg1, TArg2, TResult>(fn: (arg1: TArg1, arg2: TArg2, callback: (err: any, result: TResult) => void) => void, arg1: when.Promise<TArg1>, arg2: when.Promise<TArg2>): when.Promise<TResult>;
function call<TArg1, TArg2, TArg3, TResult>(fn: (arg1: TArg1, arg2: TArg2, arg3: TArg3, callback: (err: any, result: TResult) => void) => void, arg1: TArg1, arg2: TArg2, arg3: TArg3): when.Promise<TResult>;
function call<TArg1, TArg2, TArg3, TResult>(fn: (arg1: TArg1, arg2: TArg2, arg3: TArg3, callback: (err: any, result: TResult) => void) => void, arg1: TArg1, arg2: TArg2, arg3: when.Promise<TArg3>): when.Promise<TResult>;
function call<TArg1, TArg2, TArg3, TResult>(fn: (arg1: TArg1, arg2: TArg2, arg3: TArg3, callback: (err: any, result: TResult) => void) => void, arg1: TArg1, arg2: when.Promise<TArg2>, arg3: TArg3): when.Promise<TResult>;
function call<TArg1, TArg2, TArg3, TResult>(fn: (arg1: TArg1, arg2: TArg2, arg3: TArg3, callback: (err: any, result: TResult) => void) => void, arg1: TArg1, arg2: when.Promise<TArg2>, arg3: when.Promise<TArg3>): when.Promise<TResult>;
function call<TArg1, TArg2, TArg3, TResult>(fn: (arg1: TArg1, arg2: TArg2, arg3: TArg3, callback: (err: any, result: TResult) => void) => void, arg1: when.Promise<TArg1>, arg2: TArg2, arg3: TArg3): when.Promise<TResult>;
function call<TArg1, TArg2, TArg3, TResult>(fn: (arg1: TArg1, arg2: TArg2, arg3: TArg3, callback: (err: any, result: TResult) => void) => void, arg1: when.Promise<TArg1>, arg2: TArg2, arg3: when.Promise<TArg3>): when.Promise<TResult>;
function call<TArg1, TArg2, TArg3, TResult>(fn: (arg1: TArg1, arg2: TArg2, arg3: TArg3, callback: (err: any, result: TResult) => void) => void, arg1: when.Promise<TArg1>, arg2: when.Promise<TArg2>, arg3: TArg3): when.Promise<TResult>;
function call<TArg1, TArg2, TArg3, TResult>(fn: (arg1: TArg1, arg2: TArg2, arg3: TArg3, callback: (err: any, result: TResult) => void) => void, arg1: when.Promise<TArg1>, arg2: when.Promise<TArg2>, arg3: when.Promise<TArg3>): when.Promise<TResult>;
function apply<TResult>(fn: (callback: (err: any, result: TResult) => void) => void, args: any[]): when.Promise<TResult>;
function apply<TResult>(fn: (arg1: any, callback: (err: any, result: TResult) => void) => void, args: any[]): when.Promise<TResult>;
function apply<TResult>(fn: (arg1: any, arg2: any, callback: (err: any, result: TResult) => void) => void, args: any[]): when.Promise<TResult>;
function apply<TResult>(fn: (arg1: any, arg2: any, arg3: any, callback: (err: any, result: TResult) => void) => void, args: any[]): when.Promise<TResult>;
function liftCallback<TArg>(callback: (err: any, arg: TArg) => void): (value: when.Promise<TArg>) => when.Promise<TArg>;