Invalid some incompatible instantiation of a error

[Gozala]

Here is a simple code example:

/* @flow */

export type Always = <a> (a:a) => () => a
export const always:Always = (a) => () => a

Which produces a following error:

src/flowing.js:4
  4: export const always:Always = (a) => () => a
                                               ^ a. This type is incompatible with
  4: export const always:Always = (a) => () => a
                                  ^^^^^^^^^^^^^^ some incompatible instantiation of a


Found 1 error

Please also note that flow correctly reports type of always:

<a> (a: a) => () => a
/Users/gozala/Projects/flowing/src/flowing.js:4:14,4:26

But if I inline type annotations everything seems to work fine:

/* @flow */

export const always = <a> (a:a):()=>a => () => a

Also note that flow reports same type for always as before:

<a> (a: a) => () => a
/Users/gozala/Projects/flowing/src/flowing.js:3:14,3:19

It maybe same issue as #928 although I'm not totally sure, if so we should probably keep this and close the other one since this has a lot more simpler example

[samwgoldman]

This is a dupe of #120. The Always type is polymorphic, but Flow doesn't infer polymorphic types. That's why your working example works.

[samwgoldman]

Sorry, not #120, but rather #123.

[Gozala]

This is a dupe of #120. The Always type is polymorphic, but Flow doesn't infer polymorphic types. That's why your working example works.

So are you implying that flow should error in both cases ? If so mind elaborating on why ? Is it still flow being very cautious about possible mutations that could happen to a ?

[samwgoldman]

No, this is a real issue, but there's already an open issue for it—Flow doesn't infer polymorphic function types. This is the same reason why this code doesn't work:

function id(x) { return x };
id(0);
id("");

Flow sees the first invocation and the type of f becomes (x: number) => number. After the second invocation, f becomes (x: number | string) => number | string. That is, Flow never realizes that f is actually <T>(x: T) => T.

It should, and that's what Avik meant in the linked issue when he said Flow isn't "polymorphic enough."

[Gozala]

But why does flow reports correct polymorphic type for both implementations of always then ?