TypeScript, what are call signature of an object literal and how can they be used with generic types?

Question

I'm reading this section of the TypeScript documentation, under the generic types section, the following two are stated to be the equivalent:

Code Sample 1

function identity<T>(arg: T): T {     return arg; }  let myIdentity: <T>(arg: T) => T = identity; 

Code Sample 2

function identity<T>(arg: T): T {     return arg; }  let myIdentity: {<T>(arg: T): T} = identity; 

The documentation states this is possible due to the following.

We can also write the generic type as a call signature of an object literal type

Despite this line I'm still struggling to understand how the two are equivalent, is there any further documentation or explanation of what it means to be 'a call signature of an object literal type'.

I'm sorry I can't give any further explanation but I'm completely drawing a blank as to how the two are equivalent, to me the second type definition states that myIdentity should be an object?

Thanks.

Answer 1

Functions can have properties, that's what the object literal syntax is for: it allows to define a call signature and additional properties. Your two examples are equivalent because the second doesn't define additional properties on the object literal. You can read more on that in the section on hybrid types.

Additionally, the object literal allows to define multiple call signatures for function overloads. You can create an object of such an interface with Object.assign:

interface Foo {     (x: string): number,     (x: number): string,     bar: Array<any>, }  const foo: Foo = Object.assign(function (x: any) {     if (typeof x === 'string') {         return parseInt(x);     } else {         return x.toString();     } }, {     bar: [] }); 

Answer 2

It is because Function in JavaScript is also an object.

Consider the following:

function foo() { return 'foo' }  // vs  const foo = Object.assign(   function () { return 'foo' },   {} ) 

TypeScript just follows what is possible in JavaScript.