ALU(Arithmetic Logic Unit) written in type-level Typescript

type-level-alu.ts

export type Expect<T extends true> = T;
export type Equal<X, Y> = (<T>() => T extends X ? 1 : 2) extends <
  T
>() => T extends Y ? 1 : 2
  ? true
  : false;

type NotGate<T extends number> = T extends 1 ? 0 : 1;
type AndGate<T extends number, K extends number> = [T, K] extends [1, 1]
  ? 1
  : 0;
type OrGate<T extends number, K extends number> = [T, K] extends
  | [1, 0]
  | [0, 1]
  | [1, 1]
  ? 1
  : 0;

type XORGate<T extends number, K extends number> = OrGate<
  AndGate<NotGate<T>, K>,
  AndGate<T, NotGate<K>>
>;

type HalfAdder<
  T extends number,
  K extends number,
  Sum extends number = XORGate<T, K>,
  Carry extends number = AndGate<T, K>
> = { Sum: Sum; Carry: Carry };

type FullAdder<A extends number, B extends number, C extends number> = {
  Sum: HalfAdder<C, HalfAdder<A, B>["Sum"]>["Sum"];
  Carry: OrGate<
    HalfAdder<A, B>["Carry"],
    HalfAdder<C, HalfAdder<A, B>["Sum"]>["Carry"]
  >;
};

type MuxGate<A extends number, B extends number, Sel extends number> = OrGate<
  AndGate<NotGate<Sel>, A>,
  AndGate<Sel, B>
>;
type MUX2<A extends number, B extends number, Sel extends number> = MuxGate<
  A,
  B,
  Sel
>;
type MUX4<
  A extends number,
  B extends number,
  C extends number,
  D extends number,
  Sel1 extends number,
  Sel0 extends number
> = MUX2<MUX2<A, B, Sel0>, MUX2<C, D, Sel0>, Sel1>;

type MUX8<
  A extends number,
  B extends number,
  C extends number,
  D extends number,
  E extends number,
  F extends number,
  G extends number,
  H extends number,
  Sel2 extends number,
  Sel1 extends number,
  Sel0 extends number
> = MUX2<MUX4<A, B, C, D, Sel1, Sel0>, MUX4<E, F, G, H, Sel1, Sel0>, Sel2>;

type Bit = 0 | 1;
type EightBitBus = [Bit, Bit, Bit, Bit, Bit, Bit, Bit, Bit];

type Adder8Bit<A extends EightBitBus, B extends EightBitBus> = [
  FullAdder<A[0], B[0], 0>["Sum"],

  FullAdder<A[1], B[1], FullAdder<A[0], B[0], 0>["Carry"]>["Sum"],

  FullAdder<
    A[2],
    B[2],
    FullAdder<A[1], B[1], FullAdder<A[0], B[0], 0>["Carry"]>["Carry"]
  >["Sum"],

  FullAdder<
    A[3],
    B[3],
    FullAdder<
      A[2],
      B[2],
      FullAdder<A[1], B[1], FullAdder<A[0], B[0], 0>["Carry"]>["Carry"]
    >["Carry"]
  >["Sum"],

  FullAdder<
    A[4],
    B[4],
    FullAdder<
      A[3],
      B[3],
      FullAdder<
        A[2],
        B[2],
        FullAdder<A[1], B[1], FullAdder<A[0], B[0], 0>["Carry"]>["Carry"]
      >["Carry"]
    >["Carry"]
  >["Sum"],

  FullAdder<
    A[5],
    B[5],
    FullAdder<
      A[4],
      B[4],
      FullAdder<
        A[3],
        B[3],
        FullAdder<
          A[2],
          B[2],
          FullAdder<A[1], B[1], FullAdder<A[0], B[0], 0>["Carry"]>["Carry"]
        >["Carry"]
      >["Carry"]
    >["Carry"]
  >["Sum"],

  FullAdder<
    A[6],
    B[6],
    FullAdder<
      A[5],
      B[5],
      FullAdder<
        A[4],
        B[4],
        FullAdder<
          A[3],
          B[3],
          FullAdder<
            A[2],
            B[2],
            FullAdder<A[1], B[1], FullAdder<A[0], B[0], 0>["Carry"]>["Carry"]
          >["Carry"]
        >["Carry"]
      >["Carry"]
    >["Carry"]
  >["Sum"],

  FullAdder<
    A[7],
    B[7],
    FullAdder<
      A[6],
      B[6],
      FullAdder<
        A[5],
        B[5],
        FullAdder<
          A[4],
          B[4],
          FullAdder<
            A[3],
            B[3],
            FullAdder<
              A[2],
              B[2],
              FullAdder<A[1], B[1], FullAdder<A[0], B[0], 0>["Carry"]>["Carry"]
            >["Carry"]
          >["Carry"]
        >["Carry"]
      >["Carry"]
    >["Carry"]
  >["Sum"]
];

type And8Bit<A extends EightBitBus, B extends EightBitBus> = [
  AndGate<A[0], B[0]>,
  AndGate<A[1], B[1]>,
  AndGate<A[2], B[2]>,
  AndGate<A[3], B[3]>,
  AndGate<A[4], B[4]>,
  AndGate<A[5], B[5]>,
  AndGate<A[6], B[6]>,
  AndGate<A[7], B[7]>
];

type Or8Bit<A extends EightBitBus, B extends EightBitBus> = [
  OrGate<A[0], B[0]>,
  OrGate<A[1], B[1]>,
  OrGate<A[2], B[2]>,
  OrGate<A[3], B[3]>,
  OrGate<A[4], B[4]>,
  OrGate<A[5], B[5]>,
  OrGate<A[6], B[6]>,
  OrGate<A[7], B[7]>
];

type Not8Bit<A extends EightBitBus> = [
  NotGate<A[0]>,
  NotGate<A[1]>,
  NotGate<A[2]>,
  NotGate<A[3]>,
  NotGate<A[4]>,
  NotGate<A[5]>,
  NotGate<A[6]>,
  NotGate<A[7]>
];

type OrGate2<T extends Bit, K extends Bit> = [T, K] extends [0, 0] ? 0 : 1;

type Or8Way<B extends EightBitBus> = OrGate2<
  OrGate2<OrGate2<B[0], B[1]>, OrGate2<B[2], B[3]>>,
  OrGate2<OrGate2<B[4], B[5]>, OrGate2<B[6], B[7]>>
>;