274 - Integers Comparator (Including no-limit version)

[lvjiaxuan]

Playground.

enum Comparison {
  Greater,
  Equal,
  Lower,
}

// # 4425
type _GreaterThanForPos<T extends number, U extends number, _Counter extends 0[] = []> =
  _Counter['length'] extends T
    ? _Counter['length'] extends U
      ? Comparison.Equal
      : Comparison.Lower
    : _Counter['length'] extends U
      ? Comparison.Greater
      : _GreaterThanForPos<T, U, [ ..._Counter, 0 ]>

// Limit version
// type Comparator<
//   A extends number,
//   B extends number,
// > = `${ A },${ B }` extends `-${ infer IA extends number },-${ infer IB extends number }`
//   ? _GreaterThanForPos<IB, IA>
//   : `${ A },${ B }` extends `${ number },-${ number }`
//     ? Comparison.Greater
//     : `${ A },${ B }` extends `-${ number },${ number }`
//       ? Comparison.Lower
//       : _GreaterThanForPos<A, B>


type _RemoveZeroes<T extends string> =
  `${ T }` extends `${ infer A extends string }0${ infer B extends string }`
    ? B extends '' | '0' ? T : _RemoveZeroes<`${ A }${ B }`>
    : T

type _CountStringLength<T extends string, _Counter extends 0[] = []> =
  T extends `${ string }${ infer Rest }`
    ? _CountStringLength<Rest, [ ..._Counter, 0 ]>
    : _Counter['length']

type _ComparatorNumberLengthForPos<
  A extends number,
  B extends number,
  _A extends string = `${ A }` extends `${ infer I extends string }` ? I : never,
  _B extends string = `${ B }` extends `${ infer I extends string }` ? I : never,
> = _GreaterThanForPos<_CountStringLength<_A>, _CountStringLength<_B>>

type _ComparatorEqualLengthForPos<
  A extends number,
  B extends number,
  _A extends string = `${ A }` extends `${ infer I extends string }` ? _RemoveZeroes<I> : never,
  _B extends string = `${ B }` extends `${ infer I extends string }` ? _RemoveZeroes<I> : never,
> = _A extends `${ infer FA extends number }${ infer RestA extends number }`
  ? _B extends `${ infer FB extends number }${ infer RestB extends number }`
    ? FA extends FB
      ? _ComparatorEqualLengthForPos<RestA, RestB>
      : _GreaterThanForPos<FA, FB>
    : never
  : _GreaterThanForPos<A, B>

// No limit
type Comparator<A extends number, B extends number> =
  `${ A },${ B }` extends `-${ infer IA extends number },-${ infer IB extends number }`
    ? _ComparatorNumberLengthForPos<IA, IB> extends Comparison.Equal
      ? _ComparatorEqualLengthForPos<IB, IA>
      : _ComparatorNumberLengthForPos<IB, IA>
    : `${ A },${ B }` extends `${ number },-${ number }`
      ? Comparison.Greater
      : `${ A },${ B }` extends `-${ number },${ number }`
        ? Comparison.Lower
        : _ComparatorNumberLengthForPos<A, B> extends Comparison.Equal
          ? _ComparatorEqualLengthForPos<A, B>
          : _ComparatorNumberLengthForPos<A, B>