10 replies

Typescript's Limitations on Circular Use of `infer` in Schema

While debugging some issues I've been having with circular types, I discovered that the problem is largely related to typescript's limits regarding circular use of

infer

infer

infer

infer. Schema really only uses infer in a couple of places:

From

From

From

From,

To

To

To

To are the biggest culprits because they infer the types from functions using

ReturnType

ReturnType

ReturnType

ReturnType, which uses

infer

infer

infer

infer under the hood. I found that if I patch Schema to:

export interface Schema<From, To = From> extends Pipeable {
  readonly toType: To
  readonly fromType: From
  //.... rest of current properties
}

export interface Schema<From, To = From> extends Pipeable {
  readonly toType: To
  readonly fromType: From
  //.... rest of current properties
}

export interface Schema<From, To = From> extends Pipeable {
  readonly toType: To
  readonly fromType: From
  //.... rest of current properties
}

export interface Schema<From, To = From> extends Pipeable {
  readonly toType: To
  readonly fromType: From
  //.... rest of current properties
}

Then you can redefine

To/From

To/From

To/From

To/From to:

export type From<S extends Schema<any,any>> = S['fromType']
export type To<S extends Schema<any,any>> = S['toType']

export type From<S extends Schema<any,any>> = S['fromType']
export type To<S extends Schema<any,any>> = S['toType']

export type From<S extends Schema<any,any>> = S['fromType']
export type To<S extends Schema<any,any>> = S['toType']

export type From<S extends Schema<any,any>> = S['fromType']
export type To<S extends Schema<any,any>> = S['toType']

And do a similar thing to

Class

Class

Class

Class, then suddenly my recursive types work as expected.
Is there any reason not to do this?

Typescript's Limitations on Circular Use of `infer` in Schema

Similar Threads

Similar Threads

Similar Threads