为什么TypeScript不会为此承诺链引发编译错误？

Question

I am still learning Typescript so maybe I am just fundamentally missing something but I do not understand why the following code throws a compilation error:

// An example without Promises (does not compile)
function getAnObject(): Object {
  return { value: 'Hello' };
};

function doSomethingWithAString(input: String) {
  console.log(input);
}

const result = getAnObject();
// error TS2345: Argument of type 'Object' is not assignable to parameter of type 'String' 
doSomethingWithAString(result);

But the following code does not:

// A similar example with Promises (compiles)
function getAnObjectAsync(): Promise<Object> {
  return Promise.resolve({ value: 'Hello' });
};

getAnObjectAsync().then(function (result: String) {
// Throws a runtime exception
console.log(result.toUpperCase());
});

Why does TypeScript not complain that the onfulfilled function of the .then in the Promise example will receive result: Object ?

• Am I doing something wrong?
• Is there something I do not understand about this example?

Answer 1

That's because in TS, the type of functions' arguments are bivariant.

In the case of a Promise.then, any passed function will be accepted provided its argument is either a subtype or supertype of the required type. So an object (Object, {}) will always be accepted. Fortunately, it will still catch widely incompatible types of course; like expecting a { x: string} but receiving a { y: number } so it catches the majority of type errors.

This is a design decision that has pros and cons; (personally, I think it was not worth it) they might even change it in the future since the last few versions of TS clearly take the direction of making TS more and more sound.