type-plus 3.12.2 → 3.15.0

package/ts/function/AnyFunction.spec.ts

@@ -0,0 +1,21 @@
+import { AnyFunction, assertType } from '..'
+
+test('basic', () => {
+  function doCallback(cb: AnyFunction) {
+    cb()
+  }
+
+  doCallback(() => { })
+  doCallback(_ => { })
+  doCallback((a: number, b: number) => a + b)
+})
+
+test('define param as tuple', () => {
+  const foo: AnyFunction<[number, string]> = x => x
+  foo(1, 'a')
+})
+
+test('define result type', () => {
+  const foo: AnyFunction<string[], string> = x => x
+  assertType.isString(foo('a'))
+})

package/ts/functional/ChainFn.spec.ts

@@ -0,0 +1,7 @@
+import { assertType, ChainFn, Equal } from '..'
+
+test('return type is the same as input type', () => {
+  type A = ChainFn<number>
+
+  assertType.isTrue(true as Equal<Parameters<A>[0], ReturnType<A>>)
+})

package/ts/functional/ChainFn.ts

@@ -0,0 +1,6 @@
+export type ChainFn<T> = (param: T) => T
+
+/**
+ * An endofunctor is a functor from one category back to the same category.
+ */
+export type EndoFn<T> = (param: T) => T

package/ts/functional/Maybe.spec.ts

@@ -0,0 +1,42 @@
+import { assertType, CanAssign, canAssign } from '..'
+import { Just, just, Maybe, none, None } from './Maybe'
+
+test('just(value) returns Maybe<T>', () => {
+  assertType<Maybe<number>>(just(1))
+})
+
+test('just(undefined) returns Maybe<T>', () => {
+  const b: boolean | undefined = undefined
+  assertType<Maybe<boolean>>(just(b))
+})
+
+test('none<T>() returns Maybe<T>', () => {
+  assertType<Maybe<boolean>>(none<boolean>())
+})
+
+test('unwrap Maybe<T> returns value', () => {
+  const maybe = just('abc')
+  const actual = maybe.unwrap()
+
+  assertType<string>(actual)
+  expect(actual).toBe('abc')
+})
+
+test('None can assign to Maybe<T>', () => {
+  const actual = none<number>()
+
+  assertType.isTrue(true as CanAssign<typeof actual, Maybe<number>>)
+  assertType.isTrue(true as CanAssign<None<number>, Maybe<number>>)
+  assertType.isTrue(canAssign<Maybe<number>>()(none<number>()))
+})
+
+test('Just<number can assign to Maybe<number>', () => {
+  assertType.isTrue(true as CanAssign<Just<number>, Maybe<number>>)
+  assertType.isTrue(canAssign<Maybe<number>>()(just(1)))
+})
+
+test('Just<string> is not assignable to Maybe<number>', () => {
+  assertType.isFalse(false as CanAssign<Just<'abc'>, Maybe<number>>)
+
+  assertType.isTrue(canAssign<Maybe<number>>(false)(just('abc')))
+})

package/ts/functional/Maybe.ts

@@ -0,0 +1,19 @@
+import { Brand } from '../nominal-types'
+import { Equal } from '../predicates'
+import { Widen } from '../utils'
+
+export type Maybe<T> = Just<T> | None<T>
+export type Just<T> = Brand<'maybe', T> & { unwrap(): T }
+export type None<T> = Brand<'maybe', void> & { unwrap(): T }
+
+export function just<T>(value: T):
+  Equal<T, undefined | null> extends true ?
+  None<T> :
+  Just<Widen<NonNullable<T>>> {
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+  return { unwrap() { return value } } as any
+}
+
+export function none<T>(): None<T> {
+  return { unwrap() { } } as None<T>
+}

package/ts/functional/index.ts

@@ -0,0 +1,2 @@
+// export * from './Maybe'
+export * from './ChainFn'

package/ts/index.ts

@@ -0,0 +1,21 @@
+import * as types from './types'
+export { required, requiredDeep } from 'unpartial'
+export * from './array'
+export * from './assertion'
+export * from './class'
+export * from './ComposableTypes'
+export * from './function'
+export * from './functional'
+export * from './JSONTypes'
+export * from './math'
+export * from './nodejs'
+export * from './nominal-types'
+export * from './object'
+export * from './predicates'
+export * from './PrimitiveTypes'
+export * from './promise'
+export * from './types/optional'
+export * from './types/required'
+export * from './UnionKeys'
+export * from './utils'
+export { types, types as T }

package/ts/math/Abs.spec.ts

@@ -0,0 +1,14 @@
+import { Abs, isType } from '..'
+
+test('positive returns itself', () => {
+  isType.equal<true, 1, Abs<1>>()
+})
+
+test('negative returns positive', () => {
+  isType.equal<true, 1234, Abs<-1234>>()
+})
+
+test('number returns Fail', () => {
+  isType.equal<true, never, Abs<number>>()
+  isType.equal<true, 0, Abs<number, 0>>()
+})

package/ts/math/Abs.ts

@@ -0,0 +1,4 @@
+import { DigitArray } from './Digit'
+
+export type Abs<N extends number, Fail = never> = number extends N ? Fail :
+`${N}` extends `-${infer P}` ? DigitArray.ToNumber<DigitArray.FromString<P>> : N

package/ts/math/Add.spec.ts

@@ -0,0 +1,82 @@
+import { Add, Increment, isType } from '..'
+
+describe('Add<A, B>', () => {
+  test('fractional A gets never', () => {
+    isType.equal<true, never, Add<1.1, 1>>()
+  })
+
+  test('negative A gets never', () => {
+    isType.equal<true, never, Add<-1, 1>>()
+  })
+
+  test('fractional B gets never', () => {
+    isType.equal<true, never, Add<1, 1.2>>()
+  })
+
+  test('negative B gets never', () => {
+    isType.equal<true, never, Add<1, -1>>()
+  })
+
+  test('number gets Fail', () => {
+    isType.equal<true, never, Add<number, 1>>()
+    isType.equal<true, never, Add<1, number>>()
+
+    isType.equal<true, number, Add<number, 1, number>>()
+    isType.equal<true, number, Add<1, number, number>>()
+  })
+
+  describe('single digit', () => {
+    test('0 + n = n', () => {
+      isType.equal<true, 0, Add<0, 0>>()
+      isType.equal<true, 1, Add<0, 1>>()
+      isType.equal<true, 2, Add<0, 2>>()
+      isType.equal<true, 3, Add<0, 3>>()
+      isType.equal<true, 4, Add<0, 4>>()
+      isType.equal<true, 5, Add<0, 5>>()
+      isType.equal<true, 6, Add<0, 6>>()
+      isType.equal<true, 7, Add<0, 7>>()
+      isType.equal<true, 8, Add<0, 8>>()
+      isType.equal<true, 9, Add<0, 9>>()
+    })
+    test('9 + n', () => {
+      isType.equal<true, 9, Add<9, 0>>()
+      isType.equal<true, 10, Add<9, 1>>()
+      isType.equal<true, 11, Add<9, 2>>()
+      isType.equal<true, 12, Add<9, 3>>()
+      isType.equal<true, 13, Add<9, 4>>()
+      isType.equal<true, 14, Add<9, 5>>()
+      isType.equal<true, 15, Add<9, 6>>()
+      isType.equal<true, 16, Add<9, 7>>()
+      isType.equal<true, 17, Add<9, 8>>()
+      isType.equal<true, 18, Add<9, 9>>()
+    })
+  })
+
+  test('1 + 2 digits', () => {
+    isType.equal<true, 16, Add<3, 13>>()
+    isType.equal<true, 108, Add<9, 99>>()
+  })
+
+  test('2 + 1 digits', () => {
+    isType.equal<true, 16, Add<13, 3>>()
+    isType.equal<true, 108, Add<99, 9>>()
+  })
+
+  test('2 + 2 digits', () => {
+    isType.equal<true, 20, Add<10, 10>>()
+    isType.equal<true, 38, Add<19, 19>>()
+  })
+
+  test('n + n digits', () => {
+    isType.equal<true, 7777, Add<1234, 6543>>()
+  })
+})
+
+describe('Increment<A>', () => {
+  test('add 1', () => {
+    isType.equal<true, 1, Increment<0>>()
+  })
+  test('work with large number', () => {
+    isType.equal<true, 7777, Increment<7776>>()
+  })
+})

package/ts/math/Add.ts

@@ -0,0 +1,49 @@
+import { PadLeft } from '../array'
+import { And } from '../predicates'
+import { Digit, DigitArray } from './Digit'
+import { IsPositive } from './IsPositive'
+import { IsWhole } from './IsWhole'
+import { Max } from './Max'
+
+/**
+ * Add two number literals.
+ */
+export type Add<A extends number, B extends number, Fail = never> =
+  And<
+    And<IsPositive<A>, IsWhole<A>>,
+    And<IsPositive<B>, IsWhole<B>>
+  > extends false ? Fail :
+  DigitArray.FromNumber<A> extends infer DA ? DA extends number[] ?
+  DigitArray.FromNumber<B> extends infer DB ? DB extends number[] ?
+  Max<DA['length'], DB['length']> extends infer M ? M extends number ?
+  PadLeft<DA, M, 0> extends infer PDA ? PDA extends number[] ?
+  PadLeft<DB, M, 0> extends infer PDB ? PDB extends number[] ?
+  DigitArray.ToNumber<AddDigitArray<PDA, PDB>>
+  : Fail : Fail
+  : Fail : Fail
+  : Fail : Fail
+  : Fail : Fail
+  : Fail : Fail
+
+type AddDigitArray<A extends number[], B extends number[]> = (
+  A extends [any, ...infer ATail]
+  ? (ATail extends number[]
+    ? (B extends [any, ...infer BTail]
+      ? (BTail extends number[]
+        ? [AddDigit<A[0], B[0]>, ...AddDigitArray<ATail, BTail>]
+        : [])
+      : [A[0], ...AddDigitArray<[], ATail>])
+    : [])
+  : (B extends [any, ...infer BTail]
+    ? (BTail extends number[]
+      ? [B[0], ...AddDigitArray<[], BTail>]
+      : [])
+    : [])
+)
+
+type AddDigit<A extends number, B extends number> = [...Digit.ToTuple[A], ...Digit.ToTuple[B]]['length']
+
+/**
+ * Increment `A` by 1.
+ */
+export type Increment<A extends number, Fail = never> = Add<A, 1, Fail>

package/ts/math/Digit.spec.ts

@@ -0,0 +1,185 @@
+import { Equal, isType } from '..'
+import { Digit, DigitArray } from './Digit'
+
+describe('DigitArray.ToNumber<DA>', () => {
+  test('no digit gets 0', () => {
+    type A = DigitArray.ToNumber<[]>
+    isType.t<Equal<A, 0>>()
+  })
+
+  test('single digit', () => {
+    isType.t<Equal<DigitArray.ToNumber<[0]>, 0>>()
+    isType.t<Equal<DigitArray.ToNumber<[1]>, 1>>()
+    isType.t<Equal<DigitArray.ToNumber<[2]>, 2>>()
+    isType.t<Equal<DigitArray.ToNumber<[3]>, 3>>()
+    isType.t<Equal<DigitArray.ToNumber<[4]>, 4>>()
+    isType.t<Equal<DigitArray.ToNumber<[5]>, 5>>()
+    isType.t<Equal<DigitArray.ToNumber<[6]>, 6>>()
+    isType.t<Equal<DigitArray.ToNumber<[7]>, 7>>()
+    isType.t<Equal<DigitArray.ToNumber<[8]>, 8>>()
+    isType.t<Equal<DigitArray.ToNumber<[9]>, 9>>()
+
+  })
+
+  test('two digits', () => {
+    isType.t<Equal<DigitArray.ToNumber<[1, 0]>, 10>>()
+    isType.t<Equal<DigitArray.ToNumber<[1, 0]>, 10>>()
+    isType.t<Equal<DigitArray.ToNumber<[3, 1]>, 31>>()
+    isType.t<Equal<DigitArray.ToNumber<[13, 1]>, 131>>()
+    isType.t<Equal<DigitArray.ToNumber<[1, 2, 3, 4]>, 1234>>()
+  })
+
+  test('multi digits', () => {
+    isType.t<Equal<DigitArray.ToNumber<[1, 2, 3, 4]>, 1234>>()
+    isType.t<Equal<DigitArray.ToNumber<[1, 2, 3, 5]>, 1235>>()
+  })
+})
+
+describe('DigitArray.Shift10<DA>', () => {
+  test('zero digit gets the same', () => {
+    isType.equal<true, [], DigitArray.Shift10<[]>>()
+  })
+
+  test('single digit gets the same', () => {
+    isType.equal<true, [5], DigitArray.Shift10<[5]>>()
+  })
+
+  test('two digits with leading 0 get trimmed', () => {
+    isType.equal<true, [5], DigitArray.Shift10<[0, 5]>>()
+  })
+  test('two digits gets value shifted', () => {
+    isType.equal<true, [15], DigitArray.Shift10<[1, 5]>>()
+    isType.equal<true, [8, 10], DigitArray.Shift10<[9, 0]>>()
+    isType.equal<true, [8, 19], DigitArray.Shift10<[9, 9]>>()
+  })
+  test('multiple digits', () => {
+    isType.equal<true, [11, 12, 14], DigitArray.Shift10<[0, 1, 2, 3, 4]>>()
+  })
+})
+
+
+describe('Digit.GreaterThan<A, B>', () => {
+  test('n > n is false', () => {
+    isType.equal<true, false, Digit.GreaterThan<0, 0>>()
+    isType.equal<true, false, Digit.GreaterThan<1, 1>>()
+    isType.equal<true, false, Digit.GreaterThan<2, 2>>()
+    isType.equal<true, false, Digit.GreaterThan<3, 3>>()
+    isType.equal<true, false, Digit.GreaterThan<4, 4>>()
+    isType.equal<true, false, Digit.GreaterThan<5, 5>>()
+    isType.equal<true, false, Digit.GreaterThan<6, 6>>()
+    isType.equal<true, false, Digit.GreaterThan<7, 7>>()
+    isType.equal<true, false, Digit.GreaterThan<8, 8>>()
+    isType.equal<true, false, Digit.GreaterThan<9, 9>>()
+  })
+  test('N > m is true', () => {
+    isType.equal<true, true, Digit.GreaterThan<1, 0>>()
+    isType.equal<true, true, Digit.GreaterThan<2, 0>>()
+    isType.equal<true, true, Digit.GreaterThan<3, 0>>()
+    isType.equal<true, true, Digit.GreaterThan<4, 0>>()
+    isType.equal<true, true, Digit.GreaterThan<5, 0>>()
+    isType.equal<true, true, Digit.GreaterThan<6, 0>>()
+    isType.equal<true, true, Digit.GreaterThan<7, 0>>()
+    isType.equal<true, true, Digit.GreaterThan<8, 0>>()
+    isType.equal<true, true, Digit.GreaterThan<9, 0>>()
+
+    isType.equal<true, true, Digit.GreaterThan<2, 1>>()
+    isType.equal<true, true, Digit.GreaterThan<3, 1>>()
+    isType.equal<true, true, Digit.GreaterThan<4, 1>>()
+    isType.equal<true, true, Digit.GreaterThan<5, 1>>()
+    isType.equal<true, true, Digit.GreaterThan<6, 1>>()
+    isType.equal<true, true, Digit.GreaterThan<7, 1>>()
+    isType.equal<true, true, Digit.GreaterThan<8, 1>>()
+    isType.equal<true, true, Digit.GreaterThan<9, 1>>()
+
+    isType.equal<true, true, Digit.GreaterThan<3, 2>>()
+    isType.equal<true, true, Digit.GreaterThan<4, 2>>()
+    isType.equal<true, true, Digit.GreaterThan<5, 2>>()
+    isType.equal<true, true, Digit.GreaterThan<6, 2>>()
+    isType.equal<true, true, Digit.GreaterThan<7, 2>>()
+    isType.equal<true, true, Digit.GreaterThan<8, 2>>()
+    isType.equal<true, true, Digit.GreaterThan<9, 2>>()
+
+    isType.equal<true, true, Digit.GreaterThan<4, 3>>()
+    isType.equal<true, true, Digit.GreaterThan<5, 3>>()
+    isType.equal<true, true, Digit.GreaterThan<6, 3>>()
+    isType.equal<true, true, Digit.GreaterThan<7, 3>>()
+    isType.equal<true, true, Digit.GreaterThan<8, 3>>()
+    isType.equal<true, true, Digit.GreaterThan<9, 3>>()
+
+    isType.equal<true, true, Digit.GreaterThan<5, 4>>()
+    isType.equal<true, true, Digit.GreaterThan<6, 4>>()
+    isType.equal<true, true, Digit.GreaterThan<7, 4>>()
+    isType.equal<true, true, Digit.GreaterThan<8, 4>>()
+    isType.equal<true, true, Digit.GreaterThan<9, 4>>()
+
+    isType.equal<true, true, Digit.GreaterThan<6, 5>>()
+    isType.equal<true, true, Digit.GreaterThan<7, 5>>()
+    isType.equal<true, true, Digit.GreaterThan<8, 5>>()
+    isType.equal<true, true, Digit.GreaterThan<9, 5>>()
+
+    isType.equal<true, true, Digit.GreaterThan<7, 6>>()
+    isType.equal<true, true, Digit.GreaterThan<8, 6>>()
+    isType.equal<true, true, Digit.GreaterThan<9, 6>>()
+
+    isType.equal<true, true, Digit.GreaterThan<8, 7>>()
+    isType.equal<true, true, Digit.GreaterThan<9, 7>>()
+
+    isType.equal<true, true, Digit.GreaterThan<9, 8>>()
+  })
+
+  test('n > M is false', () => {
+    isType.equal<true, false, Digit.GreaterThan<0, 1>>()
+    isType.equal<true, false, Digit.GreaterThan<0, 2>>()
+    isType.equal<true, false, Digit.GreaterThan<0, 3>>()
+    isType.equal<true, false, Digit.GreaterThan<0, 4>>()
+    isType.equal<true, false, Digit.GreaterThan<0, 5>>()
+    isType.equal<true, false, Digit.GreaterThan<0, 6>>()
+    isType.equal<true, false, Digit.GreaterThan<0, 7>>()
+    isType.equal<true, false, Digit.GreaterThan<0, 8>>()
+    isType.equal<true, false, Digit.GreaterThan<0, 9>>()
+
+    isType.equal<true, false, Digit.GreaterThan<1, 2>>()
+    isType.equal<true, false, Digit.GreaterThan<1, 3>>()
+    isType.equal<true, false, Digit.GreaterThan<1, 4>>()
+    isType.equal<true, false, Digit.GreaterThan<1, 5>>()
+    isType.equal<true, false, Digit.GreaterThan<1, 6>>()
+    isType.equal<true, false, Digit.GreaterThan<1, 7>>()
+    isType.equal<true, false, Digit.GreaterThan<1, 8>>()
+    isType.equal<true, false, Digit.GreaterThan<1, 9>>()
+
+    isType.equal<true, false, Digit.GreaterThan<2, 3>>()
+    isType.equal<true, false, Digit.GreaterThan<2, 4>>()
+    isType.equal<true, false, Digit.GreaterThan<2, 5>>()
+    isType.equal<true, false, Digit.GreaterThan<2, 6>>()
+    isType.equal<true, false, Digit.GreaterThan<2, 7>>()
+    isType.equal<true, false, Digit.GreaterThan<2, 8>>()
+    isType.equal<true, false, Digit.GreaterThan<2, 9>>()
+
+    isType.equal<true, false, Digit.GreaterThan<3, 4>>()
+    isType.equal<true, false, Digit.GreaterThan<3, 5>>()
+    isType.equal<true, false, Digit.GreaterThan<3, 6>>()
+    isType.equal<true, false, Digit.GreaterThan<3, 7>>()
+    isType.equal<true, false, Digit.GreaterThan<3, 8>>()
+    isType.equal<true, false, Digit.GreaterThan<3, 9>>()
+
+    isType.equal<true, false, Digit.GreaterThan<4, 5>>()
+    isType.equal<true, false, Digit.GreaterThan<4, 6>>()
+    isType.equal<true, false, Digit.GreaterThan<4, 7>>()
+    isType.equal<true, false, Digit.GreaterThan<4, 8>>()
+    isType.equal<true, false, Digit.GreaterThan<4, 9>>()
+
+    isType.equal<true, false, Digit.GreaterThan<5, 6>>()
+    isType.equal<true, false, Digit.GreaterThan<5, 7>>()
+    isType.equal<true, false, Digit.GreaterThan<5, 8>>()
+    isType.equal<true, false, Digit.GreaterThan<5, 9>>()
+
+    isType.equal<true, false, Digit.GreaterThan<6, 7>>()
+    isType.equal<true, false, Digit.GreaterThan<6, 8>>()
+    isType.equal<true, false, Digit.GreaterThan<6, 9>>()
+
+    isType.equal<true, false, Digit.GreaterThan<7, 8>>()
+    isType.equal<true, false, Digit.GreaterThan<7, 9>>()
+
+    isType.equal<true, false, Digit.GreaterThan<8, 9>>()
+  })
+})

package/ts/math/Digit.ts

@@ -0,0 +1,115 @@
+import { Tail } from '../array'
+import { And } from '../predicates'
+import { IsPositive } from './IsPositive'
+import { IsWhole } from './IsWhole'
+
+export namespace Digit {
+  export type ToTuple = {
+    [k in number]: any[]
+  } & {
+    0: [],
+    1: [1],
+    2: [1, 1],
+    3: [1, 1, 1],
+    4: [1, 1, 1, 1],
+    5: [1, 1, 1, 1, 1],
+    6: [1, 1, 1, 1, 1, 1],
+    7: [1, 1, 1, 1, 1, 1, 1],
+    8: [1, 1, 1, 1, 1, 1, 1, 1],
+    9: [1, 1, 1, 1, 1, 1, 1, 1, 1],
+    10: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
+    11: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
+    12: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
+    13: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
+    14: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
+    15: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
+    16: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
+    17: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
+    18: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
+    19: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
+  }
+
+  /**
+   * A > B for [1-9]
+   */
+  export type GreaterThan<A extends number, B extends number> = B extends GreaterThanMap[A] ? true : false
+
+  type GreaterThanMap = { [k in number]: number } & {
+    0: never,
+    1: 0,
+    2: 0 | 1,
+    3: 0 | 1 | 2,
+    4: 0 | 1 | 2 | 3,
+    5: 0 | 1 | 2 | 3 | 4,
+    6: 0 | 1 | 2 | 3 | 4 | 5,
+    7: 0 | 1 | 2 | 3 | 4 | 5 | 6,
+    8: 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7,
+    9: 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8,
+  }
+}
+
+export namespace DigitArray {
+  export type ToNumber<C extends number[]> = ToTuple<[], C>['length']
+
+  export type ToTuple<R extends any[], S extends number[]> =
+    S['length'] extends 0
+    ? R
+    : (S['length'] extends 1
+      ? [...R, ...Digit.ToTuple[S[0]]]
+      : (S extends [any, ...infer T]
+        ? (T extends any[]
+          ? ToTuple<Multi10<[...R, ...Digit.ToTuple[S[0]]]>, T>
+          : never)
+        : never))
+
+  type Multi10<C extends any[]> = [...C, ...C, ...C, ...C, ...C, ...C, ...C, ...C, ...C, ...C]
+
+
+  export type FromNumber<N extends number> = FromString<NumberToString<N>>
+
+  type NumberToString<N extends number> = (And<IsPositive<N>, IsWhole<N>>) extends true ? `${N}` : never
+
+  export type FromString<S extends string> = S extends `1${infer L}` ? [1, ...FromString<L>]
+    : S extends `2${infer L}` ? [2, ...FromString<L>]
+    : S extends `3${infer L}` ? [3, ...FromString<L>]
+    : S extends `4${infer L}` ? [4, ...FromString<L>]
+    : S extends `5${infer L}` ? [5, ...FromString<L>]
+    : S extends `6${infer L}` ? [6, ...FromString<L>]
+    : S extends `7${infer L}` ? [7, ...FromString<L>]
+    : S extends `8${infer L}` ? [8, ...FromString<L>]
+    : S extends `9${infer L}` ? [9, ...FromString<L>]
+    : S extends `0${infer L}` ? [0, ...FromString<L>]
+    : []
+
+  export type Shift10<DA extends number[]> = TrimLeadingZero<Shift10State<[], DA>>
+  type Shift10State<R extends number[], DA extends number[]> =
+    DA['length'] extends 0
+    ? R
+    : (DA['length'] extends 1
+      ? [...R, ...DA]
+      : (DA extends [any, ...infer T]
+        ? (T extends number[]
+          ? (DA[0] extends 0
+            ? Shift10State<[...R, DA[0]], T>
+            : (T extends [any, ...infer Y]
+              ? (Y extends number[]
+                ? Shift10State<[...R, MinusOne[DA[0]]], [Plus10[T[0]], ...Y]>
+                : [])
+              : []))
+          : [])
+        : [])
+    )
+
+  type TrimLeadingZero<A extends number[]> =
+    A['length'] extends 0
+    ? A
+    : A[0] extends 0 ? TrimLeadingZero<Tail<A>> : A
+
+  type MinusOne = { [k in number]: number } & {
+    0: 0, 1: 0, 2: 1, 3: 2, 4: 3, 5: 4, 6: 5, 7: 6, 8: 7, 9: 8,
+    10: 9, 11: 10, 12: 11, 13: 12, 14: 13, 15: 14, 16: 15, 17: 16, 18: 17, 19: 18
+  }
+
+  type Plus10 = { [k in number]: number } &
+  { 0: 10, 1: 11, 2: 12, 3: 13, 4: 14, 5: 15, 6: 16, 7: 17, 8: 18, 9: 19 }
+}

package/ts/math/GreaterThan.spec.ts

@@ -0,0 +1,40 @@
+import { GreaterThan, isType } from '..'
+
+test('only support positive and whole number', () => {
+  isType.equal<true, never, GreaterThan<0.1, 1>>()
+  isType.equal<true, never, GreaterThan<-1, 1>>()
+  isType.equal<true, never, GreaterThan<1, 0.1>>()
+  isType.equal<true, never, GreaterThan<1, -1>>()
+})
+
+test('number gets never', () => {
+  isType.equal<true, never, GreaterThan<number, 1>>()
+  isType.equal<true, never, GreaterThan<1, number>>()
+})
+
+test('override Fail case', () => {
+  isType.equal<true, number, GreaterThan<number, 1, number>>()
+})
+
+test('n > n is false', () => {
+  isType.f<GreaterThan<0, 0>>()
+  isType.f<GreaterThan<1, 1>>()
+  isType.f<GreaterThan<12, 12>>()
+})
+
+test('with same number of digits', () => {
+  isType.t<GreaterThan<1, 0>>()
+  isType.t<GreaterThan<22, 11>>()
+  isType.t<GreaterThan<20, 19>>()
+
+  isType.f<GreaterThan<0, 1>>()
+  isType.f<GreaterThan<11, 22>>()
+  isType.f<GreaterThan<19, 20>>()
+})
+
+test('with different number of digits', () => {
+  isType.f<GreaterThan<0, 1>>()
+  isType.f<GreaterThan<9, 100>>()
+  isType.t<GreaterThan<10, 1>>()
+  isType.t<GreaterThan<123, 32>>()
+})

package/ts/math/GreaterThan.ts

@@ -0,0 +1,36 @@
+import { Head, PadLeft, Tail } from '../array'
+import { And, Equal } from '../predicates'
+import { Digit, DigitArray } from './Digit'
+import { IsPositive } from './IsPositive'
+import { IsWhole } from './IsWhole'
+import { Max } from './Max'
+
+export type GreaterThan<A extends number, B extends number, Fail = never> =
+  And<
+    And<IsPositive<A>, IsWhole<A>>,
+    And<IsPositive<B>, IsWhole<B>>
+  > extends false ? Fail :
+  number extends A ? Fail :
+  number extends B ? Fail :
+  Equal<A, B> extends true ? false :
+  GreaterThanOnPositiveWhole<A, B>
+
+type GreaterThanOnPositiveWhole<A extends number, B extends number> = (
+  DigitArray.FromNumber<A> extends infer DA ? DA extends number[] ?
+  DigitArray.FromNumber<B> extends infer DB ? DB extends number[] ?
+  Max<DA['length'], DB['length']> extends infer M ? M extends number ?
+  PadLeft<DA, M, 0> extends infer PDA ? PDA extends number[] ?
+  PadLeft<DB, M, 0> extends infer PDB ? PDB extends number[] ?
+  GreaterThanOnDigitArray<PDA, PDB>
+  : never : never
+  : never : never
+  : never : never
+  : never : never
+  : never : never
+)
+
+type GreaterThanOnDigitArray<DA extends number[], DB extends number[]> = (
+  Equal<Head<DA>, Head<DB>> extends true ?
+  GreaterThanOnDigitArray<Tail<DA>, Tail<DB>> extends Tail<DA> ? true : false :
+  Digit.GreaterThan<Head<DA>, Head<DB>> extends true ? true : false
+)