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

L’issue ne mentionne aucun fichier source, test ou point d’entrée de l’implémentation. Examinez d’abord la syntaxe proposée des méthodes comme types ainsi que les exemples existants d’interfaces et de types de fonction ; il faudrait définir le comportement de la vérification des types et se mettre d’accord sur le JavaScript généré avant que le travail soit prêt à être implémenté.