Difference between call signature and function type

Question

I'm trying to understand why we have different syntax for call signatures and for function types. Consider the following code:

interface MyInterface {
   // This is call signature
   // It is used inside object type, function expression, function declaration, etc...
    (x:number, y:number):number; 
}

var myOne : MyInterface = (x,y) => x + y;
            // vv this is function type
var myTwo : (x:number, y:number)=>number = (x,y) => x + y; 
// function type is used in function type literal

In this code myOne and myTwo variables effectively the same. They are (as far as I can see) of the very same type, just defined differently.

Now when we are using interface for defining them we use call signature that looks like this:

(x:number, y:number):number

When we are not using interface we use function type literal:

(x:number, y:number)=>number

Both express the same thing, names and types of parameters and types of the return type. I would like to know, why do we need two different yet so similar ways to write the same thing in typescript?

Answer 1

They are exactly the same.

why do we need two different yet so similar ways to write the same thing in typescript

The (x:number, y:number)=>number signature is useful as a property annotation :

interface MyInterface {
    (x:number, y:string):string;   
    someProperty: (x:number, y:number)=>number;
}

Which is similar to your:

var myTwo : (x:number, y:number)=>number

Just a shorthand for a verbose :

var myTwo : {(x:number, y:number):number}

So you can see the simplicity of ()=>.

Also

One thing to note is that a function signature allows overloading:

var myTwo : {
    (x:number, y:number):number;
    (x:number):string;
}

Which is not supported for a property annotation.