Flowtype Javascript推理未按预期工作

Question

I'm unable to figure out why Flow cannot correctly infer the return type from the Reference #1 map function if Reference #2 is not commented out.

If Reference #2 is commented out OR if I explicitly denote Mappable<B> as the return type for Reference #1 all is good.

const map = <A, B>(transform: Transform<A, B>, mappable: Mappable<A>): Mappable<B> => mappable.map(transform);

Would love to know why this is working the way it is! Thanks!

// Types
type Transform<A, B> = (value: A) => B;

// Classes
class Mappable<A> {
  __value: A;
  constructor(value: A) {
    this.__value = value;
  }
  map<B>(transform: Transform<A, B>): Mappable<B> {
    return new Mappable(transform(this.__value));
  }
}

class Container<A> extends Mappable<A> {}

// Transformations
const stringToBase10Number = (value: string): number => parseInt(value, 10);
const numberToString = (value: number): string => value.toString();

// Map Utility (Reference #1)
const map = <A, B>(transform: Transform<A, B>, mappable: Mappable<A>) => mappable.map(transform);

// Log Utility
const log = <T>(value: T): T => { console.log(value); return value; }

// Test Case
const fooContainer = new Container('10');

const fooNumberContainer = map(stringToBase10Number, fooContainer);
map(log, fooNumberContainer); // Logs '1' to the console

// Reference #2
const fooStringContainer = map(numberToString, fooNumberContainer);
map(log, fooStringContainer);

Error:

const fooStringContainer = map(numberToString, fooNumberContainer);
                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function call
const map = <A, B>(transform: Transform<A, B>, mappable: Mappable<A>) => mappable.map(transform);
                ^ B. This type is incompatible with
const numberToString = (value: number): string => value.toString();
                               ^^^^^^ number

Answer 1

Try adding a return type to the map function. So change

const map = <A, B>(transform: Transform<A, B>, mappable: Mappable<A>) => mappable.map(transform);

to

const map = <A, B>(transform: Transform<A, B>, mappable: Mappable<A>): Mappable<B> => mappable.map(transform);

Your full example before

Your full example after

Why is this return type annotation needed? It's because Flow does not infer polymorphic types. If the function always returned a string , it wouldn't matter. But since it returns Mappable<B> , the annotation is needed.

Here is another answer that also addresses this problem: Polymorphic Anonymous Functions Type Aliases