Repository: TypeScript
Issue: Cast Method of a class to a certain type
Labels: Suggestion,Awaiting More Feedback

<!-- 🚨 STOP 🚨 𝗦𝗧𝗢𝗣 🚨 𝑺𝑻𝑶𝑷 🚨

Half of all issues filed here are duplicates, answered in the FAQ, or not appropriate for the bug tracker.

Please help us by doing the following steps before logging an issue:
  * Search: https://github.com/Microsoft/TypeScript/search?type=Issues
  * Read the FAQ, especially the "Common Feature Requests" section: https://github.com/Microsoft/TypeScript/wiki/FAQ

-->

## Search Terms
casting
type
interface
method
function
parameters
inference
class
<!-- List of keywords you searched for before creating this issue. Write them down here so that others can find this suggestion more easily -->

## Suggestion

<!-- A summary of what you'd like to see added or changed -->
Currently, it is impossible to infer the parameters and the return types of a method of a class using a type 

The goal is to be able to declare a method without repeating the param types and the return type. I used typescript `Type` for that.

But there is currently no way to do this without changing the compiled javascript code.

    type IBar = (x:number, y: number)=>number;



I tried 

    type IBar = (x:number, y: number)=>number;
    class Foo {
        sum:IBar=(x,y)=>{
            return x+y;
        }
    }

BUT unfortunately, this changes the javascript code compiled into:



    class Foo {
        constructor() {
            this.sum = (x, y) => {
                return x + y;
            };
        }
    }


I am looking for something that compiles into:



    class Foo {
        sum(x, y) {
            return x + y;
        }
    }


Another option currently is to declare an interface and implement it on the class like so:

```
interface IBar { sum(x: number, y: number): number; }

class Foo implements IBar {
    public sum(x: number, y: number): number {
        return x + y;
    }
}
```

HOWEVER, this approach would bnd the method name to only `sum` . What if I want to use the same method type with a different name like `divide` or `multiply`

## Use Cases

<!--
What do you want to use this for?
What shortcomings exist with current approaches?
-->
It will be used like this 

    class Foo {
        sum(x,y){
            return x+y;
        } as IBar
    }

## Examples

    class Foo {
        sum(x,y){
            return x+y;
        } as IBar
    }


or 


    class Foo {
        divide(x,y){
            return x+y;
        } as IBar
    }

or 

    class Foo {
        multiply(x,y){
            return x+y;
        } as IBar
    }


<!-- Show how this would be used and what the behavior would be -->

## Checklist

My suggestion meets these guidelines:

* [x] This wouldn't change the runtime behavior of existing JavaScript code
* [x] This could be implemented without emitting different JS based on the types of the expressions
* [x] This isn't a runtime feature (e.g. library functionality, non-ECMAScript syntax with JavaScript output, etc.)
* [x] This feature would agree with the rest of [TypeScript's Design Goals](https://github.com/Microsoft/TypeScript/wiki/TypeScript-Design-Goals).
* [x] This wouldn't be a breaking change in existing TypeScript/JavaScript code