How To Strongly Type Functions with Variable Arguments

Question

I'm writing a Parser Combinator in Typescript. One of the functions is meant to take another function with any type signature and some number of arguments, then call it:

function f(func, ...args) {
  func.apply(null, args);
}

Is there any way to strongly type this so that the function can be called like this:

f(
  (s: string) => { console.log(s) },
  "Hello world!"
)

But have it fail with incorrectly typed arguments, or an incorrect number of them?

f(
  (s: string) => { console.log(s) },
  1234.56 // incorrect type
)

f(
  (s: string) => { console.log(s) },
  "Hello",
  "World" // too many arguments
)

(Some additional processing happens in f, which is why I don't just call func directly).

Do you mean for any function and its arguments, or specifically for the one you show? I mean, f(func: (s: string) => void, arg: string): void would work for what you've shown, but I get the feeling it's not that easy... — Heretic Monkey
– Heretic Monkey, Commented Feb 12, 2018 at 16:51
Related issue on GitHub: github.com/Microsoft/TypeScript/issues/14719 — Nathan Friend
– Nathan Friend, Commented Feb 12, 2018 at 16:52
@MikeMcCaughan I was hoping to pass in any function with any signature. Edited the question for clarity. — Valhalla
– Valhalla, Commented Feb 12, 2018 at 16:54
Yeah, figured as much. @NathanFriend's link shows that it's not there yet. Here's another issue regarding "variadic kinds" which is what you want, but not in TypeScript at the moment. For now, you'd have to define the arguments lists via overloads. — Heretic Monkey
– Heretic Monkey, Commented Feb 12, 2018 at 16:57
@NathanFriend and Mike - good to know, thanks! I wasn't aware of the term "variance kinds" until now. — Valhalla
– Valhalla, Commented Feb 12, 2018 at 17:09

Titian Cernicova-Dragomir · Accepted Answer · 2018-02-12 17:15:31Z

While you can't do this for an arbitrary number of arguments, you can define a function that checks this for a limited number of arguments, and add more as needed:

function f<T1>(func: (a1: T1) => void, a1: T1): void;
function f<T1, T2>(func: (a1: T1, a2: T2) => void, a1: T1, a2: T2): void;
function f<T1, T2, T3>(func: (a1: T1, a2: T2, a3: T3) => void, a1: T1, a2: T2, a3: T3): void;
function f<T1, T2, T3, T4>(func: (a1: T1, a2: T2, a3: T3, a4: T4) => void, a1: T1, a2: T2, a3: T3, a4: T4): void;
// Private signature, not publicly available
function f(func: Function, ...args: any[]): void {
    func.apply(null, args);
}
f(
    (s: string) => { console.log(s) },
    1234.56 // incorrect type
)

f(
    (s: string) => { console.log(s) },
    "Hello",
    "World" // will accept more arguments  
)

The above version will check types, but it can be invoked with more arguments. This is because the overload with 2 generic types will be chosen, and the func can have fewer arguments and still be compatible.

You can achieve full safety, if you use a 2 call approach, which locks in the func in the first call, and returns a second function that already has the number of parameters decided:

function f2<T1>(func: (a1: T1) => void): (a1: T1) => void;
function f2<T1, T2>(func: (a1: T1, a2: T2) => void): (a1: T1, a2: T2) => void;
function f2<T1, T2, T3>(func: (a1: T1, a2: T2, a3: T3) => void): (a1: T1, a2: T2, a3: T3) => void;
function f2<T1, T2, T3, T4>(func: (a1: T1, a2: T2, a3: T3, a4: T4) => void): (a1: T1, a2: T2, a3: T3, a4: T4) => void;
// Private2 signature, not publicly available
function f2(func: Function) {
    return function (...args: any[]) { func.apply(null, args) };
}
f2((s: string) => { console.log(s) })(1234.56) // type mismatched 

f2((s: string) => { console.log(s) })(
    "Hello",
    "World" // too many arguments
)

starball · Accepted Answer · 2023-08-12 07:53:43Z

0

You can use the following code to achive strong type safety:

function f<T extends any[], R>(func: (...args: T) => R, ...args: T) {
    func.apply(null, args);
}

edited Aug 12, 2023 at 7:53

starball♦

59.6k52 gold badges314 silver badges1k bronze badges

answered Aug 12, 2023 at 2:53

Aniket Kumar

316 bronze badges

1 Comment

Community Over a year ago

As it’s currently written, your answer is unclear. Please edit to add additional details that will help others understand how this addresses the question asked. You can find more information on how to write good answers in the help center.

Collectives™ on Stack Overflow

How To Strongly Type Functions with Variable Arguments

2 Answers 2

Comments

1 Comment

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

Comments

1 Comment

Your Answer

Sign up or log in

Post as a guest

Related