Extending a Type with TypeScript Generics

Question

Extending a Type with TypeScript Generics

Encountering difficulties compiling the code below. This snippet is part of an older project with the note - "This is a TS1.8 feature. Leave it in to ensure the environment is running the right ts".

  function assign<T extends U, U>(target: T, source: U): T {
        for (let id in source) {
            target[id] = source[id]; // error TS2322: Type 'U[Extract<keyof U, string>]' is not assignable to type 'T[Extract<keyof U, string>]'.
        } 
        return target;
    }

Trying to compile it with this command

tsc -p tsconfig.json

And using this tsconfig.json file

{
  "include": [
    "Scripts/TypeScripts/**/*"
  ],
  "compilerOptions": {
    "target": "es5",
    "module": "amd",
    "sourceMap": false,
    "watch": false
  }
}

tsc -v shows Version 3.4.5.

Testing it on the playground, I also encounter the same error, raising doubts about the validity of the code. This leads me to question why I wrote that comment and how it managed to compile for 2 years (if it did).

Hence my query: Is this valid TypeScript code? If not, was it ever?

Thank you :-)

typescript

Answer 1

Answer №1

It seems to me that this code may not be valid, especially if you haven't worked with TS1.8 before. The issue with T extends U is that even though all of the property keys in U must exist in T, the values at those keys could be narrower. Take a look at this example:

function badAssign<T extends U, U>(target: T, source: U): T {
  for (let id in source) {
    target[id] = source[id] as any;
  }
  return target;
}

By using this function, unexpected behavior can occur. For instance:

interface Ewe {
  w: string;
  x: number;
  y: boolean;
}
interface Tee extends Ewe {
  w: "hey";
  x: 1;
  y: true;
  z: object;
}

const t: Tee = { w: "hey", x: 1, y: true, z: {} };
const u: Ewe = { w: "you", x: 2, y: false };
const newT = badAssign(t, u); 
newT.w // This will output "hey" at compile time but "you" at runtime
newT.x // Will show 1 at compile time and 2 at runtime
newT.y // True at compile time, false at runtime

This inconsistency arises because when T extends U, it means that the type of target[id] is potentially narrower than source[id], which contradicts what the function presumes.

A better approach would be to use Pick<T, K> instead of U, specifying a subset of keys from T. This ensures that every key found in target also exists in

source</code, maintaining proper value assignment:</p>

<pre><code>function assign<T, K extends keyof T>(target: T, source: Pick<T, K>): T {
  for (let id in source) {
    target[id] = source[id]; 
  }
  return target;
}

This updated method eliminates errors like the one seen previously:

assign(t, u); // Now produces an error since string is not assignable to "hey"

But allows for correct usage of assign() as intended:

let target = { a: "hey", b: 123, c: true };
let source = { a: "you", c: false };
const ret = assign(target, source);

I hope this explanation helps you improve your code structure. Good luck!

Link to code

Answer 2

It seems to me that this code may not be valid, especially if you haven't worked with TS1.8 before. The issue with T extends U is that even though all of the property keys in U must exist in T, the values at those keys could be narrower. Take a look at this example:

function badAssign<T extends U, U>(target: T, source: U): T {
  for (let id in source) {
    target[id] = source[id] as any;
  }
  return target;
}

By using this function, unexpected behavior can occur. For instance:

interface Ewe {
  w: string;
  x: number;
  y: boolean;
}
interface Tee extends Ewe {
  w: "hey";
  x: 1;
  y: true;
  z: object;
}

const t: Tee = { w: "hey", x: 1, y: true, z: {} };
const u: Ewe = { w: "you", x: 2, y: false };
const newT = badAssign(t, u); 
newT.w // This will output "hey" at compile time but "you" at runtime
newT.x // Will show 1 at compile time and 2 at runtime
newT.y // True at compile time, false at runtime

This inconsistency arises because when T extends U, it means that the type of target[id] is potentially narrower than source[id], which contradicts what the function presumes.

A better approach would be to use Pick<T, K> instead of U, specifying a subset of keys from T. This ensures that every key found in target also exists in

source</code, maintaining proper value assignment:</p>

<pre><code>function assign<T, K extends keyof T>(target: T, source: Pick<T, K>): T {
  for (let id in source) {
    target[id] = source[id]; 
  }
  return target;
}

This updated method eliminates errors like the one seen previously:

assign(t, u); // Now produces an error since string is not assignable to "hey"

But allows for correct usage of assign() as intended:

let target = { a: "hey", b: 123, c: true };
let source = { a: "you", c: false };
const ret = assign(target, source);

I hope this explanation helps you improve your code structure. Good luck!

Link to code

Answer 3

Answer №2

It appears that you included it as a safeguard to catch errors in case TypeScript is older than version 1.8.

According to the "What's new in TypeScript" documentation for version 1.8, in the section "Type parameters as constraints":

In TypeScript 1.8, type parameters can now be used as constraints that refer to other type parameters within the same list. Previously, this would result in an error. This feature is commonly known as F-Bounded Polymorphism.

Example
function assign<T extends U, U>(target: T, source: U): T {
    for (let id in source) {
        target[id] = source[id];
    }
    return target;
}

let x = { a: 1, b: 2, c: 3, d: 4 };
assign(x, { b: 10, d: 20 });
assign(x, { e: 0 });  // Error

Answer 4

It appears that you included it as a safeguard to catch errors in case TypeScript is older than version 1.8.

According to the "What's new in TypeScript" documentation for version 1.8, in the section "Type parameters as constraints":

In TypeScript 1.8, type parameters can now be used as constraints that refer to other type parameters within the same list. Previously, this would result in an error. This feature is commonly known as F-Bounded Polymorphism.

Example
function assign<T extends U, U>(target: T, source: U): T {
    for (let id in source) {
        target[id] = source[id];
    }
    return target;
}

let x = { a: 1, b: 2, c: 3, d: 4 };
assign(x, { b: 10, d: 20 });
assign(x, { e: 0 });  // Error

Extending a Type with TypeScript Generics

Answer №1

Answer №2

Similar questions

The object may be null

What is the reason for Typescript not throwing an error when arguments are missing?

Using Ionic with React to smoothly scroll to a selected item in a list

Steps for importing a CommonJS module that exports as a callable into TypeScript

How to apply a single pipe to filter columns in Angular 2 with an array of values

Typescript restricts dynamic property access within objects

Several arrays within the filteredData (MatTableDataSource) are being utilized

Learn how to define an object with string keys and MUI SX prop types as values when typing in programming

Storing the selected value from dynamically generated options in Angular using ngFor

Can the ngx-chips library be used to alter the language of chips?

Achieving CommonJS imports compilation with Typescript

Conserving node.js native imports for Electron with rollup

Utilize the array map function in a React Native functional component with useState to dynamically render content

Setting Up Absolute Imports in Node.js using TypeScript

Can TypeScript Partials be utilized for testing AWS Lambda functions?

Is it possible to perform remote file upload using Selenium in TypeScript?

Tips for creating an HTTP only cookie in NestJS

Tips for transmitting data from Dart to Typescript Cloud functions, encountering the UNAUTHENTICATED error code

A child support route isn't being displayed

Inheriting static attributes in Typescript without using the static keyword