Is there a way to define a return type conditionally depending on an input parameter in typing?

Question

Is there a way to define a return type conditionally depending on an input parameter in typing?

I need help ensuring that a function in TypeScript returns a specific type based on a parameter. How can I make TypeScript understand my intention in this scenario?

type X = 'x'
type Y = 'y'

const customFunc = <Type extends X | Y>(input: Type): Type extends X ? 'result_x': 'result_y' => {
    if (input === 'x') return 'result_x'
    
    return 'result_y'
}

// The output type here will be 'result_x'
const outputX = customFunc('x')
// The output type here will be 'result_y'
const outputY = customFunc('y')

Playground Link

typescript

Answer 1

Answer №1

Utilizing Function Overloads is typically recommended for handling such situations, but it is also feasible to engage a custom type map that encompasses all potential return types based on the Union Type parameter.

type X = 'x';
type Y = 'y';

type OutputMap = {
  [M in X]: 'x1';
} & {
  [N in Y]: 'y1';
};

function customFunction<U extends X | Y>(input: U): OutputMap[U] {
  const outputMap: OutputMap = {
    x: 'x1',
    y: 'y1',
  };

  if (input in outputMap) {
    return outputMap[input];
  }

  throw new Error('Invalid input');
}

const x1 = customFunction('x'); // 'x1'
const y1 = customFunction('y'); // 'y1'

TypeScript Playground

Answer 2

Utilizing Function Overloads is typically recommended for handling such situations, but it is also feasible to engage a custom type map that encompasses all potential return types based on the Union Type parameter.

type X = 'x';
type Y = 'y';

type OutputMap = {
  [M in X]: 'x1';
} & {
  [N in Y]: 'y1';
};

function customFunction<U extends X | Y>(input: U): OutputMap[U] {
  const outputMap: OutputMap = {
    x: 'x1',
    y: 'y1',
  };

  if (input in outputMap) {
    return outputMap[input];
  }

  throw new Error('Invalid input');
}

const x1 = customFunction('x'); // 'x1'
const y1 = customFunction('y'); // 'y1'

TypeScript Playground

Is there a way to define a return type conditionally depending on an input parameter in typing?

Answer №1

Similar questions

Accessing the ViewModel property of a parent component from the ViewModel of its child in Aurelia

Error in Next.js when trying to use Firebase Cloud Messaging: ReferenceError - navigator is not defined in the Component.WindowMessagingFactory instanceFactory

Angular 2.0 encountered an unexpected value from the module 'AppModule' which appears to be an '[object Object]'

Prisma auto-generating types that were not declared in my code

Difficulty encountered when attempting to invoke a public function that makes use of a private function in TypeScript

The initial processing step for the export namespace is to utilize the `@babel/plugin-proposal-export-namespace-from` plugin. Previous attempts to resolve this issue have been

Tips for retrieving both the ID and NAME values from Ionic's Dynamic Select Options

What causes TypeScript to automatically infer a default property when dynamically importing a JavaScript file that lacks a default export?

Is it possible to set the initial value of useState() as null and later assign it an object value?

What causes Next.js to struggle with recognizing TypeScript code in .tsx and .ts files?

Encountering a Typescript error while attempting to utilize mongoose functions

Discovering the World of React with Typescript: Implementing Flexible Routes with BrowserRouter

TypeScript is unable to recognize files with the extension *.vue

Unable to retrieve information from a Node.js server using Angular 2

Is it possible for an uninitialized field of a non-null literal string type to remain undefined even with strict null checks in

You must provide a secret or key in order to use the JwtStrategy

The task of mapping an array of objects with nested values using JavaScript is proving to

Obtain precise measurements of a modified image using the Sharp library

Issues with implementing PrimeNG Data List component in Angular 4

Searching for particular information within an array of objects