Strategies for setting the output value for a defined generic type

Question

Strategies for setting the output value for a defined generic type

Is there a way to create a function that accepts optional properties common across different types, while also requiring specific properties based on the generic type passed in?

type Diff<T, U> = T extends U ? never : T
type DiffTypes<T, U> = { [Key in Diff<keyof T, keyof U>]: T[Key] }

interface Common {
    name: string
}

interface One {
    name: string
    one: 1
}

interface Two {
    name: string
    two: 2
}

interface Three {
    name: string
    three: 3
}

type Numbers = One | Two | Three

const test = <T extends Numbers>(obj: Partial<Common> & DiffTypes<T, Common>): T => ({name: 'Default', ...obj})

I'm receiving this error:

Type '{ name: string; } & Partial<Common> & DiffTypes<T, Common>' is not assignable to type 'T'.

Playground link here

Edit: I also want to ensure that the generic type can only be One, Two, or Three.

Is this feasible? Are there alternative approaches to consider?

typescript

Answer 1

Answer №1

Were you looking for this instead?

type Remove<T, K extends keyof T> = {[P in Exclude<keyof T, K>]: T[P]};
type Nullable<T, U extends keyof T = keyof T> = Remove<T, U> & Partial<Pick<T, U>>;

const example = <T extends Numbers>(missing: Nullable<T, keyof Common>): Common & typeof missing => ({
    name: 'Default',
    ...missing
});

Example:

example<One>({ one: 1 });
example<One>({ one: 1, name: 'whooo' });
example<Two>({ two: 2 });
example<Three>({ three: 3 });

example<One>({ name: 'Bob' }) // Incorrect
example<One>({ two: 2 })      // Incorrect

Answer 2

Were you looking for this instead?

type Remove<T, K extends keyof T> = {[P in Exclude<keyof T, K>]: T[P]};
type Nullable<T, U extends keyof T = keyof T> = Remove<T, U> & Partial<Pick<T, U>>;

const example = <T extends Numbers>(missing: Nullable<T, keyof Common>): Common & typeof missing => ({
    name: 'Default',
    ...missing
});

Example:

example<One>({ one: 1 });
example<One>({ one: 1, name: 'whooo' });
example<Two>({ two: 2 });
example<Three>({ three: 3 });

example<One>({ name: 'Bob' }) // Incorrect
example<One>({ two: 2 })      // Incorrect

Answer 3

Answer №2

In Short: TypeScript struggles with distinguishing between missing and undefined properties

The issue lies in the Partial<Common> within the obj argument type, which actually results in the following interpretation:

{
  name?: string | undefined
}

TypeScript is unable to differentiate between a property being missing and it being specifically set to undefined. This confusion leads to scenarios like:

test<One>({name: undefined})

being considered valid as per the argument type requirements. Providing a value of undefined for name overrides the default setting and does not adhere to the return type criteria, resulting in an error message.

The corresponding issue addressing this can be found at: https://github.com/Microsoft/TypeScript/issues/13195

My Resolution To address this until TypeScript resolves the distinction problem, I chose to cast the overrides object.

const test = <T extends Numbers>(
  obj: Partial<Common> & DiffTypes<T, Common>,
): T => ({ name: 'Default', ...(obj as Common) })

This solution comes with a clear warning that passing undefined should be avoided. However, it effectively handles the situation at hand.

Answer 4

In Short: TypeScript struggles with distinguishing between missing and undefined properties

The issue lies in the Partial<Common> within the obj argument type, which actually results in the following interpretation:

{
  name?: string | undefined
}

TypeScript is unable to differentiate between a property being missing and it being specifically set to undefined. This confusion leads to scenarios like:

test<One>({name: undefined})

being considered valid as per the argument type requirements. Providing a value of undefined for name overrides the default setting and does not adhere to the return type criteria, resulting in an error message.

The corresponding issue addressing this can be found at: https://github.com/Microsoft/TypeScript/issues/13195

My Resolution To address this until TypeScript resolves the distinction problem, I chose to cast the overrides object.

const test = <T extends Numbers>(
  obj: Partial<Common> & DiffTypes<T, Common>,
): T => ({ name: 'Default', ...(obj as Common) })

This solution comes with a clear warning that passing undefined should be avoided. However, it effectively handles the situation at hand.

Strategies for setting the output value for a defined generic type

Answer №1

Answer №2

Similar questions

Is there a way to achieve a seamless compilation in TypeScript?

Step-by-step guide on crafting a harmonious row of a label and a responsive button group

What steps are necessary to ensure that the extended attribute becomes mandatory?

I am experiencing difficulty with VS Code IntelliSense as it is not displaying certain classes for auto-import in my TypeScript project

Tips for converting necessary constructor choices into discretionary ones after they have been designated by the MyClass.defaults(options) method

Creating custom observables by utilizing ViewChildren event and void functions in Angular 12: A step-by-step guide

Angular 13: Issue with displaying lazy loaded module containing multiple outlets in a component

Unraveling the mysteries of an undefined entity

Having trouble with JSON parsing in Promise execution

Material-UI Slide component is encountering an issue where it is unable to access the style property of an undefined variable

Error: The variable _ is undefined when trying to use the .map() function on an array

Secure your NetSuite API calls with OAuth 1.0 signature authorization

What is the process for importing files with nested namespaces in TypeScript?

Is it possible to utilize the $ symbol within the ngOnInit or constructor functions?

Customized IntelliSense naming for overloaded parameters with conditional tuple types

Convert C# delegate into TypeScript

"Creating a sleek and efficient AI chess game using chess.js with Angular's

Are there any methods to utilize Zod for validating that a number contains a maximum of two decimal places?

Are there any restrictions on the amount of data that can be included in a Sankey diagram created from an Excel sheet? I would

The art of representing objects and generating JSON responses