int.ts

type Zero = {
  isZero: true;
};

type Int = Zero | { prev: Int; isZero: false };

type IncrOne<T extends Int> = {
  prev: T;
  isZero: false;
};

type DecrOne<T extends Int> = T extends IncrOne<infer T> ? T : never;

type One = Extract<IncrOne<Zero>, Int>;
type Two = Extract<IncrOne<One>, Int>;
type Three = Extract<IncrOne<Two>, Int>;
type Four = Extract<IncrOne<Three>, Int>;
type Five = Extract<IncrOne<Four>, Int>;
type Six = Extract<IncrOne<Five>, Int>;
type Seven = Extract<IncrOne<Six>, Int>;
type Eight = Extract<IncrOne<Seven>, Int>;
type Nine = Extract<IncrOne<Eight>, Int>;
type Ten = Extract<IncrOne<Nine>, Int>;

type Add<T extends Int, K extends Int> = K extends Zero
  ? T
  : Add<IncrOne<T>, DecrOne<K>>;
type Minus<T extends Int, K extends Int> = K extends Zero
  ? T
  : Minus<DecrOne<T>, DecrOne<K>>;
type Times<T extends Int, K extends Int, P = Zero> = K extends Zero
  ? Extract<P, Int>
  : Times<T, DecrOne<K>, Add<Extract<P, Int>, T>>;
type Div<T extends Int, K extends Int, P = Zero, M = Minus<T, K>> = K extends Zero
  ? Zero
  : Less<T, K> extends true
  ? Extract<P, Int>
  : M extends Int
    ? Div<M, K, IncrOne<Extract<P, Int>>>
    : never

type N<T extends Int> = T extends Zero
  ? "0"
  : T extends One
  ? "1"
  : T extends Two
  ? "2"
  : T extends Three
  ? "3"
  : T extends Four
  ? "4"
  : T extends Five
  ? "5"
  : T extends Six
  ? "6"
  : T extends Seven
  ? "7"
  : T extends Eight
  ? "8"
  : T extends Nine
  ? "9"
  : never;

type n<T extends string> = T extends "0"
  ? Zero
  : T extends "1"
  ? One
  : T extends "2"
  ? Two
  : T extends "3"
  ? Three
  : T extends "4"
  ? Four
  : T extends "5"
  ? Five
  : T extends "6"
  ? Six
  : T extends "7"
  ? Seven
  : T extends "8"
  ? Eight
  : T extends "9"
  ? Nine
  : Zero;

type SingleIntStr = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9";

type nn<T extends string> = T extends SingleIntStr
  ? n<T>
  : T extends `${infer t}${infer k}`
  ? Add<Times<Ten, n<t>>, n<k>>
  : Zero;

type calc<T> = T extends `${infer t}+${infer k}` ? Add<nn<t>, nn<k>> : T;

type a = N<Nine>;

type test = calc<"2+6">;
type test1 = Two extends One ? 1 : 2;

type Equal<T extends Int, K extends Int> = T extends Zero
  ? K extends Zero
    ? true
    : false
  : Equal<DecrOne<T>, DecrOne<K>>;
type Greater<T extends Int, K extends Int> = T extends Zero
  ? false
  : K extends Zero
  ? true
  : Greater<DecrOne<T>, DecrOne<K>>;
type Less<T extends Int, K extends Int> = K extends Zero
  ? false
  : T extends Zero
  ? true
  : Less<DecrOne<T>, DecrOne<K>>;
type GreaterOrEqual<T extends Int, K extends Int> = Greater<T, K> extends true
  ? true
  : Equal<T, K> extends true
  ? true
  : false;
type LessOrEqual<T extends Int, K extends Int> = Less<T, K> extends true
  ? true
  : Equal<T, K> extends true
  ? true
  : false;

type two = Add<One, One>;
type eight = Minus<Nine, One>;
type twelve = Times<Three, Four>;

type equalTest1 = Equal<two, Two>;
type equalTest2 = Equal<twelve, Add<Ten, Two>>;

type n6 = Add<Times<Two, Two>, Two>;
type n12 = Times<Two, Six>;
type n4 = Div<n12, Three>

type greaterTest = Greater<n6, n12>;
type lessTest = Less<n12, n6>;
type greaterOrEqualTest = GreaterOrEqual<Five, n12>;
type lessOrEqualTest = LessOrEqual<Three, n12>;