Number Range

In this medium-level challenge, you'll implement NumberRange<L, H>, a type that produces a union of all integer literal types from L to H inclusive.

type result = NumberRange<2 , 9> //  | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9

Detailed Explanation

type NumberRange<
  L extends number,
  H extends number,
  Arr extends any[] = [],
  Result extends number = never
> = Arr['length'] extends H
  ? Result | H
  : Arr['length'] extends L
    ? NumberRange<L, H, [...Arr, any], Result | Arr['length']>
    : Result extends never
      ? NumberRange<L, H, [...Arr, any], Result>
      : NumberRange<L, H, [...Arr, any], Result | Arr['length']>;

How it works:

• The type uses a growing tuple Arr as a counter, where Arr['length'] represents the current number being evaluated
• It also carries a Result accumulator that collects the union of all numbers in range
• When Arr['length'] equals H (the upper bound), it returns Result | H to include the upper bound and stop recursion
• When Arr['length'] equals L (the lower bound), it begins accumulating by adding Arr['length'] to Result and continuing
• The check Result extends never determines whether accumulation has started: if Result is still never, the current number is below L and should be skipped; otherwise, the current number is within range and gets added
• The tuple grows by one element each step ([...Arr, any]), effectively incrementing the counter until H is reached

An alternative cleaner approach:

type MakeTuple<N extends number, T extends any[] = []> =
  T['length'] extends N ? T : MakeTuple<N, [...T, any]>;
 
type NumberRange<L extends number, H extends number, T extends any[] = MakeTuple<L>> =
  T['length'] extends H
    ? H | L
    : T['length'] extends L
      ? NumberRange<L, H, [...T, any]> | T['length']
      : NumberRange<L, H, [...T, any]> | T['length'];

This challenge helps you understand tuple-based type-level counting and union accumulation, and how to apply these concepts in real-world scenarios.