Support higher order inferences for constructor functions

[Anders Hejlsberg (ahejlsberg)]

This PR expands on #30215 to support higher order inferences for constructor functions and to permit function type arguments to higher order composition functions to have other members in addition to their single call signature.

Some examples:

declareclassPoint{constructor(x: number,y: number);readonlyx: number;readonlyy: number;}declareclassBag<T>{constructor(...args: T[]);contains(value: T): boolean;staticfoo: string;}functionasFunction<Aextendsany[],B>(cf: new(...args: A)=>B){return(...args: A)=>newcf(...args);}constnewPoint=asFunction(Point);// (x: number, y: number) => PointconstnewBag=asFunction(Bag);// <T>(...args: T[]) => Bag<T>constp1=newPoint(10,20);// Pointconstp2=newPoint(10,20);// Pointconstbag1=newBag(1,2,3);// Bag<number>constbag2=newBag('a','b','c');// Bag<string>declareclassComponent<P>{props: P;constructor(props: P);}typeComponentClass<P>=new(props: P)=>Component<P>;declarefunctionmyHoc<P>(C: ComponentClass<P>): ComponentClass<P>;typeGenericProps<T>={foo: number,stuff: T};declareclassGenericComponent<T>extendsComponent<GenericProps<T>>{}// const GenericComponent2: new <T>(props: GenericProps<T>) => Component<GenericProps<T>>constGenericComponent2=myHoc(GenericComponent);

The rules for determining when higher order inferences occur are revised as follows. Given a generic function f of type <…>(…, x: P, …) => R, and an argument expression a of a generic function type A, in a call expression f(…, a, …) the type parameters of A are propagated onto the inferred result type of the function call if:

• P is a function type with no type arguments, a single call or construct signature, and no other members, and
• R is a function type with no type arguments, a single call or construct signature, and no other members, and
• A is function type with type arguments and a single call or construct signature that matches P (note that A is permitted to have other members), and
• in the left-to-right processing of the function call arguments, no inferences have been made for any of the type parameters referenced in P.

Fixes#30650.

[Anders Hejlsberg (ahejlsberg)]

TypeScript Bot (@typescript-bot) test this

[TypeScript Bot (typescript-bot)]

Heya Anders Hejlsberg (@ahejlsberg), I've started to run the extended test suite on this PR at fcd6f52. You can monitor the build here. It should now contribute to this PR's status checks.

[Anders Hejlsberg (ahejlsberg)]

TypeScript Bot (@typescript-bot) run dt

[TypeScript Bot (typescript-bot)]

Heya Anders Hejlsberg (@ahejlsberg), I've started to run the parallelized Definitely Typed test suite on this PR at fcd6f52. You can monitor the build here. It should now contribute to this PR's status checks.

[Anders Hejlsberg (ahejlsberg)]

TypeScript Bot (@typescript-bot) run dt

[TypeScript Bot (typescript-bot)]

Heya Anders Hejlsberg (@ahejlsberg), I've started to run the parallelized Definitely Typed test suite on this PR at 4fe59dc. You can monitor the build here. It should now contribute to this PR's status checks.

[Wesley Wigham (weswigham)]

The react-test-renderer failure is in master, so I think DT is clean.

[Anders Hejlsberg (ahejlsberg)]

TypeScript Bot (@typescript-bot) run dt

[TypeScript Bot (typescript-bot)]

Heya Anders Hejlsberg (@ahejlsberg), I've started to run the parallelized Definitely Typed test suite on this PR at 3e79e8d. You can monitor the build here. It should now contribute to this PR's status checks.

[Guy Kremnitzer (guykr)]

Hi Ryan Cavanaugh (@RyanCavanaugh)Anders Hejlsberg (@ahejlsberg),
when trying to use this new mechanism with React's ComponentClass I noticed this does not actually work, the inferred type is actually: const GenericComponent2: ComponentClass<GenericProps<unknown>> not const GenericComponent2: new <T>(props: GenericProps<T>) => Component<GenericProps<T>>

Please find below an adapted example from the one in this PR:

declareclassPoint{constructor(x: number,y: number)readonlyx: numberreadonlyy: number}declareclassBag<T>{constructor(...args: T[])contains(value: T): booleanstaticfoo: string}functionasFunction<Aextendsany[],B>(cf: new(...args: A)=>B){return(...args: A)=>newcf(...args)}constnewPoint=asFunction(Point)// (x: number, y: number) => PointconstnewBag=asFunction(Bag)// <T>(...args: T[]) => Bag<T>constp1=newPoint(10,20)// Pointconstp2=newPoint(10,20)// Pointconstbag1=newBag(1,2,3)// Bag<number>constbag2=newBag('a','b','c')// Bag<string>declareclassComponent<P>{props: Pconstructor(props: P)}interfaceComponentClass<P>{new(props: P): Component<P>thisWillBreakGenericInference?: boolean// <--- this is breaking the type inference}declarefunctionmyHoc<P>(C: ComponentClass<P>): ComponentClass<P>typeGenericProps<T>={foo: number;stuff: T}declareclassGenericComponent<T>extendsComponent<GenericProps<T>>{}// Should be:// const GenericComponent2: new <T>(props: GenericProps<T>) => Component<GenericProps<T>>// Actually: // const GenericComponent2: ComponentClass<GenericProps<unknown>>constGenericComponent2=myHoc(GenericComponent)

Link to playground:
The change I made is in line 31.

The issue here is that React's ComponentClass interface has a few optional members defined.

[Anders Hejlsberg (ahejlsberg)]

@guykr-stratoscale That's a known limitation. See discussion in #30650 (comment).

[Jeanette Vang (RichardForrester)]

It's really encouraging that TS is getting some more support for functional programmers. Keep up the good work!

Small critique on the announcement docs. The function you guys are showing off as compose is backwards and without currying is not really a realistic implementation.

functioncompose<T,U,V>(f: (x: T)=>U,g: (y: U)=>V): (x: T)=>V{returnx=>g(f(x))}

Based on all of the below resources:

-- Haskell(.):: (b->c) -> (a->b) ->a->c

// Sanctuary.js
compose :: Semigroupoids=>sbc->sab->sac// fp-tsexportinterfaceSemigroupoid<F>{readonlyURI: Freadonlycompose: <E,A,B>(ab: HKT2<F,A,B>,la: HKT2<F,E,A>)=>HKT2<F,E,B>}// Ramda(b->c)->(a->b)->a->c// CrockscomposeB :: (b->c)->(a->b)->a->c

I understand the the announcement docs are just for simple illustration, and it's great. I'm thrilled about the attention to the functional side of javascript. But it would be nice to have simple and correct code for the docs, maybe something like:

typefn1<I,O>=(i: I)=>Otypecompose=<Textendsany,U,V>(f: fn1<U,V>)=>(g: fn1<T,U>)=>fn1<T,V>constcompose: compose=f=>g=>a=>f(g(a))