What is the best way to implement a generic parameter with constraints in an abstract method?

Question

What is the best way to implement a generic parameter with constraints in an abstract method?

Take a look at this scenario:

interface BaseArgs {
  service: string
}

abstract class BaseClass {
  constructor(name: string, args: BaseArgs) {
    this.setFields(args)
  }

  abstract setFields<T extends BaseArgs>(args: T): void
}

interface ChildArgs extends BaseArgs {
  newField: string
}

class Child extends BaseClass {
  setFields(args: ChildArgs): void {}
}

When I compile this code in Typescript, I encounter the following error:

Property 'setFields' in type 'Child' is not assignable to the same property in base type 'BaseClass'.
  Type '(args: ChildArgs) => void' is not assignable to type '<T extends BaseArgs>(args: T) => void'.
    Types of parameters 'args' and 'args' are incompatible.
      Type 'T' is not assignable to type 'ChildArgs'.
        Property 'newField' is missing in type 'BaseArgs' but required in type 'ChildArgs'.

Although I want to ensure that the argument (args) must extend BaseArgs, it seems like simply having Child's setFields method accept a type that extends BaseArgs is not satisfying the compiler. What am I overlooking here?

I experimented with using just T without the constraint, but the compiler recommended adding the extends ChildArgs constraint with

This type parameter might need an extends ChildArgs constraint.

.

I initially hoped that in any subclass extending the abstract base class, setFields could handle any type as long as it extended BaseArgs.

typescript generics abstract-class

Answer 1

Answer №1

When it comes to generic functions and methods, the type arguments are determined by the caller rather than the implementer. The implementer can set constraints on the type parameter, but it is ultimately up to the caller to choose a compatible type argument within that constraint. Even if the compiler infers the type argument for the caller, it does so on behalf of the caller.

If you have instances of BaseClass, they follow an interface like:

interface BaseClass {
  setFields<T extends BaseArgs>(args: T): void
}

This implies that with an instance i of BaseClass, you can call i.setFields(arg) with any arg as long as it meets the requirements of being assignable to BaseArgs. Subclasses need to comply with the typings of their superclasses; for example, in class Child extends BaseClass {}, every Child instance must also be a BaseClass instance. Therefore, Child's setFields() method must allow the caller to provide any BaseArgs-compatible argument they want.

You cannot restrict the caller's choice of args like this:

class Child extends BaseClass {
  setFields(args: ChildArgs): void { } // error!
}

The implementer is limited while the caller has freedom in selecting the type arguments for generic functions and methods.

If your intention is not to have setFields be generic at all, aiming for the implementer to decide the argument type, then what you really need is the BaseClass class to be generic. Generic types (such as generic classes, interfaces, or type aliases) work differently in terms of their generic parameters scope:

abstract class BaseClass<T extends BaseArgs> {
  constructor(name: string, args: T) {
    this.setFields(args)
  }
  abstract setFields(args: T): void
}

This is akin to:

interface BaseClass<T extends BaseArgs> {
  setFields(args: T): void
}

Now, there isn't such thing as "an instance of BaseClass" without specifying the type argument. It can only exist as "an instance of BaseClass<BaseArgs>" or "an instance of BaseClass<SomeOtherArgs>". Thus, a subclass of BaseClass can extend beyond just BaseClass to

BaseClass<T></code for any desired <code>T

. For instance, the following is acceptable:

class Child extends BaseClass<ChildArgs> {
  setFields(args: ChildArgs): void { } // okay
}

Since an instance i of Child is essentially an instance of BaseClass<ChildArgs>, only a ChildArgs argument can be used with i.setFields(). This setup grants the implementer control over the type arguments while restricting the caller.

Link to Playground code

Answer 2

When it comes to generic functions and methods, the type arguments are determined by the caller rather than the implementer. The implementer can set constraints on the type parameter, but it is ultimately up to the caller to choose a compatible type argument within that constraint. Even if the compiler infers the type argument for the caller, it does so on behalf of the caller.

If you have instances of BaseClass, they follow an interface like:

interface BaseClass {
  setFields<T extends BaseArgs>(args: T): void
}

This implies that with an instance i of BaseClass, you can call i.setFields(arg) with any arg as long as it meets the requirements of being assignable to BaseArgs. Subclasses need to comply with the typings of their superclasses; for example, in class Child extends BaseClass {}, every Child instance must also be a BaseClass instance. Therefore, Child's setFields() method must allow the caller to provide any BaseArgs-compatible argument they want.

You cannot restrict the caller's choice of args like this:

class Child extends BaseClass {
  setFields(args: ChildArgs): void { } // error!
}

The implementer is limited while the caller has freedom in selecting the type arguments for generic functions and methods.

If your intention is not to have setFields be generic at all, aiming for the implementer to decide the argument type, then what you really need is the BaseClass class to be generic. Generic types (such as generic classes, interfaces, or type aliases) work differently in terms of their generic parameters scope:

abstract class BaseClass<T extends BaseArgs> {
  constructor(name: string, args: T) {
    this.setFields(args)
  }
  abstract setFields(args: T): void
}

This is akin to:

interface BaseClass<T extends BaseArgs> {
  setFields(args: T): void
}

Now, there isn't such thing as "an instance of BaseClass" without specifying the type argument. It can only exist as "an instance of BaseClass<BaseArgs>" or "an instance of BaseClass<SomeOtherArgs>". Thus, a subclass of BaseClass can extend beyond just BaseClass to

BaseClass<T></code for any desired <code>T

. For instance, the following is acceptable:

class Child extends BaseClass<ChildArgs> {
  setFields(args: ChildArgs): void { } // okay
}

Since an instance i of Child is essentially an instance of BaseClass<ChildArgs>, only a ChildArgs argument can be used with i.setFields(). This setup grants the implementer control over the type arguments while restricting the caller.

Link to Playground code

What is the best way to implement a generic parameter with constraints in an abstract method?

Answer №1

Similar questions

What is the best approach to retrieve all user information using React with TypeScript and the Redux Toolkit?

Exploring table iteration in Angular 7

Having difficulties incorporating a selected custom repository into a module

Unsure about the commit hash referenced in the tsd.json file

The `Home` object does not have the property `age` in React/TypeScript

Transformation occurs once you subscribe to an observable entity

Combining Two Dropdown Selections to Create a Unique Name using Angular

Implementing Asynchronous context tracking within a Remix application utilizing Express as the server

Ways to indicate in Typescript that a value, if it exists, is not undefined

Expo background fetch initialized but not activated

Can a TypeScript generic version of the Y-combinator be successfully executed?

Determine the generic parameter of the output type by analyzing the resolved value of a data type within the function

The error code TS2345 indicates that the argument '{ read: typeof ElementRef; }' cannot be assigned to the parameter '{ read?: any; static: boolean; }'

Elements are unresponsive to scrolling inputs

Tips for accurately implementing the onHoverIn TS type in the React Native Web Pressable component

Jest encountering errors when compiling a generic function

Unexpected runtime error when using Prisma with NodeJS and Express

Creating a comprehensive object within a single interface using Typescript

Using a configuration file with the JavaScriptServices React-Redux template

Strategies for effectively searching and filtering nested arrays