UNPKG

type-fest

Version:

A collection of essential TypeScript types

71 lines (57 loc) • 3.83 kB
import type {UnknownArray} from '../unknown-array.d.ts'; import type {TupleOf} from '../tuple-of.d.ts'; import type {StringReverse} from '../string-reverse.d.ts'; /** Returns the sum of two non-negative integers. It adds digit by digit, so it is not limited by the maximum length of a tuple. It is exact while both numbers are within `Number.MAX_SAFE_INTEGER`, and returns `number` for a result that is too large to be represented exactly. @example ``` type A = NonNegativeIntegerSum<999_999, 1>; //=> 1000000 ``` */ export type NonNegativeIntegerSum<A extends number, B extends number> = ToNumber<SumOfReversedDigits<StringReverse<`${A}`>, StringReverse<`${B}`>>>; /** Returns the difference of two non-negative integers, where `A` is not less than `B`. It subtracts digit by digit, so it is not limited by the maximum length of a tuple. It is exact while both numbers are within `Number.MAX_SAFE_INTEGER`, and returns `number` for a result that is too large to be represented exactly. @example ``` type A = NonNegativeIntegerDifference<1_000_000, 1>; //=> 999999 ``` */ export type NonNegativeIntegerDifference<A extends number, B extends number> = ToNumber<TrimLeadingZeros<DifferenceOfReversedDigits<StringReverse<`${A}`>, StringReverse<`${B}`>>>>; // A string that is not exactly a number, like one with leading zeros or one too large to be represented exactly, becomes `number`. // This differs from the public `StringToNumber`, which returns `never` for such a string. `Sum` and `Subtract` need `number` here, because a result that is too large is still a number, only not an exact one. type ToNumber<S extends string> = S extends `${infer N extends number}` ? N : never; type TrimLeadingZeros<S extends string> = S extends `0${infer Rest}` ? Rest extends '' ? '0' : TrimLeadingZeros<Rest> : S; // Splits off the least significant digit of the reversed digits, as a tuple of that length. When there are no digits left, the digit is `0`, so a shorter number is padded with zeros. type SplitDigit<S extends string> = S extends `${infer Digit extends number}${infer Rest}` ? [TupleOf<Digit>, Rest] : [[], '']; type Ten = TupleOf<10>; // The digits are reversed, so they are added from the least significant one, and each digit of the result is put in front of the previous ones. type SumOfReversedDigits<A extends string, B extends string, Carry extends UnknownArray = [], Result extends string = ''> = `${A}${B}` extends '' ? `${Carry['length'] extends 0 ? '' : '1'}${Result}` : [SplitDigit<A>, SplitDigit<B>] extends [[infer DigitA extends UnknownArray, infer RestA extends string], [infer DigitB extends UnknownArray, infer RestB extends string]] ? [...DigitA, ...DigitB, ...Carry] extends [...Ten, ...infer Digit] ? SumOfReversedDigits<RestA, RestB, [unknown], `${Digit['length']}${Result}`> : SumOfReversedDigits<RestA, RestB, [], `${[...DigitA, ...DigitB, ...Carry]['length']}${Result}`> : never; // Should never happen // Like `SumOfReversedDigits`, but it borrows from the next digit. `A` is not less than `B`, so nothing is borrowed after the last digit. type DifferenceOfReversedDigits<A extends string, B extends string, Borrow extends UnknownArray = [], Result extends string = ''> = A extends '' ? Result : [SplitDigit<A>, SplitDigit<B>] extends [[infer DigitA extends UnknownArray, infer RestA extends string], [infer DigitB extends UnknownArray, infer RestB extends string]] ? DigitA extends [...DigitB, ...Borrow, ...infer Digit] ? DifferenceOfReversedDigits<RestA, RestB, [], `${Digit['length']}${Result}`> : [...Ten, ...DigitA] extends [...DigitB, ...Borrow, ...infer Digit] ? DifferenceOfReversedDigits<RestA, RestB, [unknown], `${Digit['length']}${Result}`> : never // Should never happen : never; // Should never happen export {};