Get the type of generic function without invoking the function in typescript

user_1103757 0
Viewed 538

I have a generic function like this:

function foo<T>(val: T) { return val; }

I have some types:

type StringType = string;
type NumType = number;

Now I want to make a reference to the 'foo' function with a given type, but it wont work:

const stringFunc = foo<StringType>;
const numFunc = foo<NumType>;

Note that I don't want to invoke the 'foo' function, otherwise, I could do:

const stringFunc = (val: string) => foo<StringType>(val);
const numFunc = (val: number) => foo<NumType>(val);

Is it possible?

typescript function generics
2 Answers

If you just want to force the type and don't mind extra typing you can do it like this:

const stringFunc: (val: string) => string = foo;
const numFunc: (val: number) => number = foo;

But generally applying the type parameter to a generic function is not possible at the moment.

user_5150350

What about type casting or invoking some other adhoc generic function?

TypeScript REPL

function foo<T>(v: T) { return v }

type UnaryFunction<T> = (v: T) => T


// casting
const asStrFoo = foo as UnaryFunction<string> // asStrFoo(v: string): string
const asNumFoo = foo as UnaryFunction<number> // asNumFoo(v: number): number


// identity function
const bind = <T>(f: UnaryFunction<any>): UnaryFunction<T> => f

const strFoo = bind<string>(foo) // strFoo(v: string): string
const numFoo = bind<number>(foo) // numFoo(v: number): number


// function factory
function hoo<T>() { return function foo(v: T) { return v } }
// function hoo<T>() { return (v: T) => v }

const strHoo = hoo<string>() // strHoo(v: string): string
const numHoo = hoo<number>() // numHoo(v: number): number

note

// This condition will always return 'false' since the types 'UnaryFunction<string>' and 'UnaryFunction<number>' have no overlap.
console.log(strFoo === numFoo) // true
// This condition will always return 'false' since the types 'UnaryFunction<string>' and 'UnaryFunction<number>' have no overlap.
console.log(asStrFoo === asNumFoo) // true
// This condition will always return 'false' since the types '(v: string) => string' and '(v: number) => number' have no overlap.
console.log(strHoo === numHoo) // false
user_9854540
Related