Module
Rimbu is a TypeScript library focused on immutable, performant, and type-safe collections and other tools.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351import type { StrNum, U } from './index.ts';
/** * Returns the sum of given numbers. * @note due to compiler limitations, the maximum result and input numbers is 9999. * @example * ```ts * Add<13, 25> => 38 * Add<1386, 335> => 1721 * ``` */export type Add<N1 extends number, N2 extends number> = StrNum.ToNumber< StrNum.Add<StrNum.FromNumber<N1>, StrNum.FromNumber<N2>>>;
/** * Returns true if the given number is positive (> 0), false otherwise * @example * ```ts * IsPositive<9> => true * IsPositive<0> => false * IsPositive<-5> => false * ``` */export type IsPositive<N extends number> = GreaterThanOrEqual<N, 1>;
/** * Returns true if the given number is a natural number (>= 0), false otherwise * @example * ```ts * IsNatural<9> => true * IsNatural<0> => true * IsNatural<-5> => false * ``` */export type IsNatural<N extends number> = GreaterThanOrEqual<N, 0>;
/** * Returns true if the given number is negative (< 0), false otherwise. * @example * ```ts * IsNegative<9> => false * IsNegative<0> => false * IsNegative<-5> => true * ``` */export type IsNegative<N extends number> = U.Not<IsNatural<N>>;
/** * Returns the result of subtracting N2 from N1. * @note since only natural numbers are supported, a result that would be negative will be type never. * @note due to compiler limitations, the maximum result and input numbers is 9999. * @example * ```ts * Subtract<25, 13> => 12 * Subtract<1721, 335> => 1386 * Subtract<5, 8> => never * ``` */export type Subtract<N1 extends number, N2 extends number> = N1 extends never ? never : N2 extends never ? never : StrNum.ToNumber< StrNum.Subtract<StrNum.FromNumber<N1>, StrNum.FromNumber<N2>> >;
/** * Add 1 to the given natural number. * @example * ```ts * Inc<4> => 5 * Inc<312> => 313 * Inc<-3> => never * ``` */export type Inc<N extends number> = Add<N, 1>;
/** * Decreases a positive number by 1, or if the number is not positive, * returns never. * @example * ```ts * Dec<5> => 4 * Dec<434> => 433 * Dec<0> => never * ``` */export type Decr<N extends number> = Subtract<N, 1>;
/** * Returns true if the given natural number is even, or never otherwise. * @example * ```ts * Even<4> => true * Even<11> => false * Even<-3> => never * ``` */export type IsEven<N extends number> = StrNum.IsEven<StrNum.FromNumber<N>>;
/** * Returns true if the given natural number is odd, or never otherwise. * @example * ```ts * Odd<4> => false * Odd<11> => true * Odd<-3> => never * ``` */export type IsOdd<N extends number> = StrNum.IsOdd<StrNum.FromNumber<N>>;
/** * Returns the smallest of the given 2 natural numbers, of never otherwise * @example * ```ts * Min<2, 5> => 2 * Min<534, 424> => 424 * Min<-4, 4> => never * ``` */export type Min<N1 extends number, N2 extends number> = N1 extends never ? never : N2 extends never ? never : Subtract<N1 & U.Check<N1>, N2 & U.Check<N2>> extends never ? N1 : N2;
/** * Returns the largest of the given 2 natural numbers, of never otherwise * @example * ```ts * Max<2, 5> => 5 * Max<534, 424> => 534 * Max<-4, 4> => never * ``` */export type Max<N1 extends number, N2 extends number> = N1 extends never ? never : N2 extends never ? never : Subtract<N1, N2> extends never ? N2 : N1;
/** * Returns true if the given numbers are equal. * @example * ```ts * Equal<0, 0> => true * Equal<8, 9> => false * ``` */export type Equal<N1 extends number, N2 extends number> = N1 extends N2 ? N2 extends N1 ? true : false : false;
/** * Returns true if the given numbers are not equal. * @example * ```ts * NotEqual<0, 0> => false * NotEqual<8, 9> => true * ``` */export type NotEqual<N1 extends number, N2 extends number> = N1 extends N2 ? N1 extends N2 ? false : true : true;
/** * Returns true if the given first natural number is greater or equal than the second. * Returns never otherwise. * @example * ```ts * GreaterThanOrEqual<15, 12> => true * GreaterThanOrEqual<15, 6> => never * ``` */export type GreaterThanOrEqual<N1 extends number, N2 extends number> = Subtract< N1, N2> extends never ? false : true;
/** * Returns true if the first given number is greater than the second. * @example * ```ts * GreaterThan<5, 5> => false * GreaterThan<8, 5> => true * GreaterThan<3, 7> => false * ``` */export type GreaterThan<N1 extends number, N2 extends number> = N1 extends N2 ? false : GreaterThanOrEqual<N1, N2>;
/** * Returns true if the first given number is less than the second. * @example * ```ts * LessThan<5, 5> => false * LessThan<8, 5> => false * LessThan<3, 7> => true * ``` */export type LessThan<N1 extends number, N2 extends number> = Subtract< N1, N2> extends never ? true : false;
/** * Returns true if the first given number is less than or equal to the second. * @example * ```ts * LessThanOrEqual<5, 5> => true * LessThanOrEqual<8, 5> => false * LessThanOrEqual<3, 7> => true * ``` */export type LessThanOrEqual< N1 extends number, N2 extends number> = N1 extends N2 ? true : LessThan<N1, N2>;
/** * Returns true if the given number is greater than or equal to given L, and less than * or equal to given H, and returns false otherwise. * @example * ```ts * InRange<4, 5, 10> => false * InRange<6, 5, 10> => true * InRange<5, 5, 10> => true * ``` */export type InRange< N extends number, L extends number, H extends number> = GreaterThanOrEqual<N, L> & LessThanOrEqual<N, H> extends never ? false : true;
/** * Returns the result of multiplying the given natural numbers. * @example * ```ts * Mult<0, 0> => 0 * Mult<9, 10> => 90 * Mult<3, 18> => 54 * ``` */export type Mult<N1 extends number, N2 extends number> = N1 extends 0 ? 0 : N2 extends 0 ? 0 : N1 extends 1 ? N2 : N2 extends 1 ? N1 : StrNum.ToNumber<StrNum.Mult<StrNum.FromNumber<N1>, StrNum.FromNumber<N2>>>;
/** * Returns a tuple containing the quotient and remainer of dividing the first number * by the second. * @example * ```ts * DivMod<9, 5> => [1, 4] * DivMod<9, 3> => [3, 0] * ``` */export type DivMod<N1 extends number, N2 extends number> = N2 extends 0 ? never : N1 extends 0 ? [0, 0] : N1 extends N2 ? [1, 0] : StrNum.Divide<StrNum.FromNumber<N1>, StrNum.FromNumber<N2>> extends [ infer Q, infer R ] ? [StrNum.ToNumber<string & Q>, StrNum.ToNumber<string & R>] : never;
/** * Returns the result of dividing the first given natural number by the second. * @example * ```ts * Div<0, 0> => never * Div<9, 3> => 3 * Div<14, 5> => 2 * ``` */export type Div<N1 extends number, N2 extends number> = N2 extends 0 ? never : N1 extends 0 ? 0 : N1 extends N2 ? 1 : StrNum.ToNumber< StrNum.Divide<StrNum.FromNumber<N1>, StrNum.FromNumber<N2>>[0] >;
/** * Returns the remainder after dividing the first given natural number by the second. * @example * ```ts * Mod<0, 0> => never * Mod<9, 3> => 0 * Mod<14, 5> => 4 * ``` */export type Mod<N1 extends number, N2 extends number> = N2 extends 0 ? never : N1 extends 0 ? 0 : N1 extends N2 ? 0 : StrNum.ToNumber< StrNum.Divide<StrNum.FromNumber<N1>, StrNum.FromNumber<N2>>[1] >;
/** * Returns the power of the first natural number to the second given natural number. * @example * ```ts * Pow<2, 0> => 1 * Pow<2, 3> => 8 * Pow<3, 4> => 81 * ``` */export type Pow<N1 extends number, N2 extends number> = N1 extends 0 ? 0 : N2 extends 0 ? 1 : N2 extends 1 ? N1 : N2 extends 2 ? Mult<N1, N1> : IsEven<N2> extends true ? Pow<Mult<N1, N1>, Div<N2, 2>> : Mult<N1, Pow<N1, Decr<N2>>>;