Allow overload signatures when writing class property initializers

Search Terms

1. typescript class bound function parameter overload
2. typescript class bound function overload
3. typescript class bound method overload
4. typescript class bound arrow overload

Suggestion

It would be nice if we could overload bound arrow function methods in a class without the need to specifically declare a constructor and bind methods in it.

Use Cases

Examples

// existing valid implementation
// class `A` has method `a` bound to its instance in the constructor
class A {
  constructor(){
    this.a = this.a.bind(this);
  }

  a(a: string): string;
  a(a: string, b: string): string;
  a(a: string, b?: string): string {
    if(b) return a + b;
    return a;
  }
}

// suggested alternative implementation
// class `B` declares a bound arrow function `a` and its overloads without the need for a ctor
class B {
  a = (a: string): string;
  a = (a: string, b: string): string;
  a = (a: string, b?: string): string => {
    if(b) return a + b;
    return a;
  }
}

Checklist

My suggestion meets these guidelines:

• This wouldn’t be a breaking change in existing TypeScript/JavaScript code
• 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.

[ffflorian]

@zacnomore’s approach didn’t work for me.

What I did to resolve this:

interface Overload {
  (a: string): string;
  (a: string, b: string): string;
}

class A {
  a: Overload = (a: string, b?: string): string => {
    if (b) {
      return a + b;
    }
    return a;
  }
}

[legraphista]

You already can bind class methods with the arrow syntax in JS:

class A {
    a = () => {
        console.log(this);
    }   
}

And you can overload normal class methods in TS:

class A {
  a(a: string): string;
  a(a: string, b: string): string;
  a(a: string, b?: string): string {
    if(b) return a + b;
    return a;
  }
}

But you can’t have both; you can’t have a bound method and overload it too (syntax error):

class A {
  a = (a: string): string;
  a = (a: string, b: string): string;
  a = (a: string, b?: string): string => {
    if(b) return a + b;
    return a;
  }
}

I was looking to achieve that ^