Ytukyg

Why? To find errors in a large code base, where ng.IPromise and Promise are mixed together.

I have already done that for ng.IPromise typings by modifying this:

interface IPromise<T> {

    then<TResult>(successCallback: (promiseValue: T) => IPromise<TResult>|TResult, errorCallback?: null | undefined, notifyCallback?: (state: any) => any): IPromise<TResult>;

    // ...

}

to this:

interface IPromise<T> {

    then<TResult>(successCallback: (promiseValue: T) => IPromise<TResult>|TResult, errorCallback?: null | undefined, notifyCallback?: (state: any) => any): TResult extends Promise<any> ? never : IPromise<TResult>;

    // ...

}

But native Promise typings are more complex, cause it introduces a PromiseLike type to resolve result of any object which has a then method:

interface PromiseLike<T> {

    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): PromiseLike<TResult1 | TResult2>;

}



interface Promise<T> {

    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<TResult1 | TResult2>;

}

And I want to achieve a behavior, where every PromiseLike except an ng.IPromise resolves.

Have tried to simplify the typings to better understand them. So basically we can simplify the problem to smth like this - how to modify the following typings:

interface Bar<T> {

    then<K>(f: (value: T) => K | Bar<K>): Bar<K>;

}



interface PartialFoo<T> {

    then<K>(f: (value: T) => K | PartialFoo<K>): PartialFoo<K>;

}



interface Foo<T> {

    then<K>(f: (value: T) => K | PartialFoo<K>): Foo<K>;

}

so that:

let a: Foo<string>;

let b: PartialFoo<number>;

let c: Bar<number>;



let x: Foo<string> = a.then(() => a); // is ok

let y: Foo<number> = a.then(() => b); // is ok

let z: never = a.then(() => c); // returns type never, so chaining anything else will give an error

Also another thing, where I don't really understand how Typescript works, why when modifying interfaces in this way:

interface PartialFoo<T> {

    then<K>(f: () => K | PartialFoo<K>): PartialFoo<K>;

}



interface Foo<T> {

    then<K>(f: () => K | PartialFoo<K>): Foo<K>;

}



let a: Foo<string>;

let x = a.then(() => a);

type for x is Foo<Foo<string>>, but in case of:

interface Foo<T> {

    then<K>(f: () => K | Foo<K>): Foo<K>;

}

it's still resolved to Foo<string>. What role value: T is playing, if it's not even used?