返回链式诺言的函数的返回类型

Question

I have a class that returns a chained promise, first promise's type is angular.IPromise<Foo> , the second promise resolves with type angular.IPromise<Bar> .

Why is it the return type of doSomething angular.IPromise<Bar> ?

I would have thought that the return type would be angular.IPromise<Foo> since that's the first thing that is returned by the function. I am aware that then() returns a promise and will wrap what is returned by it into the response of that, but this is still confusing me.

import { Something } from '../somewhere';
import { Bar } from '../somewhereelse';

class Test {
    doSomething(): angular.IPromise<Bar> {
        return Something.getFoo() // getFoo() return type angular.IPromise<Foo>
            .then(() => {
                let x: Bar = {};        
                return x; 
            });
    }
}

Any help would be appreciated. I am more than happy to give any more code if required.

Answer 1

First thing is : you don't return Something.getFoo() . You return Something.getFoo().then(...) . Even if promises are used to execute asynchronous tasks, they are returned immediately.

then() returning a angular.IPromise the returned promise is not the one from Something.getFoo() but the one returned by Something.getFoo().then(...)

and as the callback provided to then() is returning a Bar object: promise.ten(foo=>return new Bar()) your statement actually returns a Promise<Bar> object.

as @TsatsuyukiIshi stated, this is the type definition of angular.IPromise.then :

then<X>(successCallback: (promiseValue: T) => IPromise<X>|X, ...): IPromise<X>

this method is generic, and its return type ( X ) depends on the type that is provided as parameter ( (promiseValue: T) => IPromise<X>|X ).

If you replace X by Bar this is obvious:

then(successCallback: (promiseValue: T) => IPromise<Bar>|Bar, ...): IPromise<Bar>

Answer 2

This returns angular.IPromise<Bar> , provided the code compiles.

Interfaces can map to any amount of classes, and they can be easily identified with the name prefixed with I .

The concrete type would be a detail of Promise implementation, however it satisfies IPromise<Bar> as long as it returns a Bar on resolve.

EDIT: TypeScript determines it via the template parameter in then<TResult>(successCallback: (promiseValue: T) => IPromise<TResult>|TResult, ...): IPromise<TResult> . This determines the return type of the callback statically. source

Also see: Whats the difference between "declare class" and "interface" in TypeScript

Answer 3

If you need to return different types from the result then you can use any type. typescript is not 100% strongly typed language. The type can change at runtime. Actually the parameter from the resolver just ignored and callback returned the type as expected.