Supporting generic type inference over the other higher-order functions

[falsandtru]

Currently, TypeScript infers generic types when referring its type immediately. Its behavior is undesirable for using higher-order functions. The type inference of generics should delay until it will be called.

function flip<a, b, c>(f: (a: a, b: b) => c): (b: b, a: a) => c {
 return (b: b, a: a) => f(a, b);
}
function zip<T, U>(x: T, y: U): [T, U] {
 return [x, y];
}
var expected: <T, U>(y: U, x: T) => [T, U] = flip(zip);
var actual: (y: {}, x: {}) => [{}, {}] = flip(zip);

[fdecampredon]

this issue is really problematic for functional paradigm users :

const map = <T, U>(transform: (t: T) => U) =>
 (arr: T[]) => arr.map(transform)

const identity = <T>(t: T) => t;

const identityStr = (t: string) => t;


const arr: string[] = map(identityStr)(['a']);
const arr1: string[] = map(identity)(['a']); // Type '{}[]' is not assignable to type 'string[]'.

[DanielRosenwasser]

(welcome back François de Campredon (@fdecampredon)!)

[fdecampredon]

(thanks ! :) )

[baio]

Yep, there is to many <any> in my Ramda code.

[Igorbek]

#10247, #9949 for the reference. And see Marin Marinov (@gcnew)'s comment