"The Promise of Generics in Typescript: Unlocking Unique Return

Question

"The Promise of Generics in Typescript: Unlocking Unique Return

In my current project, I am working on implementing a function that will always return a fulfilled promise of the same "type" that is passed to it as a parameter.

This means that if I call the function with a boolean parameter, it should return a fulfilled Promise with a boolean value. The same goes for any other data type such as strings, numbers, etc.

Here's what I've attempted so far:

const createFulfilledPromise = <T>(val: T): Promise<T> => {
    return Promise.resolve(val);
};

I'm not certain if this is the most effective way to achieve this functionality, and I have encountered issues when trying to get a Promise<void>.

Any suggestions or advice on how to improve this implementation would be greatly appreciated.

typescript generics promise typescript-generics

Answer 1

Answer №1

Your code implementation appears to be correct, but one issue with using void is that the parameter is still expected. Instead, you can call it with undefined

const PromiseOK = <T>(val: T): Promise<T> => {
    return Promise.resolve(val);
};

PromiseOK<void>(undefined)

An alternative approach would be to utilize overloads for custom behavior when dealing with void:

function PromiseOK(): Promise<void>
function PromiseOK<T>(val: T): Promise<T>
function PromiseOK<T>(val?: T): Promise<T> {
    return Promise.resolve(val);
};

PromiseOK() // Promise<void>
PromiseOK(1) //Promise<number>

Although not very elegant, it is possible to have overloads with arrow functions as well:

const PromiseOK: {
    (): Promise<void>
    <T>(val: T): Promise<T>
} = <T>(val?: T): Promise<T> => Promise.resolve(val);

PromiseOK() // Promise<void>
PromiseOK(1) //Promise<number>

Answer 2

Your code implementation appears to be correct, but one issue with using void is that the parameter is still expected. Instead, you can call it with undefined

const PromiseOK = <T>(val: T): Promise<T> => {
    return Promise.resolve(val);
};

PromiseOK<void>(undefined)

An alternative approach would be to utilize overloads for custom behavior when dealing with void:

function PromiseOK(): Promise<void>
function PromiseOK<T>(val: T): Promise<T>
function PromiseOK<T>(val?: T): Promise<T> {
    return Promise.resolve(val);
};

PromiseOK() // Promise<void>
PromiseOK(1) //Promise<number>

Although not very elegant, it is possible to have overloads with arrow functions as well:

const PromiseOK: {
    (): Promise<void>
    <T>(val: T): Promise<T>
} = <T>(val?: T): Promise<T> => Promise.resolve(val);

PromiseOK() // Promise<void>
PromiseOK(1) //Promise<number>

Answer 3

Answer №2

The original poster is seeking to correlate the Type of the parameter with the return value.

Nonetheless, if you desire a truly versatile promise where the return type is determined dynamically by the caller, consider using this approach.

const bar = <U>(baz: Baz): Promise<U> => {
  return new Promise<U>((resolve, reject) => {
    // assign any value with type U to resolve
    // for instance, API response: U
  });
};

// Example of how to use it
bar<CustomType>(someValueForBaz).then().catch();

Answer 4

The original poster is seeking to correlate the Type of the parameter with the return value.

Nonetheless, if you desire a truly versatile promise where the return type is determined dynamically by the caller, consider using this approach.

const bar = <U>(baz: Baz): Promise<U> => {
  return new Promise<U>((resolve, reject) => {
    // assign any value with type U to resolve
    // for instance, API response: U
  });
};

// Example of how to use it
bar<CustomType>(someValueForBaz).then().catch();

Answer 5

Answer №3

Here is an example of how it should appear:

An example function using Promise in TypeScript:
function PromiseOK<T>(val: T): Promise<T> {
    return Promise.resolve(val);
};

If you prefer to use the fat arrow notation:

Another example with fat arrow notation:
const PromiseOK = <T extends any>(val: T): Promise<T> => {
    return Promise.resolve(val);
};

The usage of T extends any also works for void.

Answer 6

Here is an example of how it should appear:

An example function using Promise in TypeScript:
function PromiseOK<T>(val: T): Promise<T> {
    return Promise.resolve(val);
};

If you prefer to use the fat arrow notation:

Another example with fat arrow notation:
const PromiseOK = <T extends any>(val: T): Promise<T> => {
    return Promise.resolve(val);
};

The usage of T extends any also works for void.

"The Promise of Generics in Typescript: Unlocking Unique Return

Answer №1

Answer №2

Answer №3

Similar questions

What are the steps to fix the error stating that 'loginError.data' is an unknown type?

What is the best way to overload a function based on the shape of the argument object in

What is the best way to change a Date stored in an array to a string format? [angular4]

Troubleshooting: Issues with APIGateway's Default Integration

How to utilize the async pipe on an observable<Object> and connect it to a local variable in the HTML using Angular

Angular does not allow the transfer of property values from one to another

Is there a technique to block small increments in a Time Input field?

Encountering error TS2304: Cannot resolve name 'classes' when attempting to apply styling in React using Typescript

Error: Trying to modify a property that is set as read-only while attempting to override the toString() function

Storing a string in a variable within Typescript

Creating a nested/child route structure within the Angular 2 router

Webpack converts 'import' statements to 'require'

Error: The term 'makeStyles' cannot be found in the '@material-ui/core' module after installing Material-ui-pickers

Is it advisable to move operations outside of the useEffect hook?

Error happens while running the setInterval loop in the code execution

Bluebird's premature return in express/mongoose is causing unexpected issues

In Angular, you can easily modify and refresh an array item that is sourced from a JSON file by following these steps

Retrieve particular key from document in MongoDB based on provided value

Typescript causing undefined React Router match issue

Altering or including new space variables within a custom Chakra-ui theme