Support abstract class methods without abstract class

[Irrelon]

🔍 Search Terms

abstract methods runtime prototype typesafe synthesized

✅ Viability Checklist

• 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, new syntax sugar for JS, etc.)
• This isn't a request to add a new utility type: https://github.com/microsoft/TypeScript/wiki/No-New-Utility-Types
• This feature would agree with the rest of our Design Goals: https://github.com/Microsoft/TypeScript/wiki/TypeScript-Design-Goals

⭐ Suggestion

It would be good if we could declare a method as abstract without the requirement to declare the entire class as abstract.

📃 Motivating Example

Take an example class such as:

class MyClass {
    protected _id?: string;
    protected _isVisible?: boolean;

    id (val?: string): string | this | undefined {
        if (val === undefined) {
            return this._id;
        }

        this._id = val;
        return this;
    }

    // Similar implementation for isVisible()
}

If I have a bunch of accessor functions like id() that follow the same getter/setter behaviour I have to write out each one in concrete code which takes time and wastes bytes across the network when the code gets sent down the pipe.

What I would do in JS is create a synthesize() function that takes the class and the method name and then generates the function at runtime against the underlying prototype, something like:

function synthesize<FunctionArgType = any> (Class: any, methodName: string) {
	const privatePropertyName = `_${methodName}`;

	Class.prototype[methodName] = function (val?: FunctionArgType) {
		if (val === undefined) {
			return this[privatePropertyName];
		}

		this[privatePropertyName] = val;
		return this;
	};
}

It then becomes trivial to add the desired methods as:

synthesize(MyClass, "id");
synthesize(MyClass, "isVisible");
// ...etc etc

At present, I can "sort of" achieve this by ts-ignoring the abstract methods that I know are going to become available at runtime:

class MyClass {
    // @ts-ignore
    abstract id (val?: string): string | this;
    // @ts-ignore
    abstract isVisible (val?: boolean): boolean | this;
}

This is a bit sad given that the JS functionality can significantly reduce the byte-size of the file if the class is large and provides a lot of similar accessor functionality. I realise that this might appear to be an edge-case, but right now, TS makes writing conforming JS of this nature a real burden by either creating concrete classes, or ts-ignoring like it's 1999.

💻 Use Cases

1. What do you want to use this for?
2. What shortcomings exist with current approaches?
3. What workarounds are you using in the meantime?

[RyanCavanaugh]

Just use interface merging?

class MyClass {
  // etc
}
interface MyClass {
  isVisible():  boolean;
}
const c = new MyClass();
console.log(c.isVisible()); // ok

[typescript-bot]

This issue has been marked as "Question" and has seen no recent activity. It has been automatically closed for house-keeping purposes.