Cast Method of a class to a certain type

Search Terms

casting
type
interface
method
function
parameters
inference
class

Suggestion

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

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
}

Checklist

My suggestion meets these guidelines:

• This wouldn't change the runtime behavior of existing JavaScript code
• This could be implemented without emitting different JS based on the types of the expressions
• This isn't a runtime feature (e.g. library functionality, non-ECMAScript syntax with JavaScript output, etc.)
• This feature would agree with the rest of TypeScript's Design Goals.
• This wouldn't be a breaking change in existing TypeScript/JavaScript code

The issue names no source files, tests, or implementation entry points. Review the proposed method-as-type syntax and the existing interface and function-type examples first; the work would need a defined type-checking behavior and agreement on the emitted JavaScript before it is ready to implement.