Typescript signature for higher-order decorator function

Question

Is it possible to write a type signature for a decorator function (I mean decorator design pattern decorator, not typescript decorator functionality)?

I tried this:

function decorate<T extends () => any>(callback: T): T {
    return (...args) => {
        console.log('called with args: ', args);
        return callback(...args);
    };
}

but it gives me TS2322: Type '(...args: any[]) => any' is not assignable to type 'T'.

Answer 1

You can do this in 3.0 using Tuples in rest parameters and spread expressions

function decorate<A extends any[], R>(callback: (...a: A) => R): (...a: A) => R {
    return (...args) => {
        console.log('called with args: ', args);
        return callback(...args);
    };
}

function foo(s: number) {
    return s.toString();
}


function bar(s: number, o : string[]) {
    return s.toString();
}

var dBar = decorate(bar) // (s: number, o: string[]) => string
var dFoo = decorate(foo) // (s: number) => string

There are caveats, as pointed out in the comments. Generics don't work well with this approach. Also the function above does not handle overloads correctly. For a workaround to the overload issue see this answer .

Edit

A version that will work with less caveats but that will require some type assertions in the implementation is close to the one you proposed:

function decorate<T extends (...a: any[]) => any>(callback: T): T {
    return ((...args) => {
        console.log('called with args: ', args);
        return callback(...args);
    }) as any;
}

This better captures that the input is the same as the output and is preferable if not other type manipulations are necessary on the return type or the arguments. While this version breaks implementation type safety this is an acceptable tradeoff to get full call site safety as it will work with both overloads and generics.