Triangular number

In this medium-level challenge, you'll implement a Triangular type that computes the Nth triangular number (the sum 1 + 2 + 3 + ... + N) entirely at the type level using tuple length arithmetic.

type cases = [
  Expect<Equal<Triangular<0>, 0>>,
  Expect<Equal<Triangular<1>, 1>>,
  Expect<Equal<Triangular<3>, 6>>,
  Expect<Equal<Triangular<10>, 55>>,
  Expect<Equal<Triangular<20>, 210>>,
  Expect<Equal<Triangular<55>, 1540>>,
  Expect<Equal<Triangular<100>, 5050>>,
]

Detailed Explanation

type Triangular<
  N extends number,
  Counter extends any[] = [],
  Acc extends any[] = []
> = Counter['length'] extends N
  ? Acc['length']
  : Triangular<N, [...Counter, 0], [...Acc, ...Counter, 0]>;

How it works:

• The type uses two accumulator tuples: Counter tracks the current step (from 0 up to N), and Acc accumulates the total sum as a tuple whose length represents the result
• At each recursive step, Counter grows by one element (incrementing the step), and Acc grows by the current step's value plus one, achieved by spreading [...Acc, ...Counter, 0] -- this adds Counter['length'] + 1 elements to Acc
• When Counter['length'] equals N, the recursion stops and returns Acc['length'] as the computed triangular number
• For example, with N=3: step 0 adds 1 element (total 1), step 1 adds 2 elements (total 3), step 2 adds 3 elements (total 6), giving the 3rd triangular number

This challenge helps you understand type-level arithmetic through tuple length manipulation and how to apply recursive accumulation patterns in real-world scenarios.