How to dynamically infer type in Typescript?

Question

How can I make the compiler understand that the return type of the parse method is linked to the input of the serialize method and it is dynamic?

type QUESTION = {
  parse: (value: string) => any
  serialize: (value: ReturnType<QUESTION['parse']>) => string
}

const idsQuestions: QUESTION[] = [
  {
    parse: (input) => input.split('\n'),
    serialize: (ids) => ids.join('\n') // expect ids to be interpreted as string[]
  },
  {
    parse: (input) => input.split('\n').reduce((acc, id) => ({
      ...acc,
      [id]: true,
    }), {}),
    serialize: (ids) => Object.keys(ids).join('\n') // expect ids to be interpreted as { [string] => boolean }
  }
]

// expect this to throw an error on build
const questionWithError: QUESTION = {
  parse: () => false, // return type is boolean
  serialize: (ids) => ids.join('\n') // but ids is not interpreted as boolean, so compiler doens't give an error
}

I've tried some uses of generics and unknown, but could not make it work. Tried to use infer also, but could not understand exactly how to work with it

I could have something hardcoded like this, but I wanted it to be dynamic

type QUESTION<T> = {
  parse: (value: string) => T
  serialize: (value: T) => string
}

const idsQuestions: [
  QUESTION<string[]>,
  QUESTION<{ [k: string]: boolean }>,
] = [
  {
    parse: (input) => input.split('\n'),
    serialize: (ids) => ids.join('\n') // expect ids to be interpreted as string[]
  },
  {
    parse: (input) => input.split('\n').reduce((acc, id) => ({
      ...acc,
      [id]: true,
    }), {}),
    serialize: (ids) => Object.keys(ids).join('\n') // expect ids to be interpreted as { [string] => boolean }
  }
]

Playground link

Couldn't you just make QUESTION<T> and then use T as parameter and T[] as return type for parse, and upside down for serialize? — Icepickle
– Icepickle, Commented Jul 1, 2022 at 14:32
Yes, this solves the problem. Edited my question to be closer to my use case — Matheus Vellone
– Matheus Vellone, Commented Jul 1, 2022 at 14:41
expect ids to be interpreted as { [string] => boolean } what do you mean it's not supposed to throw an error. — Yedidya Rashi
– Yedidya Rashi, Commented Jul 1, 2022 at 14:49
yeah this one is correct, but the () => false right below have an error — Matheus Vellone
– Matheus Vellone, Commented Jul 1, 2022 at 14:51

Jeff Mercado · Accepted Answer · 2022-07-01 17:33:26Z

1

I don't think what you're trying to achieve is doable without some helper functions or making it excessively verbose. Make a function that could help determine what T should be.

type QUESTION<T> = {
  parse: (value: string) => T
  serialize: (value: T) => string
}

function QUESTION<T>(parse: (value: string) => T, serialize: (value: T) => string): QUESTION<T> {
  return { parse, serialize };
}

const idsQuestions = [
  QUESTION(
    (input) => input.split('\n'),
    (ids) => ids.join('\n') // expect ids to be interpreted as string[]
  ),
  QUESTION(
    (input) => input.split('\n').reduce((acc, id) => ({
      ...acc,
      [id]: true,
    }), {} as Record<string, boolean>),
    (ids) => Object.keys(ids).join('\n') // expect ids to be interpreted as { [string] => boolean }
  )
] as const;

answered Jul 1, 2022 at 17:33

Jeff Mercado

136k34 gold badges268 silver badges282 bronze badges

Sign up to request clarification or add additional context in comments.

1 Comment

Ted A. Over a year ago

This is the way to do it.

Yedidya Rashi · Accepted Answer · 2022-07-01 14:32:52Z

0

You need to use genric-type.

With this feature, you can tie between Types dynamically

interface Question<T>  {
  parse: (value: string) => T
  serialize: (value: T) => string
}

const idsQuestion: Question<string[]> = {
  parse: (input) => input.split('\n'),
  serialize: (ids) => ids.join('\n') // expect ids to be interpreted as string[]
}

// expect this to throw an error on build
const questionWithError: Question<boolean> = {
  parse: () => false, // return type is boolean
  serialize: (ids) => ids.join('\n') // the transpiler will show an error
}

answered Jul 1, 2022 at 14:32

Yedidya Rashi

1,0929 silver badges22 bronze badges

3 Comments

Matheus Vellone Over a year ago

The real use case is a bit more complex than the example, so using generics this way solves this problem, but don't solve the case I have.

Yedidya Rashi Over a year ago

so ask your complex one

Matheus Vellone Over a year ago

question edited

Collectives™ on Stack Overflow

How to dynamically infer type in Typescript?

2 Answers 2

1 Comment

3 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

1 Comment

3 Comments

Your Answer

Sign up or log in

Post as a guest

Related