如何 typescript 严格键入条件 function？

Question

I am looking for real a Typescript nerd to help me with this. I am trying to create a function with two parameters; key as the key of an interface and value as the value of the type of this key on the interface. To constrain the types, I would like to pass as conditional type the key, so the function doesn't allow me to introduce a value with a type different than the defined to that key on the interface. Here is an example of the approach:

interface A {
    a: number;
    b: string;
    c: boolean;
}

function Test<T extends keyof A> (key: T, value: Pick<A, T>){

    return;

}
/* Expected results */

const res = Test<'a'>('a', 1) //ok
const res = Test<'a'>('a', true) //wrong
const res = Test<'d'>('d', true) //wrong
const res = Test<''>('', true) //display autocompletion of possible values (keys of A)

I am looking for these things:

1. Autocompletion of the available key values
2. That the function yells at me if I set a value with a type different than the defined for that key in interface A

I accept other approaches if they are as strict as this one.

Regards

Answer 1

Try using A[T] instead of Pick<A, T> .

interface A {
    a: number;
    b: string;
    c_more_to_show_autocomplete: boolean;
}

declare function Test<T extends keyof A>(key: T, value: A[T]): void;

const res = Test('a', 1) //ok
const res = Test('a', true) //wrong
const res = Test('d', true) //wrong
const res = Test('c_', true) //display autocompletion of possible values (keys of A)

TypeScript playground

Answer 2

The generic described by @CameronLittle will do what you want. If will infer the type of the key based on the provided string and enforce that the values match that key.

But since you asked for a "real Typescript nerd" I feel compelled to point out that techically you can pass invalid arguments if you set the generic yourself rather than letting it be inferred. For example:

const res = Test<keyof A>('a', true);

This is not an error because 'a' is assignable to keyof A and true is assignable to A[keyof A] . We would ideally like this to be an error since true is not assignable to A['a'] .

The most type-safe approach is to use a union of valid pairings rather than a generic.

type Args = {
    [K in keyof A]: [K, A[K]];
}[keyof A]

The above mapped type resolves to the union:

type Args = ["a", number] | ["b", string] | ["c", boolean]

These tuples are the arguments that we want Test to accept.

function Test(...args: Args): void {};

This gives us proper typechecking and eliminates the possibility that we can call it invalidly.

const res1 = Test('a', 1) //ok
const res2 = Test('a', true) //wrong
const res3 = Test('d', true) //wrong
const res4 = Test('c', true) //ok

Typescript Playground Link