Add Num.Range to @rimbu/typical

[alecmev]

Thank you for creating this!

I was going to use union subtraction, but it goes only up to 999, and I needed to include a few numbers above that, and Num.Add turned out to be perfect for that:

import type { Num } from '@rimbu/typical';

type Range<
  F extends number,
  T extends number,
  A extends number[] = [],
> = F extends T ? A[number] | F : Range<Num.Add<F, 1>, T, [...A, F]>;

let x: Range<1, 10> = 1;
x = 0; // Error
x = 11; // Error

Edit:

I ended up using this, as to avoid having a dep (and I haven't checked, but it might have better performance too):

type IncrementMap = {
  0: 1;
  1: 2;
  2: 3;
  // ...
  1233: 1234;
  1234: 1234; // To make all values also Incrementable
};

type Incrementable = keyof IncrementMap;
type Increment<N extends Incrementable> = IncrementMap[N];

type Range<
  F extends Incrementable,
  T extends Incrementable,
  A extends number[] = [],
> = F extends T ? A[number] | F : Range<Increment<F>, T, [...A, F]>;

The list of numbers can be generated here.

But the original snippet still fits into this library, I think.

[vitoke]

Hey, thanks for sharing these ideas. I can see the convenience of having this Range type to easily state the desired type. However, in essence you are creating a union type with all the numbers in that range. Without built-in calculations, this will always need to be done recursively (incrementing by one) which is inherently sub-optimal.

If the use-case is to validate inputs to a function, then the current types offer a much more performant way to specify this, like so:

import { Num, U } from "@rimbu/typical";

function f<N extends number>(value: N & U.Check<Num.InRange<N, 0, 10>>) {}
f(5); // <- no problem
f(14); // <- compiler error

I get that this is quite a bit more complex than the Range type, but on the upside, it is much more performant and easy for the compiler to check. Interested to hear your thoughts..

[alecmev]

Hi! Thank you for trying to help.

I'm using this for union discrimination, actually. They look something like this, and there are hundreds of codes:

type Foo = 
  | { code: 123, value: string }
  | { code: 456, value: number }
  | { code: 789, value: boolean }

Then I process Foo[] arrays, and do different things based on what code I encounter, and it's very convenient when TypeScript narrows down the type of value automatically inside switch cases.