Polymorphic this type does not work with conditional mapped types

[mcsrobert]

TypeScript Version: 3.5.3

Search Terms: Polymorphic this mapped conditional

Code

type NumberedKeys<T> = { [K in keyof T]:
    T[K] extends number ? K : never }[keyof T];

type X = NumberedKeys<Example>;

class Example {
    public a: number;
    public b: string;
    public c: number;

    public constructor() {
        this.a = 3;
        this.b = "hello";
        this.c = 42;
    }

    public getNumber(key: NumberedKeys<this>): number {
        return this[key];
    }
}

Expected behavior: NumberedKeys<Example> works fine, but NumberedKeys<this> does not.

Actual behavior:

Type 'this[{ [K in keyof this]: this[K] extends number ? K : never; }[keyof this]]' is not assignable to type 'number'.
  Type 'this[this[keyof this] extends number ? keyof this : never]' is not assignable to type 'number'.
    Type 'this[keyof this]' is not assignable to type 'number'.
      Type 'this[string] | this[number] | this[symbol]' is not assignable to type 'number'.
        Type 'this[string]' is not assignable to type 'number'.

Playground Link: link

Related Issues: n/a

[jack-williams]

I'm not sure if this approach is possible because a key type may not constrain the type of values it maps to, it can only say that is a key of some type. (If someone does have a solution I'd be interested to see it!)

Would this work for your use-case?

public getNumber<K extends keyof this>(this: Record<K, number>, key: K): number {
    return this[key];
}

[mcsrobert]

@jack-williams I cannot seem to get that to work. When constructing the class I get:

The 'this' context of type 'Example' is not assignable to method's 'this' of type 'Record<"getNumber", number>'.
  Types of property 'getNumber' are incompatible.
    Type '<K extends "a" | "b" | "c" | "getNumber">(this: Record<K, number>, key: K) => number' is not assignable to type 'number'.

[jack-williams]

Can you post an extended example?

Here is my version: playground

[mcsrobert]

@jack-williams I got your example working eventually. The problem is that I need access to other properties of this. This is not possible with Record.

The problem I'm trying to solve is a generalised, inheritable version of DataLoader priming.

I can use keyof this here, but I was trying to see if there was a way to have stricter typing for this, when I ran into the issue above. I've posted the extended example here.

[RyanCavanaugh]

We can tell from inspection that NumberedKeys returns keys where the looked up property is of type number, but TypeScript can't do the kind of higher-order reasoning to realize that this means the resulting type, when indexed back in to the same type, has that effect in the general case.

[EduardoRFS]

I also hit that today when was trying to make an amazing type definition, minimum example:

type PickProperties<T, P> = Pick<T, {
  [K in keyof T]: T[K] extends P ? K : never;
}[keyof T]>;
type Numbers<T> = PickProperties<T, number>;
type Identity<T extends number> = T;

const use = <T, K extends keyof Numbers<T>>(
  service: K,
  fn: Identity<Numbers<T>[K]>
): void => {}

@RyanCavanaugh it's that hard to implement a constrain based on keyof? Because the constrain that Numbers<T> will always returns { [key: string]: number } so + keyof will result in T[K] being always a number.

edit, workaround found:

// same code as above just append it
type IsNumbers<T> = T extends number ? T : never;
const use = <T, K extends keyof Numbers<T>, U extends IsNumbers<T[K]>>(
  service: K,
  fn: Identity<U>
): void => {}