Is it possible to create an object/class/interface that represents a Function signature?

Question

Everything already works as expected in my code. What I want is to make it more verbose, making the signatures of the method more self-explanatory (I know I can use Docs comments for this, but I would also like to use the types of Typescript) and can be better validated by Tslint's of life.

What I have today:

class Test{
    testMetadada<T>(expression: (t: T) => void) {
        // ...
    }
}

The object expression is the type (t: T) => void, which is not very explanatory, I would like for example that something like:

class Expression<T> extends (t: T) => void{

}

or

interface Expression<T> extends (t: T) => void{

}

or

let Expression = ((t: T) => void)<T>;

So my method would be something like:

class Test{
    testMetadada<T>(expression: Expression) {
        // ...
    }
}

Where Expression represented the same (t: T) => void.

Is there anything I can do about it?

Behold here’s the example of what I’m trying to implement with this (the possibility of using Arrow function of Typescript as expressions Lambda Expressions of C# to obtain metadata)

Answer 1

It is possible to use type aliases:

type Expression<T> = (t: T) => void;

Thus the signature of the method:

class Test{
    testMetadada<T>(expression: Expression<T>) {
        // ...
    }
}

Updated example of the solution.

---

Based on answer to that question in Soen.