Allow non-polymorphic ("private") extension of base classes #57979

Activity

1. dmchurch commented on Mar 28, 2024

   

   Danielle Church (dmchurch)

   on Mar 28, 2024

   Author

   More actions

   This is also possibly related to #4628. Not in the sense that my issue is affected by static inheritance, but because if this issue were resolved by the addition of something like the extends private mechanism described here, that could also be used to resolve 4628, by allowing decoupling of inherited members vs exposed members.
2. dmchurch commented on Mar 29, 2024

   

   Danielle Church (dmchurch)

   on Mar 29, 2024

   Author

   More actions

   It occurs to me that one radical way to solve this problem would be to add some syntax that allows you to suppress creating the interface portion of the class altogether. Then you could simply define the interface separately with whatever subset of the actual functionality you want to expose, and then the ES6 class definition just gets matched against that interface, rather than generating the interface itself.

   ...Huh. This actually feels like a useful and actionable feature. You could rewrite the original example like this:

   // This line is the only definition of the MyTuple<T> type
   export interface MyTuple<T> extends ReadonlyArray<T> { }
   // A private class is one whose types are not visible to the outside. It has signature { } or possibly object.
   export private class MyTuple<T> extends Array<T>
   // This one implements the MyTuple<T> interface to ensure that it matches its public API
       implements MyTuple<T> {
     constructor(...args: readonly T[]) {
       super();
       this.push(...args);
       Object.freeze(this);
     }
   }

   What do you think?
3. whzx5byb commented on Apr 11, 2024

   

   whzx5byb

   on Apr 11, 2024

   More actions

   Danielle Church (@dmchurch) You can use a class expression to make it "private".

   // This line is the only definition of the MyTuple<T> type
   export interface MyTuple<T> extends ReadonlyArray<T> { }
   // A private class is one whose types are not visible to the outside. It has signature { } or possibly object.
   export const MyTuple = class<T> extends Array<T>
   // This one implements the MyTuple<T> interface to ensure that it matches its public API
       implements MyTuple<T> {
     constructor(...args: readonly T[]) {
       super();
       this.push(...args);
       Object.freeze(this);
     }
   }

   Note that you MUST NOT use the name MyTuple for the class expression. Use any other name or anonymous instead, otherwise the interface MyTuple<T> declared in the outer scope will be shadowed.
4. Ryan Cavanaugh (RyanCavanaugh)

   added

   SuggestionAn idea for TypeScriptAn idea for TypeScript

   Awaiting More FeedbackThis means we'd like to hear from more people who would be helped by this featureThis means we'd like to hear from more people who would be helped by this feature

   on Apr 11, 2024
5. dmchurch commented on Apr 11, 2024

   

   Danielle Church (dmchurch)

   on Apr 11, 2024

   Author

   More actions

   whzx5byb Yes, I've used that workaround before, and it's not applicable in this case. I need the emit to contain an ECMAScript top-level class export, which has slightly different semantics than an anonymous class assigned to a const (or a let, or a var, etc etc). If you have any suggestions that actually fit my needs, I'm all ears.
6. n1kk commented on Apr 23, 2024

   

   Nikita Domin (n1kk)

   on Apr 23, 2024

   More actions

   I was looking for something similar, I wanted my subclass to be a readonly array. After playing with all the possibilities I managed frankenstein this together from the bits an pieces on StackOverflow and this repos issues.

   function ReadonlyArrayCtor(): { new <T>(...items: readonly T[]): ReadonlyArray<T> } {
       return Array as any;
   }
   
   export class MyTuple<T> extends ReadonlyArrayCtor()<T> {
       constructor(...args: readonly T[]) {
           super(...args);
           Object.freeze(this);
       }
   }
   
   let vec = new MyTuple(1, 2);
   
   vec[1] = 100; // error

   Playground

   Kinda works. But couldn't make it an actual tuple though. Even casting the constructor factory to readonly [number, number] did not limit the subclass to only 2 indexes. I guess extends broadens the type to have "at least two".

   function ReadonlyArrayCtor(): { new (x: number, y: number): readonly [number, number] } {
       return Array as any;
   }
   
   export class MyTuple<T> extends ReadonlyArrayCtor() {
       constructor(x: number, y: number) {
           super(x, y);
           Object.freeze(this);
       }
   }
   
   let vec = new MyTuple(1, 2);
   
   let x = vec[0]
   let y = vec[1]
   let z = vec[2] // no error
   
   vec[1] = 100; // error

   Playground