Deduce the output data type of a function by having knowledge of a single property

Question

Deduce the output data type of a function by having knowledge of a single property

Is there a way to achieve this without using if/else or switch statements by utilizing function return values?

interface test1 {
    type: 'test1'
}

interface test2 {
    type: 'test2'
}

type unType = test1 | test2;

//I am aware of the property "type"'s value
//Can I use this information to determine the specific type (test1 or test2) in a function's return value?
function whichType<T>(typeValue): T {

    return null;
}

const tt1 = whichType<unType>('test1');// expected output: interface test1
const tt2 = whichType<unType>('test2');// expected output: interface test2

typescript typescript-generics

Answer 1

Answer №1

To implement overloads as suggested by TJ Crowder is an effective approach, especially when dealing with a limited number of interfaces. It is straightforward to write and understand.

For a more versatile solution, one can utilize the Extract conditional type to retrieve the type based on the provided string:

interface test1 { type: 'test1' }

interface test2 { type: 'test2' }

type unType = test1 | test2;

function whichType<K extends unType['type']>(typeValue: K): Extract<unType, {type: K}> {
    return null!;
}

const tt1 = whichType('test1'); // test1
const tt2 = whichType('test2'); // test2

Creating a solution that works for any union involves using function currying due to TypeScript's lack of support for partial type parameter inference:

function whichType<T extends { type: string}>() {
    return function <K extends T['type']>(typeValue: K): Extract<T, {type: K}> {
        return null!;
    }
}

const tt1 = whichType<unType>()('test1'); // test1
const tt2 = whichType<unType>()('test2'); // test2

Answer 2

To implement overloads as suggested by TJ Crowder is an effective approach, especially when dealing with a limited number of interfaces. It is straightforward to write and understand.

For a more versatile solution, one can utilize the Extract conditional type to retrieve the type based on the provided string:

interface test1 { type: 'test1' }

interface test2 { type: 'test2' }

type unType = test1 | test2;

function whichType<K extends unType['type']>(typeValue: K): Extract<unType, {type: K}> {
    return null!;
}

const tt1 = whichType('test1'); // test1
const tt2 = whichType('test2'); // test2

Creating a solution that works for any union involves using function currying due to TypeScript's lack of support for partial type parameter inference:

function whichType<T extends { type: string}>() {
    return function <K extends T['type']>(typeValue: K): Extract<T, {type: K}> {
        return null!;
    }
}

const tt1 = whichType<unType>()('test1'); // test1
const tt2 = whichType<unType>()('test2'); // test2

Answer 3

Answer №2

If you want to approach it from a type perspective and use literals when calling whichType, you can achieve this by utilizing function overloading:

interface test1 {
    type: 'test1'
}

interface test2 {
    type: 'test2'
}

type unType = test1 | test2;

function whichType(typeValue: 'test1'): test1;
function whichType(typeValue: 'test2'): test2;
function whichType(typeValue: string): unType {
    switch (typeValue) {
        case 'test1':
            return <test1>null;
        case 'test2':
            return <test2>null;
        default:
            throw new Error(`Unknown type ${typeValue}`);
    }
}

const tt1 = whichType('test1'); // tt1's type is test1
const tt2 = whichType('test2'); // tt2's type is test2

Check it out on the playground

As indicated in the code comment, you will still require runtime logic to handle it during execution.

If you wish to allow non-literal strings in calls to whichType, you would have to include another overload:

function whichType(typeValue: string): unType;

...and then address the challenge of working with an unknown type. :-|

[On the playground][2]

[2]: function whichType(typeValue: string): unType;

Answer 4

If you want to approach it from a type perspective and use literals when calling whichType, you can achieve this by utilizing function overloading:

interface test1 {
    type: 'test1'
}

interface test2 {
    type: 'test2'
}

type unType = test1 | test2;

function whichType(typeValue: 'test1'): test1;
function whichType(typeValue: 'test2'): test2;
function whichType(typeValue: string): unType {
    switch (typeValue) {
        case 'test1':
            return <test1>null;
        case 'test2':
            return <test2>null;
        default:
            throw new Error(`Unknown type ${typeValue}`);
    }
}

const tt1 = whichType('test1'); // tt1's type is test1
const tt2 = whichType('test2'); // tt2's type is test2

Check it out on the playground

As indicated in the code comment, you will still require runtime logic to handle it during execution.

If you wish to allow non-literal strings in calls to whichType, you would have to include another overload:

function whichType(typeValue: string): unType;

...and then address the challenge of working with an unknown type. :-|

[On the playground][2]

[2]: function whichType(typeValue: string): unType;

Deduce the output data type of a function by having knowledge of a single property

Answer №1

Answer №2

Similar questions

Create a dynamic function that adds a new property to every object in an array, generating unique values for

What is the process to verify a password?

Guide on transferring the Token from the initial response request to the header of the second request, with the help of Axios in an Ionic React application (Making 2 Post Requests

Occasionally the CUSTOM_ELEMENTS_SCHEMA error may appear intermittently

Use the mat-autocomplete filter to emphasize partial string matches in the search results

Why does VSCode open a React app in Edge instead of Chrome?

Establish a connection between a React variable and state management

Using Iframe for WooCommerce integration and implementing Facebook login within an Ionic application

The request to search for "aq" on localhost at port 8100 using Ionic 2 resulted in a 404 error, indicating that the

Different Approaches for Handling User Interactions in Angular Instead of Using the Deferred (Anti-?)Pattern

Exploring Angular 10 Formly: How to Retrieve a Field's Value within a Personalized Formly Wrapper

Employing a one-time use variable that is asynchronously loaded via a React hook

Trouble arises when trying to use add event listener on dynamically generated elements through (*ngFor)

What is the method in Angular 6 that allows Observable to retrieve data from an Array?

The risk of a race condition could arise when working with nested switchMaps in ngr

Testing react-native components using styled-components theme within react-native testing-library

Unable to locate the 'NodeJS' namespace along with node types

Why is it necessary to include the spread operator before an array of objects?

Typescript Array does not adhere to correct data type

Determining the output type by considering the presence of optional parameters