How does typescript implement a Range that supports larger numbers？

Question

Sometimes I may need to limit the value range of a variable, and I expect to get the following types.

type Range<start, end, step extends number = 1> = ?

type a1 = Range<1000, 2000>; // 1000 | 1001 | 1002 | ... | 2000
type a2 = Range<1000, 2000, 2>; // 1000 | 1002 | ... | 2000

The above code allows me to have a Range of values between 1000 and 2000, although the values I want may be larger, such as 5000 and above. So Far I've only written a Range of 1000, i have no idea how to implement a Range that supports large numbers.

——————————————————————————————————————————

I accepted the help of netizens, and now I have written the Range function I want, you can check this link：link

The range supports up to tens of thousands of numbers, but too large a range of numbers may have performance problems, I think if the range of more than ten thousand to do further optimization can have better performance, but I have not yet supported.

Answer 1

Since the limit of the tail recursion is 1000 there is no straight way to achieve this, however, the possible improvement would be to add not just one element per iteration but more. If we add two per iteration we can reach up to 2000 elements. This way it can be scaled even more, however, it's going to cause a really hard time for the compiler.

I will use some utility types from type-samurai package:

IsGreaterThan - Returns a boolean whether the first passed integer is greater than the second integer. Range: [Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER].

Sum - Accepts two integers and returns their sum. Range: [Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER]

The strategy: The type accepts three parameters:

• From - range start
• To - range end
• Result - an array of added numbers, defaults to [].

We going to check whether from is already greater than To in that case, using the indexed access we are going to get a union of all elements and store them in the new generic parameter by using infer keyword.

Then, by using distribution we are going to compare every member of the union with the To and remove them if they are greater than it.

If From is lower than To, we are going to add 5 to From and add From + 1,... From + 4 to the Result and call the Range recursively:

import { IsGreaterThan, Sum } from 'type-samurai';

type Range<
  From extends number,
  To extends number,
  Result extends number[] = [From],
> = IsGreaterThan<From, To> extends true
  ? [...Result, To][number] extends infer R extends number
    ? R extends R
      ? IsGreaterThan<R, To> extends true
        ? never
        : R
      : never
    : never
  : Range<
      Sum<From, 5>,
      To,
      [...Result, From, Sum<From, 1>, Sum<From, 2>, Sum<From, 3>, Sum<From, 4>]
    >;

Testing:

type A = Range<0, 4000>;

const a: A = 3999; // no error
const b: A = 4003; // error

playground