Provide the ability to change assigned generic inside a class

[radzserg]

Suggestion

Provide the ability to change assigned generic inside a class - class Buzz<R>

Currently, it's possible to change class generic only by creating a new object.

class Buzz<R extends Object> {
    public add<N extends Object>(newValue: N): Buzz<R & N> {
        return ({} as unknown) as Buzz<R & N>;
    }
}

let buzz = new Buzz();
let buzz2: Buzz<{ a: number }> = buzz.add({ a: 123 });
let buzz3: Buzz<{ a: number; b: string }> = buzz2.add({ b: "string" });

But there's no way to change R if we call a member function of a class.

It's possible to make another workaround with this in a guard

class Buzz<R extends Object = {}> {
    public add<N extends Object>(newValue: N): this is Buzz<R & N> {
        return true;
    }
    public get<N extends keyof R>(name: N): R[N] {
        return ({} as unknown) as R[N];
    }
}

let buzz = new Buzz();
if (buzz.add({ a: 123 })) {
  let a: number = buzz.get("a")   // works fine
} else {
  let a: number = buzz.get("a") // TS2345: Argument of type 'string' is not assignable to parameter of type 'never'.
}

but in this case we still need to use if condition that doesn't work

🔍 Search Terms

class generic

✅ Viability 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, new syntax sugar for JS, etc.)
• This feature would agree with the rest of TypeScript's Design Goals.

⭐ Suggestion

use this as CurrentClass<NewGenericType> syntax to allow changing assigned generic.

class Buzz<R extends Object = {}> {
    public add<N extends Object>(newValue: N): this as Buzz<R & N> {
        // this.values.push(newValue);
    }
}

📃 Motivating Example

It allows using the OOP approach without a need to create new objects.

💻 Use Cases

Live example. Dependency Injection container is getting new definitions. It is supposed to be a singleton in the program.

const container = new DIContainer();

container.add({ key1: new Foo() });
container.add({ key2: new Bar() });
const value = container.get("key1");

// currently I can only do

let container = new DIContainer();
container = container.add({ key1: new Foo() });
container= container.add({ key2: new Bar() });

[MartinJohns]

This sounds exactly like #41339. Finding that issue again was tough.

[jcalz]

This looks an awful lot like assertion functions as implemented in #32695 (although assertion functions have the annoying limitation that you need to explicitly annotate the class instance type in the variable that holds it) :

class Buzz<T extends object = {}> {
    data: any = {}
    add<U extends object>(newValue: U): asserts this is Buzz<T & U> {
        Object.assign(this.data, newValue);
    }
    get<K extends keyof T>(name: K): T[K] {
        return this.data[name] as T[K];
    }
}

let buzz: Buzz = new Buzz(); // explicitly annotated as Buzz here, or you get errors
buzz.add({ a: 123 });
buzz.get("b") // error
console.log(buzz.get("a").toFixed(2)) // 123.00
buzz.add({ b: "string" });
buzz.get("b") // okay
console.log(buzz.get("b").toUpperCase()); // STRING

Playground link

I'd like to see #45385 so that assertion functions are easier to use, but TypeScript basically has this functionality already.

[radzserg]

Great, that's exactly what I was looking for. It was tough to find this in the docs. Thank you. Closing this one.