Creating a versatile function that can function with or without promises is a valuable skill to have

Question

Creating a versatile function that can function with or without promises is a valuable skill to have

I am currently working on developing a versatile sort function that can function with or without promises seamlessly.

The intended structure of the function should look something like this:

function sort<T>(list: T[], fn: (item: T) => string | number): T[];
function sort<T>(list: Promise<T[]>, fn: (item: T) => string | number): Promise<T[]>;

The objective is to be able to use the function regardless of whether the input list is a promise or not, while ensuring that the return type matches the input type.

I have implemented similar constructions for other data types, such as a map function that works for both arrays and objects. However, dealing with promises adds an extra layer of complexity, as marking the method as async would require it to always return a promise.

Is there a way to achieve this? Can this be done?

typescript

Answer 1

Answer №1

After some trial and error, I was able to figure out the solution on my own. The key is to utilize the ability to chain promises:

function sort<T>(list: T[], fn: (item: T) => string | number): T[];
function sort<T>(list: Promise<T[]>, fn: (item: T) => string | number): Promise<T[]>;
function sort<T>(list: Promise<T[]> | T[], fn: (item: T) => string | number): Promise<T[]> | T[] {
  const doPlainArraySort = (items: T[]): T[] => { /* Implement your sorting algorithm here */ };

  if (list instanceof Promise) {
    return list.then(doPlainArraySort);
  }

  return doPlainArraySort(list);
}

The only drawback of this approach is that determining whether an object is a promise may not be straightforward, but aside from that, it functions as intended!

Answer 2

After some trial and error, I was able to figure out the solution on my own. The key is to utilize the ability to chain promises:

function sort<T>(list: T[], fn: (item: T) => string | number): T[];
function sort<T>(list: Promise<T[]>, fn: (item: T) => string | number): Promise<T[]>;
function sort<T>(list: Promise<T[]> | T[], fn: (item: T) => string | number): Promise<T[]> | T[] {
  const doPlainArraySort = (items: T[]): T[] => { /* Implement your sorting algorithm here */ };

  if (list instanceof Promise) {
    return list.then(doPlainArraySort);
  }

  return doPlainArraySort(list);
}

The only drawback of this approach is that determining whether an object is a promise may not be straightforward, but aside from that, it functions as intended!

Creating a versatile function that can function with or without promises is a valuable skill to have

Answer №1

Similar questions

Replacing text with new content when text is stored in a separate file

Retrieving Headers from a POST Response

Karma's connection was lost due to a lack of communication within 10000 milliseconds

Creating a custom class to extend the Express.Session interface in TypeScript

My app is having trouble updating routes correctly. Can anyone provide guidance on how to configure routeConfig properly for my application?

Declaring a function type with a void parameter type in typescript

Every time I try to request something on my localhost, NextJS console throws a TypeError, saying it cannot read the properties of undefined, specifically '_owner'

Creating a RESTful API with Express, Firestore, Cloud Functions, and TypeScript

Create a new visual masterpiece using Canvas by repurposing an

How is it possible for this for loop to function properly without the need to pass the incrementing variable

Angular 6: TypeError - The function you are trying to use is not recognized as a valid function, even though it should be

Removing a targeted element from an array in Angular

Issue arises when isomorphic-dompurify is used alongside dompurify in Next.js 13 causing compatibility problems

The React-widgets DateTimePicker is malfunctioning and displaying an error stating that it cannot assign to the type of 'Readonly<DateTimePickerProps>'

Dealing with errors when implementing an Angular 2 route guard that returns an Observable of type boolean can be a

Unable to locate module within a subdirectory in typescript

"Encountered a problem when trying to access properties within a

What is causing the duplication of leaves when using this DFS implementation?

What is the reason why the swiper feature is malfunctioning in my React-Vite-TS application?

Switching Theme Dynamically in a Multi-tenant Next.js + Tailwind App