Can anyone provide guidance on how to define a generic constraint that guarantees the value types of a shared key in two different types are identical?

Question

Can anyone provide guidance on how to define a generic constraint that guarantees the value types of a shared key in two different types are identical?

I am currently working on a function that copies fields from one object to another, and I have two main requirements:

The key provided must be common between both objects.
The value type corresponding to the given key should be the same in both objects.

How can I enforce the second constraint? Below is my current implementation.

function copyField<T1, T2>(input: T1, output: T2, key: keyof T1 & keyof T2) {
  const keyValue = input[key]
  output[key] = keyValue // How can I ensure that the key value is the same for both?

  // ^ Error: Type 'T1[keyof T1 & keyof T2]' is not assignable to type 'T2[keyof T1 & keyof T2]'.
  // Type 'T1' is not assignable to type 'T2'. 'T2' could be instantiated with an
  // arbitrary type which could be unrelated to 'T1'.
}

type A = { field: string }
type B = { field: string }

copyField<A, B>({field: 'hello'}, {field: 'world'}, 'field')

Live example on typescriptlang.org

Update

An answer below got me closer to what I want but still doesn't guarantee that the value for the given key is exactly the same. This demonstrates how mismatched types can still compile because the constraint only guarantees that the type is present somewhere on both objects, not necessarily for the given key.

function copyField<K extends string, V>(input: {[k in K]: V}, output: {[k in K]: V}, key: K) {
  const keyValue = input[key]
  output[key] = keyValue
}

type A = { s: string, mismatch: string }
type B = { s: string, mismatch: number }
//                                 ^--- these don't have the same type

const a: A = {s: 'hello', mismatch: 'hello'}
const b: B = {s: 'world', mismatch: 123}

// This compiles, but I want it to only accept 's'
copyField(a, b, 'mismatch')

typescript typescript-generics

Answer 1

Answer №1

Here is a potential solution:

type MatchingKeys<First, Second> = {
    [Key in keyof First & keyof Second]:
        [First[Key], Second[Key]] extends [Second[Key], First[Key]] ? Key : never
}[keyof First & keyof Second]

This code creates a new type by comparing keys from two different objects and determining if their corresponding values are of the same type.

A key K is retained only if

[First[K], Second[K]] extends [Second[K], First[K]]

, indicating that the types of the values at that key match up. If this logic is too strict for your needs, you can adjust it to First[K] extends Second[K] to focus solely on the compatibility of value types.

Play around with this code on the TypeScript Playground!

Answer 2

Here is a potential solution:

type MatchingKeys<First, Second> = {
    [Key in keyof First & keyof Second]:
        [First[Key], Second[Key]] extends [Second[Key], First[Key]] ? Key : never
}[keyof First & keyof Second]

This code creates a new type by comparing keys from two different objects and determining if their corresponding values are of the same type.

A key K is retained only if

[First[K], Second[K]] extends [Second[K], First[K]]

, indicating that the types of the values at that key match up. If this logic is too strict for your needs, you can adjust it to First[K] extends Second[K] to focus solely on the compatibility of value types.

Play around with this code on the TypeScript Playground!

Answer 3

Answer №2

If it's relevant, here is the approach I would take:

function copyField<O, K extends keyof O, I extends Record<K, O[K]>>(
    input: I,
    output: O,
    key: K
) {
    const i: Record<K, O[K]> = input;
    output[key] = i[key];
}

The concept behind this function is to allow the type O of the variable output to be flexible, and enable any key K of O to be used as an argument. Moreover, the type I of input is restricted to Record<K, O[K]>, ensuring that input must have a property at key K with a value that can be assigned to O[K].

It is important to note that strict identity between I[K] and

O[K]</code is not required. What matters is that <code>I[K] extends O[K]</code, allowing for successful copies while preventing erroneous ones.</p>
<p>Additionally, widening <code>input

from type I to its constraint Record<K, O[K]> was necessary within the function implementation to satisfy the compiler.

This function delivers the following desired behavior:

copyField({ good: 0, bad: "", whatever: true }, { good: 4, bad: 1 }, "good"); // This is acceptable
copyField({ good: 0, bad: "", whatever: true }, { good: 4, bad: 1 }, "bad"); // This will result in an error
// ------------------> ~~~
// Type 'string' is not assignable to type 'number'

Note that the error arises in the input parameter rather than the value assigned to "bad" for key. Specifically, it indicates that the property bad is a string which cannot be written into a number property.

Similarly, this setup allows copying from a narrower type to a broader type but prevents the reverse:

copyField({ x: 123 }, { x: Math.random() < 0.5 ? 456 : "789" }, "x"); // This works fine
copyField({ x: Math.random() < 0.5 ? 456 : "789" }, { x: 123 }, "x"); // This will throw an error
// ---------------> ~
// Type 'string | number' is not assignable to type 'number'

The first operation succeeds because copying the number value from input into the wider number | string value of output is safe. Conversely, the second operation fails because it's unsafe to copy a number | string value from input to the narrower number value of output. The accompanying warning clarifies the issue.

Link to code on Playground

Answer 4

If it's relevant, here is the approach I would take:

function copyField<O, K extends keyof O, I extends Record<K, O[K]>>(
    input: I,
    output: O,
    key: K
) {
    const i: Record<K, O[K]> = input;
    output[key] = i[key];
}

The concept behind this function is to allow the type O of the variable output to be flexible, and enable any key K of O to be used as an argument. Moreover, the type I of input is restricted to Record<K, O[K]>, ensuring that input must have a property at key K with a value that can be assigned to O[K].

It is important to note that strict identity between I[K] and

O[K]</code is not required. What matters is that <code>I[K] extends O[K]</code, allowing for successful copies while preventing erroneous ones.</p>
<p>Additionally, widening <code>input

from type I to its constraint Record<K, O[K]> was necessary within the function implementation to satisfy the compiler.

This function delivers the following desired behavior:

copyField({ good: 0, bad: "", whatever: true }, { good: 4, bad: 1 }, "good"); // This is acceptable
copyField({ good: 0, bad: "", whatever: true }, { good: 4, bad: 1 }, "bad"); // This will result in an error
// ------------------> ~~~
// Type 'string' is not assignable to type 'number'

Note that the error arises in the input parameter rather than the value assigned to "bad" for key. Specifically, it indicates that the property bad is a string which cannot be written into a number property.

Similarly, this setup allows copying from a narrower type to a broader type but prevents the reverse:

copyField({ x: 123 }, { x: Math.random() < 0.5 ? 456 : "789" }, "x"); // This works fine
copyField({ x: Math.random() < 0.5 ? 456 : "789" }, { x: 123 }, "x"); // This will throw an error
// ---------------> ~
// Type 'string | number' is not assignable to type 'number'

The first operation succeeds because copying the number value from input into the wider number | string value of output is safe. Conversely, the second operation fails because it's unsafe to copy a number | string value from input to the narrower number value of output. The accompanying warning clarifies the issue.

Link to code on Playground

Answer 5

Answer №3

Give this a shot

function replicateValue<A extends string, B>(source: {[x in A]: B}, destination: {[x in A]: B}, keyToCopy: A) {
  const valueToCopy = source[keyToCopy]
  destination[keyToCopy] = valueToCopy
}

replicateValue({item: 'apple'}, {item: 'banana'}, 'item')

Answer 6

Give this a shot

function replicateValue<A extends string, B>(source: {[x in A]: B}, destination: {[x in A]: B}, keyToCopy: A) {
  const valueToCopy = source[keyToCopy]
  destination[keyToCopy] = valueToCopy
}

replicateValue({item: 'apple'}, {item: 'banana'}, 'item')

Can anyone provide guidance on how to define a generic constraint that guarantees the value types of a shared key in two different types are identical?

Update

Answer №1

Answer №2

Answer №3

Similar questions

Error encountered within eot file using file-loader and webpack

In Ionic3, NgFor is designed to work with Iterables like Arrays for binding

Detecting hoverover on boostrap card-header using TypeScript

Unable to store the outcomes from [ngbTypeahead] in [resultTemplate]

Tips on exporting a basic TypeScript class in an Angular 4 module

Angular 4 yields an undefined result

Code in Javascript to calculate the number of likes using Typescript/Angular

Exploring the automatic type inference functionality of Typescript for generic classes

Angular2: Ways to update components with resolver dependencies?

I find myself hindered by TypeScript when trying to specify the accurate constraints for getUserMedia

Incorporating SVG graphics within a SharePoint web part

Tips for troubleshooting a Typescript application built with Angular 2

Ways to retrieve data beyond the constructor

Exploring ways to customize or replace the extended CurrencyPipe type in Angular

How to use RxJs BehaviorSubject in an Angular Interceptor to receive incoming data

After updating next.config, the NextJS + NextAuth middleware doesn't seem to be triggered

Error in TypeScript when type-checking a dynamic key within a record

What method can I use to reach the controller of a route that has been exported to another route?

Experiencing strange sorting issues with @dnd-kit when moving a draggable element that contains multiple items from the list

The pattern validator in Angular 2 Reactive Forms does not seem to be functioning as expected