Allow circular constraints

Suggestion

🔍 Search Terms

Circular constraints, “Type parameter ‘T’ has a circular constraint.(2313)”

✅ Viability Checklist

My suggestion meets these guidelines:

• This wouldn’t be a breaking change in existing TypeScript/JavaScript code
• This wouldn’t change the runtime behavior of existing JavaScript code
• This could be implemented without emitting different JS based on the types of the expressions
• This isn’t a runtime feature (e.g. library functionality, non-ECMAScript syntax with JavaScript output, new syntax sugar for JS, etc.)
• This feature would agree with the rest of TypeScript’s Design Goals.

⭐ Suggestion

Often constraints are truly circular, that is to say we want type-checking an parameter based on itself, for instance consider this…

declare const placeOrder: <T extends Order<T>>(order: T) => void

type Order<Self> =
  { ids: number[]
  , urgent: Self["ids" & keyof Self]
  }

declare const orderA: 1
declare const orderB: 2
declare const orderC: 3

placeOrder({ ids: [orderA, orderB], urgent: [orderA] })
// okay, good

placeOrder({ ids: [orderA, orderB], urgent: [orderC] })
// nope, `orderC` can't be marked as urgent as it's not being placed

Here the circular constraint T extends Order<T> compiles because it’s not immediately circular, but in case of immediately circular the compiler complaints and doesn’t allow compiling it…

type Basket = { bananas: number, apple: number }
declare const updateBasket: <T extends ShallowExact<T, Partial<Basket>>(basket: T) => void
//                                     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Type parameter 'T' has a circular constraint.(2313)

updateBasket(({ banana: basket.bananas + 1, apple: 10 }))
// no error

type ShallowExact<T, U> =
  T extends U
    ? U extends unknown
        ? { [K in keyof T]: K extends keyof U ? T[K] : never }
        : never
    : U

As a workaround we could make the circular constraint non-immediate by using a variadic argument…

type Basket = { bananas: number, apple: number }
declare const updateBasket: <T extends [ShallowExact<T[0], Partial<Basket>]>(...basket: T) => void

updateBasket(({ banana: basket.bananas + 1, apple: 10 }))
// Type 'number' is not assignable to type 'never'

type ShallowExact<T, U> =
  T extends U
    ? U extends unknown
        ? { [K in keyof T]: K extends keyof U ? T[K] : never }
        : never
    : U

But this makes the type unnecessarily complicated, in some scenarios even more complicated…

type Basket = { bananas: number, apple: number }
declare const updateBasket:
  <F extends [(state: Basket) => ShallowExact<ReturnType<F[0]>, Partial<Basket>>]>(...f: F) => void

updateBasket(basket => ({ banana: basket.bananas + 1, apple: 10 }))
// Type 'number' is not assignable to type 'never'

type ShallowExact<T, U> =
  T extends U
    ? U extends unknown
        ? { [K in keyof T]: K extends keyof U ? T[K] : never }
        : never
    : U

This could have simply been the following if TS allowed circular constraints…

type Basket = { bananas: number, apple: number }
declare const updateBasket:
  <T extends ShallowExact<T, Partial<Basket>>(f: (state: Basket) => T) => void

updateBasket(basket => ({ banana: basket.bananas + 1, apple: 10 }))
// no error

type ShallowExact<T, U> =
  T extends U
    ? U extends unknown
        ? { [K in keyof T]: K extends keyof U ? T[K] : never }
        : never
    : U

So the feature request is to allow writing circular constraints.

[nopeless]

Thanks but the code that you’re trying to fix (the first in OP) already works perfectly fine (and is better than your version): https://tsplay.dev/m3X2bW

I just showed this as an example of a (non-immediate) circular constraint TS is fine with.

Smart, I must have skimmed too hard. Thanks for the example

[devanshj]

simpler than trying to constrain against a derivative of the inferred type variable.

Well, it’s not, here again what you’re doing is what I’d call a “workaround” to not have a circular constraint. What I would call simple is embracing the fact that the type of order depends upon it’s value and hence there is a circular constraint by definition independent of code.

I can increase the requirement even more, how would one refactor this… (I’m increasing the requirement slowly to keep it as minimal as possible.)

declare const placeOrder: <T extends [Order<T[0]>]>(...order: T) => T[0]

type Order<Self> =
  Self extends number[] ? number[] :
  { ids: number[]
  , urgent?: Self["ids" & keyof Self]
  , onChange?:
      Exclude<keyof Self, "ids" | "urgent" | "onChange"> extends infer MetaKey extends keyof any
        ? & { [K in MetaKey]?: () => void }
          & { [K in Exclude<keyof Self["onChange" & keyof Self], MetaKey>]?: never }   
        : never
  }

declare const orderA: 1
declare const orderB: 2
declare const orderC: 3

placeOrder({
  ids: [orderA, orderB],
  extraMeta: "hello",
  onChange: {
    extraMeta: () => {},
    // @ts-expect-error
    bogusProp: () => {}
  }
})


placeOrder({ ids: [orderA, orderB], urgent: [
  // @ts-expect-error
  orderC
] })

Again I’m just trying to prove this claim of mine…

in some cases you can cleverly write types to not have a circular constraint, but that’s not always possible