Is it possible to differentiate between Pick<Foo, Bar> and Omit<Foo, Bar> in Typescript?

Question

Is it possible to differentiate between Pick<Foo, Bar> and Omit<Foo, Bar> in Typescript?

I encountered an issue where:

Pick<Foo, Bar> & Omit<Foo, Bar> !== Foo

This situation is perplexing because I anticipated Pick to choose keys in Bar and Omit to select keys not in Bar. However, when attempting this in TypeScript, an error arises:

export function bind<
  TOpts extends Record<string, unknown>,
  TReturn,
  TBound extends keyof TOpts
>(
  fn: (opts: TOpts) => TReturn,
  bound: Pick<TOpts, TBound>
): (opts: Omit<TOpts, TBound>) => TReturn {
  return (opts) => {
    return fn({
      ...bound,
      ...opts,
    });
  };
}

Argument of type 'Pick<TOpts, TBound> & Omit<TOpts, TBound>' is not assignable to parameter of type 'TOpts'.
  'Pick<TOpts, TBound> & Omit<TOpts, TBound>' is assignable to the constraint of type 'TOpts', but 'TOpts' could be instantiated with a different subtype of constraint 'Record<string, unknown>'.

Link to TypeScript playground: TypeScript Playground Link

I'm curious if this error is justified or simply an anomaly resulting from one of TypeScript's optimizations. Specifically, under what circumstances would the assertion not hold true for values of TOpts and TBound?

typescript

Answer 1

Answer №1

This issue with TypeScript is well-documented and acknowledged, as discussed in the following GitHub thread:

The main challenge lies in the fact that when creating an intersection of different subsets within a higher order type using Pick<T, K> or similar methods, it cannot be directly assigned back to that higher order type. When the proposed solution for this problem gets implemented, such workaround assertions will no longer be necessary.

In essence,

Pick<T, K> & Omit<T, K>

should theoretically be assignable to T, but this capability seems elusive to the compiler at present.

(There are certain exceptional scenarios where this assignment wouldn't work as expected. For instance, if T has a call signature like {(): string; a: number}, both Pick and Omit mapped types would lack this call signature, as detailed in microsoft/TypeScript#27575. However, these edge cases are not our primary focus here.)

If you support the implementation of this logic, consider showing your interest by endorsing the GitHub issue above with a 👍 to help the TS team assess community demand. At present, its implementation doesn't seem imminent, and a few upvotes may not expedite the process significantly. Nonetheless, every bit helps.

Until this feature is integrated, employing a type assertion can inform the compiler about your intentions:

return fn({
  ...bound,
  ...opts,
} as TOpts); // okay

Check out the code on the Playground

Answer 2

This issue with TypeScript is well-documented and acknowledged, as discussed in the following GitHub thread:

The main challenge lies in the fact that when creating an intersection of different subsets within a higher order type using Pick<T, K> or similar methods, it cannot be directly assigned back to that higher order type. When the proposed solution for this problem gets implemented, such workaround assertions will no longer be necessary.

In essence,

Pick<T, K> & Omit<T, K>

should theoretically be assignable to T, but this capability seems elusive to the compiler at present.

(There are certain exceptional scenarios where this assignment wouldn't work as expected. For instance, if T has a call signature like {(): string; a: number}, both Pick and Omit mapped types would lack this call signature, as detailed in microsoft/TypeScript#27575. However, these edge cases are not our primary focus here.)

If you support the implementation of this logic, consider showing your interest by endorsing the GitHub issue above with a 👍 to help the TS team assess community demand. At present, its implementation doesn't seem imminent, and a few upvotes may not expedite the process significantly. Nonetheless, every bit helps.

Until this feature is integrated, employing a type assertion can inform the compiler about your intentions:

return fn({
  ...bound,
  ...opts,
} as TOpts); // okay

Check out the code on the Playground

Is it possible to differentiate between Pick<Foo, Bar> and Omit<Foo, Bar> in Typescript?

Answer №1

Similar questions

Recording attributes in a React component with Typescript

Connect one router to another router within the Oak framework, similar to how it is done in

Create a custom template needed by an Angular module using data from a JSON reply

What is the best way to incorporate tailored validation into reactive forms in Angular?

Is there a way to refactor the onAuthStateChanged function from useEffect in firebase to a class component?

The Vue Router hooks are not being activated within the component when utilizing Typescript

Unable to utilize React Icons component as an object value in typescript

Angular 12: Ensure completion of all data fetching operations (using forkJoin) prior to proceeding

TypeScript, express framework, node-dev tool, and a personalized file type loader

The memory heap error in JavaScript arises during the Webpack build process

Can you pass a generic type as a parameter for another generic in Java?

Error: Call stack size limit reached in Template Literal Type

Potential absence of object.ts(2531)

Improving the method to change a string into a string literal in TypeScript

Cannot be assigned to type "never" after applying a type predicate

Using React.PureComponent, the list component efficiently renders each item with optimized performance

Generating a hierarchical structure in Angular by converting a flat array into a Tree array

Error occurs when attempting to instantiate a class with parameters that do not match any available constructor signatures

Exploring the power of TypeScript with React-Router

What is the process to enable mandatory validation after a change in input in Angular 4?