How can we limit the parameter value depending on the keys of a generic parameter?

Question

How can we limit the parameter value depending on the keys of a generic parameter?

Below is a simplified example of what I am trying to achieve. The class B has a generic parameter "T" and I want to restrict the allowed values of some method parameters to only those that match the keys of the parameter "T".

In my simplistic understanding, the code below should do what I think I intend. However, I keep encountering errors on the specified lines.

My goal is to limit the values when calling something like the "foo" method to only those that correspond to the T parameter. For instance, b.foo("asdf") would be acceptable, but b.foo("qwerty") would not be (as "qwerty" is not in keyof A).

Any guidance on how to make progress with this would be greatly appreciated.

interface A {
    asdf: string;
}

type Names<X extends A> = X extends A ? keyof X : never;

class B<T extends A> {
    foo(N: Names<T>) {

    }

    baz(n: Names<T>) {
        this.foo("asdf"); // Argument of type '"asdf"' is not assignable to parameter of type 'Names<T>'.ts(2345)
        this.foo("qwerty"); // expect an error here, but not the other ones

        this.foo(n); // fine?
    }
}

interface C extends A {
    qwerty: string;
}

class D<T extends C> extends B<T> {
    bar() {
        this.foo("asdf"); // Argument of type '"asdf"' is not assignable to parameter of type 'Names<T>'.ts(2345)

        this.foo("qwerty"); // Argument of type '"qwerty"' is not assignable to parameter of type 'Names<T>'.ts(2345)
        this.baz("asdf"); // Argument of type '"asdf"' is not assignable to parameter of type 'Names<T>'.ts(2345)
        this.baz("qwerty"); // Argument of type '"qwerty"' is not assignable to parameter of type 'Names<T>'.ts(2345)
    }
}

typescript typescript-generics

Answer 1

Answer №1

Looking at the example provided, all that's required is to directly employ the utilization of the keyof operator instead of explicitly defining Names (although you could define

type Names<X extends A> = keyof X

):

interface A {
  asdf: string;
}


class B<T extends A> {
  foo(N: keyof T) {

  }

  baz(n: keyof T) {
    this.foo("asdf"); // acceptable
    this.foo("qwerty"); // error
    this.foo(n); // acceptable
  }
}

interface C extends A {
  qwerty: string;
}

class D<T extends C> extends B<T> {
  bar() {
    this.foo("asdf"); // acceptable
    this.foo("qwerty"); // acceptable
    this.baz("asdf"); // acceptable
    this.baz("qwerty"); // acceptable
    this.baz("blork"); // produces an error
  }
}

This particular code snippet compiles without any errors, achieving the intended result.

Alternatively, your definition of Names<T> closely resembles

type AllKeysOf<T> = T extends unknown ? keyof T : never;

(with the exception that Names's input is constrained to A). This represents a distributive conditional type, which divides the input into its individual union components, retrieves the keys for each component, and then combines them back into a union. So while keyof (A | B) corresponds to the intersection of keys from each union component, equivalent to (keyof A) & (keyof B), the type AllKeysOf<A | B> equates to the union (keyof A) | (keyof B). Depending on the specific use case, this distinction may be significant.

However, conditional types reliant on generic type parameters, like Names<T> within the bodies of the B and D classes, aren't actually assessed by the compiler. It temporarily defers their assessment, rendering them opaque types. Within the context of the baz() method in B<T>, for instance, the compiler lacks insight into the potential type represented by

Names<T></code, thus opting to reject everything as a precautionary measure. Therefore, although we might deduce that <code>"asdf"

can be assigned to

Names<T></code if <code>T extends A

, the compiler struggles with such deductions and issues warnings. Consequently, it's advisable to avoid utilizing generic conditional types unless absolutely necessary: when keyof T suffices, it should take precedence over Names<T>.

Access the Playground link to view the code

Answer 2

Looking at the example provided, all that's required is to directly employ the utilization of the keyof operator instead of explicitly defining Names (although you could define

type Names<X extends A> = keyof X

):

interface A {
  asdf: string;
}


class B<T extends A> {
  foo(N: keyof T) {

  }

  baz(n: keyof T) {
    this.foo("asdf"); // acceptable
    this.foo("qwerty"); // error
    this.foo(n); // acceptable
  }
}

interface C extends A {
  qwerty: string;
}

class D<T extends C> extends B<T> {
  bar() {
    this.foo("asdf"); // acceptable
    this.foo("qwerty"); // acceptable
    this.baz("asdf"); // acceptable
    this.baz("qwerty"); // acceptable
    this.baz("blork"); // produces an error
  }
}

This particular code snippet compiles without any errors, achieving the intended result.

Alternatively, your definition of Names<T> closely resembles

type AllKeysOf<T> = T extends unknown ? keyof T : never;

(with the exception that Names's input is constrained to A). This represents a distributive conditional type, which divides the input into its individual union components, retrieves the keys for each component, and then combines them back into a union. So while keyof (A | B) corresponds to the intersection of keys from each union component, equivalent to (keyof A) & (keyof B), the type AllKeysOf<A | B> equates to the union (keyof A) | (keyof B). Depending on the specific use case, this distinction may be significant.

However, conditional types reliant on generic type parameters, like Names<T> within the bodies of the B and D classes, aren't actually assessed by the compiler. It temporarily defers their assessment, rendering them opaque types. Within the context of the baz() method in B<T>, for instance, the compiler lacks insight into the potential type represented by

Names<T></code, thus opting to reject everything as a precautionary measure. Therefore, although we might deduce that <code>"asdf"

can be assigned to

Names<T></code if <code>T extends A

, the compiler struggles with such deductions and issues warnings. Consequently, it's advisable to avoid utilizing generic conditional types unless absolutely necessary: when keyof T suffices, it should take precedence over Names<T>.

Access the Playground link to view the code

How can we limit the parameter value depending on the keys of a generic parameter?

Answer №1

Similar questions

Click the button to apply a custom pipe for filtering the Angular table

Creating a new TypeScript file via the command line: A step-by-step guide!

What is the best way to simulate the axios call within my express controller?

Comparison between modules and standalone components

Using Rxjs to reset an observable with combineLatest

Why does React redirect me to the main page after refreshing the page, even though the user is authenticated in a private route?

How can I retrieve the value of an array using ngForm in Angular 2?

Discover the method for extracting a value from an interface and incorporating it into a separate function

I'm having trouble grasping the concept of 'globals' in TypeScript/NodeJS and distinguishing their differences. Can someone explain it to me?

Enhance your TypeScript classes with decorators that can add new methods to your class

The parameter type 'Contact' cannot be assigned to the argument type '{ [x: string]: any; }'

Loading an HTML file conditionally in an Angular 5 component

Developing a custom data structure that identifies the keys of an object with a designated nested attribute

Exploring Angular 8: Connecting elements to an array filled with objects

Update ngx-datatable when the user clicks on a different directive

During the ng build process, an error is encountered stating, "Cannot read the property 'kind' of undefined."

What is the process for overriding the module declaration for `*.svg` in Next.js?

Tips for expanding/collapsing accordion tab with the click of a button

How can I assign two different colors based on the type in Typescript?

Guide to declaring a dynamic type variable based on a constructor parameter