determine callback function's signature in runtime

Question

I want to pass different callback functions as an argument and have them called with proper parameters.

Here is a highly simplified example of how should it work. Except that process instanceof ITwo has no sense and I cannot find any expression that does the job.

    interface IOne { (j: string): number; }
    interface ITwo { (j: number): number; }
    function dualArg(i: string, process: IOne | ITwo): number {
        // something like this
        if (process instanceof ITwo) {
            // call with numeric arg
            return process(i);
        } else {
            // conver to number
            return process(+i);
        }
    }
    function inc(i: number): number {
        return ++i;
    }
    function idem(text: string): number {
        return +text;
    }
    it('determine function signature', () => {
        expect(dualArg('1', inc)).toBe(2);
        expect(dualArg('1', idem)).toBe(1);
    })

For a normal argument instanceof will be enough for TypeScript to treat it as an object of specific type, however there does not seem to be anything similar for functions.

If I use some kind of hard-coded conditional, such as process.prototype.constructor.name === 'idem' I get Typescript error message: Cannot invoke an expression whose type lacks a call signature. Type 'IOne | ITwo' has no compatible call signatures.

Here of course I could define process: any to disable any TypeScript checks and the code will compile and run, but my goal is to be able to distinguish the functions just by their signature (and not rely on some other convention such as name or additional flags).

Answer 1

The problem is that at runtime all type information is lost. So you can't directly reason about the type of a function at runtime (beyond the fact that it is a function).

What you could do is create a function type that also has a property that determines the type. And use a function to build-up the function:

enum Type { One, Two}
interface IOne { (j: string): number; type: Type.One }
interface ITwo { (j: number): number; type: Type.Two}
function dualArg(i: string, process: IOne | ITwo): number {
    if (process.type === Type.One) {
        // Type guard above, process is of type IOne
        return process(i);
    } else {
        // Type guard above, process is of type ITwo
        return process(+i);
    }
}
function inc(i: number): number {
    return ++i;
}
function idem(text: string): number {
    return +text;
}

function oneFunction(fn: (j: string)=> number) : IOne{
    return Object.assign(fn, { type: Type.One as Type.One });
}

function twoFunction(fn: (j: number)=> number) : ITwo{
    return Object.assign(fn, { type: Type.Two as Type.Two });
}

dualArg("", twoFunction(inc));
dualArg("", oneFunction(idem));

For your simple example this would be overkill (you could just define two versions of dualArg) but if the creation of the function and the usage are far apart and there is more code that is reused between the two this approach might make sense.

Answer 2

TypeScript is a dev time only. You can't expect it to do something in run-time. TypeScript is able to "understand" things using your run-time assumptions (like instanceof).

It looks like your two functions should have one implementation with two overloads, and not deal with it in the dualArg (calling) function. Dealing with the parameter types inside dualArg means that you will have to do the same thing everywhere you want to call these functions.

So how about you implement a wrapper function that will do the parameter tests (In run-time) and TypeScript will detect that, and protect you.