Techniques for a versatile class limited to a particular category

Question

Techniques for a versatile class limited to a particular category

In my code, I have a Vector class that looks like this:

class Vector<N extends number> {...}

N represents the size or dimension of the vector. This Vector class also includes a cross product method to calculate the cross product between vectors:

cross(vector: Vector<N>) {...}

The issue is that the cross product method is only valid for vectors with 3 dimensions (N extends 3). So, my question is: Is there a way to prevent other vectors from accessing the cross product method, except for those with exactly 3 dimensions? I would prefer not to use a subclass such as 3DVector specifically for implementing the cross product method. One solution I considered is:

cross(vector: N extends 3 ? Vector<3> : never) {...}

However, this solution does not completely hide the method but rather disables it by setting the parameter to never. Can you suggest a better approach to solve this problem more effectively?

typescript typescript-generics

Answer 1

Answer №1

To enhance the functionality of the Vector class, you can create a specialized subclass called Vector3D. This subclass can include methods specific to 3-dimensional vectors, such as the cross method. By doing this, you essentially "hide" the method from other types of vectors.

export class Vector<N extends number> {
    /* ... */
}

export class Vector3D extends Vector<3> {
    cross(vector: Vector3D) {
        /* ... */
    }
}

export class Vector2D extends Vector<2> {
    /* ... */
}

const vectorWithCross = new Vector3D();
const vectorWithoutCross = new Vector2D();
const genericVector = new Vector<390>();

vectorWithCross.cross(new Vector3D()) // works fine

vectorWithoutCross.cross(new Vector3D()) // error
genericVector.cross(new Vector3D()) // error

Feel free to experiment with this code on TypeScript playground for further customization.

Answer 2

To enhance the functionality of the Vector class, you can create a specialized subclass called Vector3D. This subclass can include methods specific to 3-dimensional vectors, such as the cross method. By doing this, you essentially "hide" the method from other types of vectors.

export class Vector<N extends number> {
    /* ... */
}

export class Vector3D extends Vector<3> {
    cross(vector: Vector3D) {
        /* ... */
    }
}

export class Vector2D extends Vector<2> {
    /* ... */
}

const vectorWithCross = new Vector3D();
const vectorWithoutCross = new Vector2D();
const genericVector = new Vector<390>();

vectorWithCross.cross(new Vector3D()) // works fine

vectorWithoutCross.cross(new Vector3D()) // error
genericVector.cross(new Vector3D()) // error

Feel free to experiment with this code on TypeScript playground for further customization.

Answer 3

Answer №2

Imagine a scenario where you were not utilizing generics, but instead creating classes like Vector1d, Vector2d, Vector3d, etc. In this situation, if the cross operation is only applicable to Vector3d, you would exclude it from the other classes and attempt to conceal it -- for example, by adding the method in the derived class if they all inherit from Vector.

Similarly, I believe that if a method pertains solely to a specific value of the generic type, it should not be part of the generic's methods.

Although I do not have enough knowledge of TypeScript to provide a precise solution, generally speaking, I think that cross should exist as a global or standalone function, rather than being contained within the class:

class Vector<N extends Number> { ... };

// ...

function cross(Vector<3>, Vector<3>) -> Vector<3>;

Alternatively, you could establish a separate class specifically for 3D vectors and implement the operation there:

class Vector<N extends Number> { ... };

// ...

class Vector3D extends Vector<3> {
  // ...
  function cross(Vector3D, Vector3D) -> Vector3D { 
   // ....
  }
}

Answer 4

Imagine a scenario where you were not utilizing generics, but instead creating classes like Vector1d, Vector2d, Vector3d, etc. In this situation, if the cross operation is only applicable to Vector3d, you would exclude it from the other classes and attempt to conceal it -- for example, by adding the method in the derived class if they all inherit from Vector.

Similarly, I believe that if a method pertains solely to a specific value of the generic type, it should not be part of the generic's methods.

Although I do not have enough knowledge of TypeScript to provide a precise solution, generally speaking, I think that cross should exist as a global or standalone function, rather than being contained within the class:

class Vector<N extends Number> { ... };

// ...

function cross(Vector<3>, Vector<3>) -> Vector<3>;

Alternatively, you could establish a separate class specifically for 3D vectors and implement the operation there:

class Vector<N extends Number> { ... };

// ...

class Vector3D extends Vector<3> {
  // ...
  function cross(Vector3D, Vector3D) -> Vector3D { 
   // ....
  }
}

Answer 5

Answer №3

Here is a solution that may not be perfect, but it's worth trying out.

// Creating a vector class with a missing cross method
class vector<N extends number>{...}

// Manually adding the cross method to the prototype
vector.prototype.cross = function (other: vector<3>) {...}

// Re-defining the vector interface with the added cross method, demonstrating how TypeScript interfaces can be extended
interface vector<N extends number>{
    cross: (N extends 3 ? (other: vector<3>) => vector<3> : never)
}

The key aspect here is the type definition of the cross method, which is dependent on the type argument provided. If the type is 3, then cross is available as a method; otherwise, it's set to never. This ensures that while autocomplete may still display cross when N is not 3, it won't be callable in those cases.

Answer 6

Here is a solution that may not be perfect, but it's worth trying out.

// Creating a vector class with a missing cross method
class vector<N extends number>{...}

// Manually adding the cross method to the prototype
vector.prototype.cross = function (other: vector<3>) {...}

// Re-defining the vector interface with the added cross method, demonstrating how TypeScript interfaces can be extended
interface vector<N extends number>{
    cross: (N extends 3 ? (other: vector<3>) => vector<3> : never)
}

The key aspect here is the type definition of the cross method, which is dependent on the type argument provided. If the type is 3, then cross is available as a method; otherwise, it's set to never. This ensures that while autocomplete may still display cross when N is not 3, it won't be callable in those cases.

Techniques for a versatile class limited to a particular category

Answer №1

Answer №2

Answer №3

Similar questions

Tips for acquiring the newest router in an angular environment

Encountering difficulty in removing a record from the database utilizing Prisma with Next.js API routes

What is the best way to transform a JS const into TSX within a Next.js application?

What is the correct way to add type annotations to an Axios request?

Locating a class variable using a string chosen from a DropDown menu

Executing a designated assessment in Protractor

Is there a way to install @types that are compatible with an outdated version of TypeScript?

How to send form group in Angular when the enter key is pressed

Typescript does not directly manipulate values. For instance, using a statement like `if(1==2)` is prohibited

Implementing a more efficient method for incorporating UUIDs into loggers

Setting up AngularJS 1.5.x to function seamlessly with SystemJS and TypeScript

Incorrect errors are displayed by VS Code in ts-node shell scripts

Error message thrown by node express.js indicating that response headers cannot be reset once they have been sent

The inline style in Angular 2 is not functioning as expected when set dynamically

TSLint Alert: Excessive white space detected before 'from' keyword (import-spacing)

What is the best way to ensure that two promises are both resolved before triggering a function from within a promise?

Tips for integrating Excel files with NestJS

Creating TypeScript domain objects from JSON data received from a server within an Angular app

Obtaining an OBJECT from a hashmap instead of a string

What is the proper way to utilize variables in package.json with npm version 7.x.x?