Ability to get generic type from typeof and infer
See original GitHub issueTypeScript version: 3.6.2
Search Terms
typeof generic function return generic type
infer arguments from generic function
Suggestion
I ran into the issue described at #32170, where the answer was
I expect what you’re trying to do is refer to a specific call instantiation of a generic function, which isn’t currently possible.
The feature request is to make this possible.
Examples
In the following code, dragHelperReact
is a helper function for implementing draggable functionality, which also abstracts over Mouse vs Touch events (since Pointer Events are not supported in older browsers). It takes as input three callbacks; since those callbacks have fairly lengthy signatures, I want to infer their argument types. The difficulty is that React.SyntheticEvent
is a generic type, which allows narrowing of e.currentTarget
.
import * as React from "react";
function dragHelper<T>(
move: (e: MouseEvent | TouchEvent, coords: {x: number; y: number; dx: number; dy: number}) => void,
down: (
e: React.MouseEvent<T> | React.TouchEvent<T>,
coords: {x: number; y: number},
upHandler: (e: MouseEvent | TouchEvent) => void,
moveHandler: (e: MouseEvent | TouchEvent) => void
) => void,
up: (e: MouseEvent | TouchEvent) => void
) {
return {
onMouseDown: () => {
/* implementation */
}
};
}
type Args<T extends (...args: any) => any> = T extends (...args: infer A) => ReturnType<T> ? A : void;
type Move = typeof dragHelperReact extends (down: infer M, move: infer D, up: infer U) => void ? M : never;
type Down = typeof dragHelperReact extends (move: infer M, down: infer D, up: infer U) => void ? D : never;
type Up = typeof dragHelperReact extends (move: infer M, down: infer D, up: infer U) => void ? U : never;
// these work
type MoveArgs = Args<Move>;
type UpArgs = Args<Up>;
// I want to do something like this; it does not work.
type DownArgs<T> = Args<Down<T>>;
// This is a workaround I tried; it does not work either.
type DownArgs<T> = Down extends (e: any, ...args: infer U) => void ? [React.MouseEvent<T> | React.TouchEvent<T>, ...U] : never;
// This workaround works.
type DownArgs<T> = Down extends (e: any, ...args: infer U) => void ? [React.MouseEvent<T> | React.TouchEvent<T>, U[0], U[1], U[2]] : never;
class Example extends React.Component {
down(...[e, coords, upHandler, downHandler]: DownArgs<HTMLDivElement>) {
// e.currentTarget is narrowed to HTMLDivElement
}
move(...[e, coords]: MoveArgs) {}
up(...[e]: UpArgs) {}
render() {
return (
<div {...dragHelper(this.move, this.down, this.up)}/>
);
}
}
Checklist
My suggestion meets these guidelines:
- This wouldn’t be a breaking change in existing TypeScript/JavaScript code
- This wouldn’t change the runtime behavior of existing JavaScript code
- This could be implemented without emitting different JS based on the types of the expressions
- This isn’t a runtime feature (e.g. library functionality, non-ECMAScript syntax with JavaScript output, etc.)
- This feature would agree with the rest of TypeScript’s Design Goals.
Issue Analytics
- State:
- Created 4 years ago
- Reactions:6
- Comments:5 (2 by maintainers)
Top GitHub Comments
With #47607 it is possible to refer to specific instantiations of generic functions.
Ran into this, too:
I don’t know how to best handle specific instantiations of generic functions on their own (eg
typeof something<number>
, but maybeReturnType
andParameters
could accept optional additional type parameters for this?