Ways to filter down categories by utilizing a specific attribute

Question

Ways to filter down categories by utilizing a specific attribute

How can we define the function getInterface in a way that the returned type by res is specifically number?

Just to be clear: I am not attempting to write these functions myself; rather, I have an environment where a method exists that returns different objects based on parameters.type, and I'm seeking a solution to properly type them.

interface A {
  tag: 'a'
  do_one: () => number;
}
interface B {
  tag: 'b'
  do_one: () => string;
}
type Interface = A | B
let one = getInterface({ type: 'a' })
let res = one.do_one()

typescript

Answer 1

Answer №1

It seems like your question may need some clarification, but from what I understand, you want the getInterface function to take a type and return the corresponding value based on that type.

This can be achieved using either overloads or conditional types:

Example using overloads:

type Interface = A | B

function getInterface(v: { type: 'a' }): A
function getInterface(v: { type: 'b'}): B 
function getInterface(v: { type: 'b'} | { type: 'a'}): A | B {
    return null!
}
let one = getInterface({ type: 'a' })
let res = one.do_one()

Example using conditional types:

interface A {
    tag: 'a'
    do_one: () => number;
}
interface B {
    tag: 'b'
    do_one: () => string;
}
type Interface = A | B

type GetJustTypes = Interface extends infer I ? I extends { tag: infer U } ? { tag: U } : never : never
function getInterface<T extends GetJustTypes>(v: T): Extract<Interface, T>
function getInterface(v: { tag: 'b' } | { tag: 'a' }): A | B {
    return null!
}
let one = getInterface({ tag: 'a' })
let res = one.do_one()

Answer 2

It seems like your question may need some clarification, but from what I understand, you want the getInterface function to take a type and return the corresponding value based on that type.

This can be achieved using either overloads or conditional types:

Example using overloads:

type Interface = A | B

function getInterface(v: { type: 'a' }): A
function getInterface(v: { type: 'b'}): B 
function getInterface(v: { type: 'b'} | { type: 'a'}): A | B {
    return null!
}
let one = getInterface({ type: 'a' })
let res = one.do_one()

Example using conditional types:

interface A {
    tag: 'a'
    do_one: () => number;
}
interface B {
    tag: 'b'
    do_one: () => string;
}
type Interface = A | B

type GetJustTypes = Interface extends infer I ? I extends { tag: infer U } ? { tag: U } : never : never
function getInterface<T extends GetJustTypes>(v: T): Extract<Interface, T>
function getInterface(v: { tag: 'b' } | { tag: 'a' }): A | B {
    return null!
}
let one = getInterface({ tag: 'a' })
let res = one.do_one()

Answer 3

Answer №2

function fetchInterfaceOfTypeA(arg: { type: 'a' }): A;
function retrieveInterfaceOfTypeB(arg: { type: 'b' }): B;

const instanceOne = fetchInterfaceOfTypeA({ type: 'a'} )
const result = instanceOne.performAction()  // The result is a number

Answer 4

function fetchInterfaceOfTypeA(arg: { type: 'a' }): A;
function retrieveInterfaceOfTypeB(arg: { type: 'b' }): B;

const instanceOne = fetchInterfaceOfTypeA({ type: 'a'} )
const result = instanceOne.performAction()  // The result is a number

Answer 5

Answer №3

Thanks a lot for your assistance! I realize my initial question was quite messy, I should have provided more clarity from the start.

Nevertheless, I was able to successfully determine the correct code snippet -

type FilterTag<T, U> = T extends { tag: U } ? T : never
type Interface<T> = FilterTag<A | B, T>
declare function getInterface<T extends string>(params: { type: T }): Interface<T>

resulting in getInterface({ type 'X' }) always delivering the appropriate interface, with only one union type requiring adjustment when necessary

Answer 6

Thanks a lot for your assistance! I realize my initial question was quite messy, I should have provided more clarity from the start.

Nevertheless, I was able to successfully determine the correct code snippet -

type FilterTag<T, U> = T extends { tag: U } ? T : never
type Interface<T> = FilterTag<A | B, T>
declare function getInterface<T extends string>(params: { type: T }): Interface<T>

resulting in getInterface({ type 'X' }) always delivering the appropriate interface, with only one union type requiring adjustment when necessary

Answer 7

Answer №4

The issue must be addressed using the do_one() function primarily

getInterface(<someparam>):number{
   do_one():number{
      return 4;
   }
}
let result:number = one.do_one();

Answer 8

The issue must be addressed using the do_one() function primarily

getInterface(<someparam>):number{
   do_one():number{
      return 4;
   }
}
let result:number = one.do_one();

Answer 9

Answer №5

It is vital to have a clear understanding of typings, as they serve the purpose of preventing errors during compilation. Once compiled, the final outcome will always be pure javascript.

In response to your inquiry, typing can only be inserted using either the or | condition, which is verified solely during compilation.

The concept of dynamic typing remains an unsolved mystery.

However, there is a technique known as instance-of that can be utilized.

Answer 10

It is vital to have a clear understanding of typings, as they serve the purpose of preventing errors during compilation. Once compiled, the final outcome will always be pure javascript.

In response to your inquiry, typing can only be inserted using either the or | condition, which is verified solely during compilation.

The concept of dynamic typing remains an unsolved mystery.

However, there is a technique known as instance-of that can be utilized.

Ways to filter down categories by utilizing a specific attribute

Answer №1

Answer №2

Answer №3

Answer №4

Answer №5

Similar questions

Comparison of env.local and String variables

Creating spec.ts files for components by hand: A guide

Transforming an ordinary JavaScript object into a class instance

Angular EventEmitter coupled with Callbacks

What is the best way to define a general class within the constructor of another class in TypeScript?

Prisma - Modify a single resource with additional criteria

Using Typescript and ThreeJS, include new elements to the environment within the loader

Exploring/Adjusting an RxJS Observable Object

Creating JPEG images with specified dimensions. How can you add W x H sizing to an image?

Encountering difficulty in retrieving the outcome of the initial HTTP request while utilizing the switchMap function in RxJS

Typescript fails to recognize a value assigned within an await statement

How to access the dynamic route's path in Next.js when using Server Components?

Using brackets around or after an expression in Typescript

Tips for configuring VS Code to display and check object schemas

Steps for sending a POST request for every file in the given array

Struggling to fix TypeScript error related to Redux createSlice function

Can someone guide me on incorporating static methods into a Mongoose model using TypeScript for Mongoose version 5.11?

Retrieve all the characteristics accessible of a particular course

An error occurs when attempting to use object mapping and the rest operator in a return statement due to

Guide to setting up react-styleguidist, developing with Create React App, using Typescript, incorporating Material UI, and including