如何从键而不是值推断类型参数？

Question

I have a class representing a directed graph structure, which is generic with one type parameter K extends string for the node names. A graph is constructed by passing an object like {a: ['b'], b: []} which in this minimal example represents two nodes a and b , with one edge a → b .

class Digraph<K extends string> {
    constructor(readonly adjacencyList: Record<K, K[]>) {}

    getNeighbours(k: K): K[] {
        return this.adjacencyList[k];
    }
}

However, declared like this, the type parameter K is inferred from the contents of the arrays, instead of from object's property names. This means K becomes 'b' instead of 'a' | 'b' 'a' | 'b' , and so Typescript gives an error because it thinks a is an excess property in an object literal.

// inferred as Digraph<'b'> instead of Digraph<'a' | 'b'>
// error: Argument of type '{ a: string[]; b: never[]; }' is not assignable to parameter of type 'Record<"b", "b"[]>'.
let digraph = new Digraph({
    a: ['b'],
    b: [],
});

Is there a way to have K inferred directly from the property names, instead of their values?

Playground Link

---

One solution I tried is to add another type parameter T extends Record<K, K[]> and declare constructor(readonly adjacencyList: T) {} . Then the excess property error goes away, but now K is only inferred as string .

Also, the type Digraph<K, T> is too specific - two digraphs with the same nodes should be assignable to each other even when they have different edges, and I'd rather not have to write Digraph<K, Record<K, K[]>> or Digraph<K, any> to get around this. I'm looking for a solution which doesn't add an extra type parameter or change what K would be, if possible.

Answer 1

It seems you're looking for a NoInfer<T> type that states that T should only be used for type checking but not for inference, as discussed in this TypeScript issue . It hasn't been added to TypeScript, but this definition from jcalz works for your code:

type NoInfer<T> = [T][T extends any ? 0 : never];

If you rewrite the record as Record<K, NoInfer<K>[]> the class becomes

class Digraph<K extends string> {
    constructor(readonly adjacencyList: Record<K, NoInfer<K>[]>) {}

    getNeighbours(k: K): K[] {
        return this.adjacencyList[k];
    }
}

and the digraph example gets typed correctly:

// inferred type: Digraph<"a" | "b">
let digraph = new Digraph({
    a: ['b'],
    b: [],
});

TypeScript playground

Keep in mind it's still kind of a hack though, and future improvements might enable the type checker to infer NoInfer<T> = T and stop it from blocking inference.

Answer 2

So your problem is that there are multiple inference site candidates for K in the type Record<K, K[]> , and that the compiler's inference algorithm is giving priority to the wrong one. You would like to be able to tell the compiler that it should not use the second K (in the elements of the array in the property value position) for inference, and that it should only use the first K (in the property key position) for this purpose. It should only pay attention to that second site after K is inferred, and only to check that the inferred type works.

---

There is an open issue at microsoft/TypeScript#14829 asking for such non-inferential type parameter usages . The idea is that there should be some type function called NoInfer<T> where the type NoInfer<T> eventually evaluates just to T , but only after type inference has occurred. Then you would write this:

class Digraph<K extends string> {
    constructor(readonly adjacencyList: Record<K, NoInfer<K>[]>) { }

    getNeighbours(k: K): K[] {
        return this.adjacencyList[k];
    }
}

and everything should just work.

---

While no official version of NoInfer exists, there are some user-made implementations mentioned inside microsoft/TypeScript#14829 that work for some use cases. The one I tend to recommend is:

type NoInfer<T> = [T][T extends any ? 0 : never];

Evaluation of the conditional type T extends any? 0: never T extends any? 0: never is (currently for TS4.2) deferred until T is a specific type. So while NoInfer<T> will eventually evaluate to T , the compiler cannot see this.

Hopefully microsoft/TypeScript#14829 will eventually get an official implementation, so that the workarounds mentioned in there can be abandoned in favor of it. Or at least the existing workarounds would get promoted to supported features. (The type NoInfer<T> = T & {} version is about as supported as it can be , but unfortunately that will not work for your use case.)

---

Anyway, you can check that this definition of NoInfer<T> will behave as you want in your example code:

let digraph = new Digraph({
    a: ['b'],
    b: [],
}); // okay, Digraph<"a" | "b">

let badDigraph = new Digraph({
    a: ['c'], // error, "c" is not assignable to "a" | "b"
    b: []
})

Playground link to code