TypeScript method type signature redundant

Question

Maybe I'm seriously missing something, but I'm unable to get rid of a syntax problem with all my classes.

Here is an example :

class Foo {
   bar: (x: string, y: number) => string = (xx: string, yy: number) : string => {
      // do some stuff...
   };
}

Since I'm enforcing type declarations using tslint, ALL my methods are written like this. It's horrible. Having to copy paste the arguments part, renaming the args names between the type declaration and the lambda declaration is soooo painfull.

So : is there a better way to combine type signature and lambda declaration without all the knee jerking ? I sincerely hope I have missed something and hope this is not "by design" ! :)

Answer 1

Edit:

If you're targeting ES5, you can also do something like this:

var bar = (x: string, y: number) : string => {
  // do some stuff...
};

class Foo {
   get bar () { return bar; }
}

var test = (new Foo).bar('hello', 3);

Or:

class Foo {
   get bar () {
       return (xx: string, yy: number): string => {
            // do some stuff... 
       };
    }
}

This way the method's context is preserved and it also exists on the prototype. There's also no need to copy the argument types, TSC will infer them.

Answer 2

You need to configure TSLint to enforce types but ignore the type of the functions:

typedef enforces type definitions to exist. Rule options:

• "call-signature" checks return type of functions

• "parameter" checks type specifier of function parameters

• "property-declaration" checks return types of interface properties

• "variable-declaration" checks variable declarations

• "member-variable-declaration" checks member variable declarations

You can use a file like this one to configure TSLint. And read this to learn more about how to configure it.