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

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

From

From

To

To

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

ReturnType

ReturnType

, which uses

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
}

Then you can redefine

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']

And do a similar thing to

Class

Class

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

Effect Community•3y ago•

10 replies

spaethnl

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

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

From

From

To

To

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

ReturnType

ReturnType

, which uses

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
}

Then you can redefine

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']

And do a similar thing to

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

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

Similar Threads

Similar Threads

Similar Threads