Fails to infer the value at a given key for concrete types

[contrarian]

TypeScript Version: 3.8.3

Search Terms:

Expected behavior:

TypeScript should infer the type of value when given the key for a concrete type.

Actual behavior:

TypeScript does not infer the type of value when given the key for a concrete type

Related Issues:

Code

type ValueOf<T> = T[keyof T];

type KeyFor<T, V> = ValueOf<{ [K in keyof T]: T[K] extends V ? K : never }>

type Thing = {
    a: number;
}

type Reader<T> = {
    get: <V>(key: KeyFor<T, V>) => V
}

// when dealing with a generic, TS correctly figures out that the return type is number
function getNumber<T>(reader: Reader<T>, numberKey: KeyFor<T, number>) {
    return reader.get(numberKey);
}

declare const thingReader: Reader<Thing>

// when dealing with the concrete type `Thing`, TS inference fails 
function getNumberFromMyThing(numberKey: KeyFor<Thing, number>) {
    return thingReader.get(numberKey)
}

Output

"use strict";
function getNumber(store, numberKey) {
    return store.get(numberKey);
}
function getNumberFromMyThing(numberKey) {
    return thingReader.get(numberKey);
}

Compiler Options

{
  "compilerOptions": {
    "noImplicitAny": true,
    "strictNullChecks": true,
    "strictFunctionTypes": true,
    "strictPropertyInitialization": true,
    "strictBindCallApply": true,
    "noImplicitThis": true,
    "noImplicitReturns": true,
    "useDefineForClassFields": false,
    "alwaysStrict": true,
    "allowUnreachableCode": false,
    "allowUnusedLabels": false,
    "downlevelIteration": false,
    "noEmitHelpers": false,
    "noLib": false,
    "noStrictGenericChecks": false,
    "noUnusedLocals": false,
    "noUnusedParameters": false,
    "esModuleInterop": true,
    "preserveConstEnums": false,
    "removeComments": false,
    "skipLibCheck": false,
    "checkJs": false,
    "allowJs": false,
    "declaration": true,
    "experimentalDecorators": false,
    "emitDecoratorMetadata": false,
    "target": "ES2017",
    "module": "ESNext"
  }
}

Playground Link: Provided

[RyanCavanaugh]

The problem here is that numberKey was immediately resolved to "a" (which is the right thing to do), so the type information that "a" really meant "All the keys whose values turned out to be numbers" was effectively lost at that point. It's the same as if you had written

    return thingReader.get("a" as const)

The higher-order example can't do this immediate resolution, so works as expected.

In general TS can't simultaneously do higher-order reasoning and immediate resolution at the same time, and this is a case where immediate resolution is general preferable.

[contrarian]

I agree that resolving keys when possible is the correct behaviour. But it's not clear that TS can't simultaneously do higher-order reasoning and immediate resolution at the same time.

The type information "All the keys whose values turned out to be numbers" was not lost.

For example:

// will work as expected
function getNumberFromMyThing(numberKey: KeyFor<Thing, number>): number {
    return thingReader.get(numberKey)
}

getNumberFromMyThing("a") // number
getNumberFromMyThing("b") // error

[contrarian]

In trying to workaround this limitation, I stumbled upon another oddity (Playground Link).

The following will work how I want:

type Value = boolean | number | string 

type KeyFor<T, V extends Value> = ValueOf<{ [K in keyof T]: T[K] extends V ? K : never }>

type Thing = {
    a: number;
}

type Get<T> = {
    <K extends KeyFor<T, Value>>(key: K): T[K]
    <V extends Value>(key: KeyFor<T, V>): V
}

type Reader<T> = {
    get: Get<T> 
}

function getNumber<T>(reader: Reader<T>, numberKey: KeyFor<T, number>) {
    return reader.get(numberKey);
}

declare const thingReader: Reader<Thing>

function getNumberFromMyThing(numberKey: KeyFor<Thing, number>) {
    return thingReader.get(numberKey)
}

But it seems that it should not. It seems that the reader.get call in getNumber should match the first overload since KeyFor<T, number> should extend KeyFor<T, Value>, yet it does not. And because it does not, I can fallback to the previous signature, which works for the generic case. In the concrete case, the first overload matches, and I can use the resolved key to recover the type.

Interestingly, the following will match the first overload:

function getValue<T>(reader: Reader<T>, key:  KeyFor<T, Value>) {
    return reader.get(key);
}