TypeScript class that utilizes internal functions to implement another class

Question

TypeScript class that utilizes internal functions to implement another class

In my journey of exploration, I decided to try implementing a class within another class in TypeScript.

Here is the code snippet I came up with and tested on the Playground link:

class A {
    private f() { console.log("f"); }
    public g() { console.log("G"); }
}

class B implements A {
    public g() { console.log("g"); }
}

Upon testing, I encountered the error:

Class 'B' incorrectly implements class 'A' --- property 'f' is missing in type 'B'

. This error also suggested that I should use extends instead of implements.

In an attempt to rectify this, I tried introducing a private field named f, as using public resulted in different access modifiers, as seen in this Playground link.

However, this led to a new error:

Class 'B' incorrectly implements class 'A'. Types have separate declarations of a private property 'f'

, which left me baffled.

Why is the presence of private members crucial in this context? Does it mean that if I use different data structures to implement the same algorithm, I would have to declare similarly named private properties to satisfy type checking?
Why does the error persist even when f is implemented as a private function?

Although I would not typically approach tasks this way, I am intrigued by the workings of TypeScript in this scenario.

Thank you for any insights!

typescript implements

Answer 1

Answer №1

The GitHub issue Microsoft/TypeScript#18499 raises the importance of private members in determining compatibility. The main reason being: class private members are visible to other instances of the same class.

There is an insightful comment by @RyanCavanaugh in response to this issue:

Allowing private fields to be missing would lead to major problems, not just a minor soundness issue. For example:
class Identity {
  private id: string = "secret agent";
  public sameAs(other: Identity) {
    return this.id.toLowerCase() === other.id.toLowerCase();
  }
}
    
class MockIdentity implements Identity {
  public sameAs(other: Identity) { return false; }
}
MockIdentity is a public-compatible version of Identity, but attempting to use it as one will result in a crash in sameAs when a non-mocked copy interacts with a mocked copy.

Illustrating the potential failure:

const identity = new Identity();
const mockIdentity = new MockIdentity();
identity.sameAs(mockIdentity); // boom!

Therefore, there are valid reasons for this constraint.

To work around this limitation, you can extract only the public properties of a class using a mapped type like this:

type PublicPart<T> = {[K in keyof T]: T[K]}

Then, have B implement PublicPart<A> instead of A:

class A {
    private f() { console.log("f"); }
    public g() { console.log("G"); }
}

// works    
class B implements PublicPart<A> {
    public g() { console.log("g"); }
}

Hopefully, this explanation is beneficial. Best of luck!

Answer 2

The GitHub issue Microsoft/TypeScript#18499 raises the importance of private members in determining compatibility. The main reason being: class private members are visible to other instances of the same class.

There is an insightful comment by @RyanCavanaugh in response to this issue:

Allowing private fields to be missing would lead to major problems, not just a minor soundness issue. For example:
class Identity {
  private id: string = "secret agent";
  public sameAs(other: Identity) {
    return this.id.toLowerCase() === other.id.toLowerCase();
  }
}
    
class MockIdentity implements Identity {
  public sameAs(other: Identity) { return false; }
}
MockIdentity is a public-compatible version of Identity, but attempting to use it as one will result in a crash in sameAs when a non-mocked copy interacts with a mocked copy.

Illustrating the potential failure:

const identity = new Identity();
const mockIdentity = new MockIdentity();
identity.sameAs(mockIdentity); // boom!

Therefore, there are valid reasons for this constraint.

To work around this limitation, you can extract only the public properties of a class using a mapped type like this:

type PublicPart<T> = {[K in keyof T]: T[K]}

Then, have B implement PublicPart<A> instead of A:

class A {
    private f() { console.log("f"); }
    public g() { console.log("G"); }
}

// works    
class B implements PublicPart<A> {
    public g() { console.log("g"); }
}

Hopefully, this explanation is beneficial. Best of luck!

Answer 3

Answer №2

The current Typescript-supported solution is as follows:

class X {
    private x() { console.log("x"); }
    public y() { console.log("Y"); }
}

class Y implements Pick<X, keyof X> {
    public y() { console.log("y"); }
}

Explanation: The use of keyof X in this example ensures that only the public properties (and methods) of X are returned. The Pick function then narrows down the scope of X to only its public properties and their respective type.

Answer 4

The current Typescript-supported solution is as follows:

class X {
    private x() { console.log("x"); }
    public y() { console.log("Y"); }
}

class Y implements Pick<X, keyof X> {
    public y() { console.log("y"); }
}

Explanation: The use of keyof X in this example ensures that only the public properties (and methods) of X are returned. The Pick function then narrows down the scope of X to only its public properties and their respective type.

Answer 5

Answer №3

Unfortunately, due to the current specifications of typescript, it is not feasible. Despite there being a previously raised concern regarding this, the issue has since been resolved and closed.

One possible solution is to allow an implementing class to disregard private methods of the implementee class.

For further information, consider reading Extending vs. implementing a pure abstract class in TypeScript

Answer 6

Unfortunately, due to the current specifications of typescript, it is not feasible. Despite there being a previously raised concern regarding this, the issue has since been resolved and closed.

One possible solution is to allow an implementing class to disregard private methods of the implementee class.

For further information, consider reading Extending vs. implementing a pure abstract class in TypeScript

Answer 7

Answer №4

The reason behind this lies in the visibility of private members being restricted to the type rather than the instance. This means that all objects of type T can access the private members of other objects of the same type.

In nominatively typed languages, this is not a problem since all instances of T inherit the implementation of T. However, in structurally typed languages like TypeScript, we cannot assume that all instances fulfilling T have the same implementation as the class declaring type T.

As a result, private members must be included in the public contract of the type to prevent an object of the structural type T from calling a non-existent private member of another object with the same structural type.

Having private members as part of the public type contract is not ideal and could have been avoided by scoping privates to the instance rather than the type.

Answer 8

The reason behind this lies in the visibility of private members being restricted to the type rather than the instance. This means that all objects of type T can access the private members of other objects of the same type.

In nominatively typed languages, this is not a problem since all instances of T inherit the implementation of T. However, in structurally typed languages like TypeScript, we cannot assume that all instances fulfilling T have the same implementation as the class declaring type T.

As a result, private members must be included in the public contract of the type to prevent an object of the structural type T from calling a non-existent private member of another object with the same structural type.

Having private members as part of the public type contract is not ideal and could have been avoided by scoping privates to the instance rather than the type.

TypeScript class that utilizes internal functions to implement another class

Answer №1

Answer №2

Answer №3

Answer №4

Similar questions

Creating web components with lit-element, leveraging rollup, postcss, and the tailwind framework for packaging

What is the best way to extract information from a button and populate a form in AngularCLI?

Using Typescript and webpack to detect variables that are defined in the browser but not in Node environment

Bringing in the RangeValue type from Ant Design package

Title remains consistent | Angular 4

Order of execution for Angular 2 components

Tips for sending data returned asynchronously from an Observable in Angular from a Child component to its Parent

Unable to locate module src/ in Node.js TypeScript

Deep Dive into TypeScript String Literal Types

How to send Multipart form data with a string payload

What is the proper way to call document methods, like getElementByID, in a tsx file?

Using TypeScript: Functions incorporating properties

What is the reason for TypeScript not providing warnings for unrealistic conditions involving 'typeof' and 'in'?

The state object in Redux Toolkit remains static, resulting in the error message "Uncaught TypeError: Cannot assign to read only property 'property-name' of object '#<Object>'"

Best practices for safely handling dynamic keys in Typescript

Creating OpenAPI/Swagger documentation from TypeScript code

Can the tiles in a grid-list be organized in a specific order?

Set up an event listener for when geolocation permission is approved

Creating a nested/child route structure within the Angular 2 router

incorporating my unique typographic styles into the MUI framework