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

Tips on implementing computed properties in Vue.js while using TypeScript

Shifting the use of @Inject(MAT_DIALOG_DATA) away from class constructors

Uh-oh! A circular dependency has been detected in the Dependency Injection for UserService. Let's untangle this web and fix the issue!

typescript locate within the union type in the mapping expression

Is it possible to bind parameters in the select clause using TypeORM?

Accessing form objects in Typescript with AngularJS

"When attempting to render a Node inside the render() method in React, the error message 'Objects are not valid as a React child' is

Can you explain how to incorporate a node module script into a React.js project?

Navigating to a Different Page in Angular 7

Accessing a data property within an Angular2 route, no matter how deeply nested the route may be, by utilizing ActivatedRoute

How can I restrict the return type of a generic method in TypeScript based on the argument type?

Parsing JSON objects with identifiers into TypeScript is a common task in web development

A mistake has occurred: Unhandled promise rejection TypeError: Unable to assign the property 'devices' to an undefined object in Ionic 4 with Angular

The Redux Toolkit Slice is encountering an issue where it generates the incorrect type of "WritableDraft<AppApiError> when the extraReducer is

Declaring Typescript modules across multiple .d.ts files

Accessing the 'comment' property within the .then() function is not possible if it is undefined

Encountered an issue while using OpenAPI 3.1 with openapi-generator-cli typescript-fetch. Error: JsonParseException - The token 'openapi' was not recognized, expected JSON String

Issues with updating values in Angular form controls are not being resolved even with the use of [formControl].valueChanges

Is it feasible to evaluate a Typescript method parameter decorator at request time in a nodejs+nestjs environment rather than just at build time?

An issue occurred: Unable to access the 'login' property because of a TypeError