Type instantiation is excessively deep with tuple spread

Bug Report

🔎 Search Terms

• 2889 spread

🕗 Version & Regression Information

• This is the behavior in every version I tried (4.1.5 to 5.2.0 nightly), and I reviewed the FAQ for entries about: recursion

⏯ Playground Link

Playground link with relevant code

💻 Code

type NTuple<T, N extends number, Acc extends T[] = []> =
  N extends Acc['length']
  ? Acc
  : NTuple<T, N, [...Acc, T]>

type Pair = NTuple<number, 2>;
//   ^? type Pair = [number, number]

type SpreadN<A extends number> = [...NTuple<any, A>]
//                               ~~~~~~~~~~~~~~~~~~~
// Type instantiation is excessively deep and possibly infinite. (2589)

🙁 Actual behavior

I'm getting the "Type instantiation is excessively deep and possibly infinite. (2589)" error on what should be the identity.

🙂 Expected behavior

I'd expect this to just work. SpreadN should produce the same results as NTuple. It's surprising to me that this error is produced on the definition of SpreadN, rather than when it's instantiated with an overly large value of N.

I think this may have something to do with distribution over unions because when I reverse the conditional, the code works fine:

type NTuple2<T, N extends number, Acc extends T[] = []> =
  Acc['length'] extends N  // note that the check is reversed
  ? Acc
  : NTuple2<T, N, [...Acc, T]>

type SpreadN2<A extends number> = [...NTuple<any, A>]  // ok
type Pair2 = SpreadN2<2>;
//   ^? type Pair2 = [any, any]

It's not clear to me why reversing that conditional would matter, but it does have the effect of preventing distribution over unions, which is not desirable:

type T1 = NTuple<string, 2 | 3>;
//   ^? type T1 = [string, string] | [string, string, string]
type T2 = NTuple2<string, 2 | 3>;
//   ^? type T2 = [string, string]

Inizia riproducendo l'esempio di spread di tuple nel TypeScript Playground collegato e confronta NTuple con NTuple2, incluso il loro comportamento sulle unioni. Il lavoro è completato quando SpreadN non segnala più l'errore 2589 nella sua definizione, mentre NTuple mantiene i risultati attesi delle unioni distribuite.