Description
TypeScript Version: 3.5.1
Search Terms:
return type, generic, constraint, assignable, correlated type
Code
type XStr = {x:string};
type XNum = {x:number};
type U = XStr|XNum;
type Args = { str : XStr, num : XNum };
declare function foo<
ReturnT extends U,
ValueT extends ReturnT["x"]
> (
f : (args : Args) => ReturnT,
value : ValueT
) : void;
/*
Error as expected.
Type 'string | number' does not satisfy the constraint 'string'.
Type 'number' is not assignable to type 'string'.
*/
foo<XStr, string|number>(
(args:Args) => args.str,
""
);
//Inferred type, foo<XStr, string | number>
foo(
args => args.str,
//Expected: Error
//Actual: OK
"" as string|number
);
//Inferred type, foo<XStr, string>
foo(
//Added explicit type annotation to function params
(args:Args) => args.str,
/*
Error as expected.
Type 'string | number' does not satisfy the constraint 'string'.
Type 'number' is not assignable to type 'string'.
*/
"" as string|number
);
/////
/*
Error as expected.
Type '1' does not satisfy the constraint 'string'.
*/
foo<XStr, 1>(
(args:Args) => args.str,
1
);
//Inferred type, foo<XStr, 1>
foo(
args => args.str,
//Expected: Error
//Actual: OK
1
);
//Inferred type, foo<XStr, string>
foo(
//Added explicit type annotation to function params
(args:Args) => args.str,
/*
Error as expected.
Type '1' does not satisfy the constraint 'string'.
*/
1
);
Expected behavior:
I'm just calling it a correlated type because it reminds me of correlated subqueries from SQL.
- The constraint type of
ValueT
is dependent on the type ofReturnT
. - When
f
does not have parameters, or all parameters are explicitly annotated,
ValueT
is inferred correctly. - When
f
has parameters that are not explicitly annotated,
ValueT
is inferred incorrectly. - Attempting to explicitly set invalid type paramters will error as expected.
foo<XStr, string|number>
should not be allowedfoo<XStr, 1>
should not be allowed
Actual behavior:
foo<XStr, string|number>
is allowed under inferencefoo<XStr, 1>
is allowed under inference
Playground Link:
Related Issues:
A different, more complex example,
#14829 (comment)
[Edit]
Can someone come up with a better name for this?
I'm working on rewriting my type-safe SQL builder library and it relies on the return type of generic functions being inferred correctly. But it seems like return type inference just breaks in so many unexpected ways.
Anonymous callback functions are used a lot for building the WHERE
, ORDER BY
, GROUP BY
, HAVING
, JOIN
, etc. clauses.
Since return type inference for generic functions is not robust, it's basically a blocker for me =(