@shd101wyy/yo 0.0.2

package/std/prelude.yo

@@ -0,0 +1,3094 @@
+// Prelude Module
+// - Calling "import" is prohibited in this prelude module.
+
+// === Builtin Yo functions ===
+extern "Yo",
+  // compt_codegen_inline: (fn(compt(C): compt_string)-> compt(unit)),
+  // compt_noop: (()-> compt(unit)),
+  __yo_return_self : (fn(forall(T: Type), self: T) -> T),
+  __yo_noop: (fn(forall(T : Type))-> T),
+  __yo_as: (fn(forall(_Self: Type), self: _Self, compt(Target): Type) -> Target),
+  
+  // Arithmetic Operators
+  /// +
+  __yo_op_add : (fn(forall(T : Type), x : T, y : T) -> T),
+  /// -
+  __yo_op_sub : (fn(forall(T : Type), x : T, y : T) -> T),
+  /// *
+  __yo_op_mul : (fn(forall(T : Type), x : T, y : T) -> T),
+  /// /
+  __yo_op_div : (fn(forall(T : Type), x : T, y : T) -> T),
+  /// %
+  __yo_op_mod : (fn(forall(T : Type), x : T, y : T) -> T),
+  /// -
+  __yo_op_neg : (fn(forall(T : Type), x : T) -> T),
+  
+  // Relational Operators
+  /// ==
+  __yo_op_eq : (fn(forall(T : Type), x : T, y : T) -> bool),
+  /// !=
+  __yo_op_neq : (fn(forall(T : Type), x : T, y: T) -> bool),
+  /// <
+  __yo_op_lt : (fn(forall(T : Type), x : T, y : T) -> bool),
+  /// <=
+  __yo_op_lte : (fn(forall(T : Type), x : T, y : T) -> bool),
+  /// >
+  __yo_op_gt : (fn(forall(T : Type), x : T, y : T) -> bool),
+  /// >=
+  __yo_op_gte : (fn(forall(T : Type), x : T, y : T) -> bool),
+
+  // Logical Operators
+  /// !
+  __yo_op_not : (fn(forall(T : Type), x : T) -> bool),
+
+  // Bitwise Operators
+  /// &
+  __yo_op_bit_and : (fn(forall(T : Type), x : T, y : T) -> T),
+  /// |
+  __yo_op_bit_or  : (fn(forall(T : Type), x : T, y : T) -> T),
+  /// ^
+  __yo_op_bit_xor : (fn(forall(T : Type), x : T, y : T) -> T),
+  /// ~
+  __yo_op_bit_complement: (fn(forall(T : Type), x : T) -> T),
+  /// <<
+  __yo_op_bit_left_shift : (fn(forall(T : Type), x : T, y : T) -> T),
+  /// >>
+  __yo_op_bit_right_shift : (fn(forall(T : Type), x : T, y : T) -> T),
+
+  // Ptr related functions
+  __yo_ptr_add :
+    fn(forall(T: Type), ptr : T, offset : usize) -> T,
+  __yo_ptr_sub :
+    fn(forall(T: Type), ptr : T, offset : usize) -> T,
+  __yo_ptr_diff :
+    fn(forall(T: Type), ptr1 : T, ptr2 : T) -> isize,
+  __yo_ptr_eq :
+    fn(forall(T: Type), ptr1 : T, ptr2 : T) -> bool,
+  __yo_ptr_neq :
+    fn(forall(T: Type), ptr1 : T, ptr2 : T) -> bool,
+  __yo_ptr_lt :
+    fn(forall(T: Type), ptr1 : T, ptr2 : T) -> bool,
+  __yo_ptr_lte :
+    fn(forall(T: Type), ptr1 : T, ptr2 : T) -> bool,
+  __yo_ptr_gt :
+    fn(forall(T: Type), ptr1 : T, ptr2 : T) -> bool,
+  __yo_ptr_gte :
+    fn(forall(T: Type), ptr1 : T, ptr2 : T) -> bool,
+
+  // slice related
+  __yo_slice_len :
+    fn(forall(T: Type), slice: Slice(T)) -> usize
+;
+export __yo_as;
+
+assert :: (fn(flag : bool, (compt(msg) : compt_string) ?= "Assertion failed.") -> unit)
+  cond(
+    flag => (),
+    true => panic(msg)
+  )
+;
+export assert;
+
+
+/// === Modules ===
+Send :: module(
+  id := "Send"
+);
+export Send;
+
+/// === Arithmetic ===
+Add :: (fn(compt(Rhs) : Type, compt(Output) ?= Rhs)-> compt(Module))
+  module
+    Output := Output,
+    (+)    :  (fn(lhs: Self, rhs: Rhs)-> Output)
+;
+export Add;
+
+ComptAdd :: (fn(compt(Rhs) : Type, compt(Output) ?= Rhs)-> compt(Module))
+  module
+    Output := Output,
+    (+)    :  (fn(compt(lhs): Self, compt(rhs): Rhs)-> compt(Output))
+;
+export ComptAdd;
+
+Sub :: (fn(compt(Rhs) : Type, compt(Output) ?= Rhs)-> compt(Module))
+  module
+    Output := Output,
+    (-)    : (fn(lhs: Self, rhs: Rhs)-> Output)
+;
+export Sub;
+
+ComptSub :: (fn(compt(Rhs) : Type, compt(Output) ?= Rhs)-> compt(Module))
+  module
+    Output := Output,
+    (-)    : (fn(compt(lhs): Self, compt(rhs): Rhs)-> compt(Output))
+;
+export ComptSub;
+
+Mul :: (fn(compt(Rhs) : Type, compt(Output) ?= Rhs)-> compt(Module))
+  module
+    Output := Output,
+    (*)    : (fn(lhs: Self, rhs: Rhs)-> Output)
+;
+export Mul;
+
+ComptMul :: (fn(compt(Rhs) : Type, compt(Output) ?= Rhs)-> compt(Module))
+  module
+    Output := Output,
+    (*)    : (fn(compt(lhs): Self, compt(rhs): Rhs)-> compt(Output))
+;
+export ComptMul;
+
+Div :: (fn(compt(Rhs) : Type, compt(Output) ?= Rhs)-> compt(Module))
+  module
+    Output := Output,
+    (/)    : (fn(lhs: Self, rhs: Rhs)-> Output)
+;
+export Div;
+
+ComptDiv :: (fn(compt(Rhs) : Type, compt(Output) ?= Rhs)-> compt(Module))
+  module
+    Output := Output,
+    (/)    : (fn(compt(lhs): Self, compt(rhs): Rhs)-> compt(Output))
+;
+export ComptDiv;
+
+Mod :: (fn(compt(Rhs) : Type, compt(Output) ?= Rhs)-> compt(Module))
+  module
+    Output := Output,
+    (%)    : (fn(lhs: Self, rhs: Rhs)-> Output)
+;
+export Mod;
+
+ComptMod :: (fn(compt(Rhs) : Type, compt(Output) ?= Rhs)-> compt(Module))
+  module
+    Output := Output,
+    (%)    : (fn(compt(lhs): Self, compt(rhs): Rhs)-> compt(Output))
+;
+export ComptMod;
+
+BitLeftShift :: (fn(compt(Rhs) : Type, compt(Output) ?= Rhs)-> compt(Module))
+  module
+    Output := Output,
+    (<<)   : (fn(lhs: Self, rhs: Rhs)-> Output)
+;
+export BitLeftShift;
+
+ComptBitLeftShift :: (fn(compt(Rhs) : Type, compt(Output) ?= Rhs)-> compt(Module))
+  module
+    Output := Output,
+    (<<)   : (fn(compt(lhs): Self, compt(rhs): Rhs)-> compt(Output))
+;
+export ComptBitLeftShift;
+
+BitRightShift :: (fn(compt(Rhs) : Type, compt(Output) ?= Rhs)-> compt(Module))
+  module
+    Output := Output,
+    (>>)   : (fn(lhs: Self, rhs: Rhs)-> Output)
+;
+export BitRightShift;
+
+ComptBitRightShift :: (fn(compt(Rhs) : Type, compt(Output) ?= Rhs)-> compt(Module))
+  module
+    Output := Output,
+    (>>)   : (fn(compt(lhs): Self, compt(rhs): Rhs)-> compt(Output))
+;
+export ComptBitRightShift;
+
+Exponentiation :: (fn(compt(Rhs) : Type, compt(Output) ?= Rhs)-> compt(Module))
+  module
+    Output := Output,
+    (**)   : (fn(lhs: Self, rhs: Rhs)-> Output)
+;
+export Exponentiation;
+
+ComptExponentiation :: (fn(compt(Rhs) : Type, compt(Output) ?= Rhs)-> compt(Module))
+  module
+    Output := Output,
+    (**)   : (fn(compt(lhs): Self, compt(rhs): Rhs)-> compt(Output))
+;
+export ComptExponentiation;
+
+Negate :: (fn(compt(Output) : Type)-> compt(Module)) 
+  module
+    Output := Output,
+    (neg): (fn(self: Self)-> Output)
+;
+export Negate;
+
+ComptNegate :: (fn(compt(Output) : Type)-> compt(Module)) 
+  module
+    Output := Output,
+    (neg) : (fn(compt(self): Self)-> compt(Output))
+;
+export ComptNegate;
+
+/// === Logic ===
+LogicalNot :: module
+  (!)  : (fn(self: Self)-> bool)
+;
+export LogicalNot;
+
+ComptLogicalNot :: module
+  (!)  : (fn(compt(self): Self) -> compt(bool))
+;
+export ComptLogicalNot;
+
+BitNot :: (fn(compt(Output) : Type) -> compt(Module))
+  module
+    Output := Output,
+    (~)    :  (fn(self: Self)-> Output)
+;
+export BitNot;
+
+ComptBitNot :: (fn(compt(Output) : Type) -> compt(Module))
+  module
+    Output := Output,
+    (~)    :  (fn(compt(self): Self)-> compt(Output))
+;
+export ComptBitNot;
+
+BitAnd :: (fn(compt(Rhs) : Type, compt(Output) ?= Rhs) -> compt(Module)) 
+  module
+    Output := Output,
+    (&)    :  (fn(lhs: Self, rhs: Rhs)-> Output)
+;
+export BitAnd;
+
+ComptBitAnd :: (fn(compt(Rhs) : Type, compt(Output) ?= Rhs) -> compt(Module)) 
+  module
+    Output := Output,
+    (&)    :  (fn(compt(lhs): Self, compt(rhs): Rhs)-> compt(Output))
+;
+export ComptBitAnd;
+
+BitOr :: (fn(compt(Rhs) : Type, compt(Output) ?= Rhs) -> compt(Module))
+  module
+    Output := Output,
+    (|)    :  (fn(lhs: Self, rhs: Rhs)-> Output)
+;
+export BitOr;
+
+ComptBitOr :: (fn(compt(Rhs) : Type, compt(Output) ?= Rhs) -> compt(Module))
+  module
+    Output := Output,
+    (|)    :  (fn(compt(lhs): Self, compt(rhs): Rhs)-> compt(Output))
+;
+export ComptBitOr;
+
+BitXor :: (fn(compt(Rhs) : Type, compt(Output) ?= Rhs) -> compt(Module)) 
+  module
+    Output := Output,
+    (^)    :  (fn(lhs: Self, rhs: Rhs)-> Output)
+;
+export BitXor;
+
+ComptBitXor :: (fn(compt(Rhs) : Type, compt(Output) ?= Rhs) -> compt(Module)) 
+  module
+    Output := Output,
+    (^)    :  (fn(compt(lhs): Self, compt(rhs): Rhs)-> compt(Output))
+;
+export ComptBitXor;
+
+(!) :: impl {
+  (not) :: (fn(forall(_Self : Type),
+            self : _Self,
+            where(_Self <: LogicalNot)
+          ) -> bool)
+    self.(!)()
+  ;
+
+  (compt_not) :: (fn(forall(_Self : Type), 
+          compt(self) : _Self,
+          where(_Self <: ComptLogicalNot)
+        ) -> compt(bool))
+    self.(!)()
+  ;
+
+  Call :: (not, compt_not);
+
+  export
+    Call,
+    not,
+    compt_not
+  ;
+};
+(not) :: (!);
+export not, (!);
+
+(-) :: impl {
+  (neg) :: (fn(forall(_Self : Type),
+            self : _Self,
+            where(_Self <: Negate(_Self))
+          ) -> _Self) {
+    return self.neg();
+  };
+
+  (compt_neg) :: (fn(forall(_Self : Type), 
+          compt(self) : _Self,
+          where(_Self <: ComptNegate(_Self))
+        ) -> compt(_Self)) {
+    return self.neg();
+  };
+
+  Call :: (neg, compt_neg);
+
+  export
+    Call,
+    neg,
+    compt_neg
+  ;
+};
+export (-);
+
+/**
+ * logic for bool
+ * No need to export them. For internal use only
+ */
+impl(bool, LogicalNot(
+  (!): ((a) ->
+    __yo_op_not(a)
+  )
+));
+impl(bool, ComptLogicalNot(
+  (!) : (fn(compt(self): bool) -> compt(bool))(
+    __yo_compt_boolean_not(self)
+  )
+));
+
+/// === Eq ===
+Eq ::
+  (fn(compt(Rhs) : Type) -> compt(Module))
+  module(
+    (==) : (fn(lhs: Self, rhs: Rhs) -> bool),
+
+    ((!=) : (fn(lhs: Self, rhs: Rhs) -> bool)) ?= 
+      ((lhs, rhs) ->
+        not(Self.(==)(lhs, rhs))
+      )
+  );
+export Eq;
+
+ComptEq ::
+  (fn(compt(Rhs) : Type) -> compt(Module))
+  module(
+    (==) : (fn(compt(lhs): Self, compt(rhs): Rhs) -> compt(bool)),
+
+    ((!=) : (fn(compt(lhs): Self, compt(rhs): Rhs) -> compt(bool))) ?= 
+      ((lhs, rhs) ->
+        not(Self.(==)(lhs, rhs))
+      )
+  )
+;
+export ComptEq;
+
+/// === Ord ===
+Ordering :: enum
+  Less,
+  Equal,
+  Greater
+;
+export Ordering;
+
+Ord :: (
+  fn(
+    compt(Rhs) : Type
+  ) -> compt(Module))
+  module(
+    where(Self <: Eq(Rhs)),
+
+    (<) :
+      fn(lhs: Self, rhs: Rhs) -> bool,
+    (<=) :
+      fn(lhs: Self, rhs: Rhs) -> bool,
+    (>) :
+      fn(lhs: Self, rhs: Rhs) -> bool,
+    (>=) :
+      fn(lhs: Self, rhs: Rhs) -> bool
+  )
+;
+export Ord;
+
+ComptOrd :: (
+  fn(
+    compt(Rhs) : Type
+  ) -> compt(Module))
+  module(
+    where(Self <: ComptEq(Rhs)),
+
+    (<) :
+      fn(compt(lhs): Self, compt(rhs): Rhs) -> compt(bool),
+    (<=) :
+      fn(compt(lhs): Self, compt(rhs): Rhs) -> compt(bool),
+    (>) :
+      fn(compt(lhs): Self, compt(rhs): Rhs) -> compt(bool),
+    (>=) :
+      fn(compt(lhs): Self, compt(rhs): Rhs) -> compt(bool)
+  )
+;
+
+/**
+ * Hash trait - Similar to Rust's std::hash::Hash
+ * 
+ * This trait defines the ability to hash a value into a u64.
+ * Types that implement Hash can be used as keys in HashMap and HashSet.
+ * 
+ * The hash function should satisfy:
+ * 1. Deterministic: The same value always produces the same hash
+ * 2. Consistent with Eq: If a == b, then hash(a) == hash(b)
+ * 
+ * Note: Unlike Rust which uses a Hasher trait for incremental hashing,
+ * we use a simpler approach where each type directly produces a u64 hash.
+ */
+Hash :: module(
+  /**
+    * Compute the hash of a value
+    * Returns a u64 hash value
+    */
+  (hash): (fn(value: Self) -> u64)
+);
+export
+  Hash
+;
+
+// === Clone ===
+Clone :: (fn(compt(Output) : Type) -> compt(Module))
+  module(
+    clone : 
+      fn(self: Self) -> Output
+  )
+;
+
+// === Isolation ===
+Isolation :: module(
+  can_isolate : (fn(self : Self) -> bool)
+);
+export Isolation;
+
+// === Builtin types ===
+/// bool
+impl(bool, Send());
+impl(bool, Eq(bool)(
+  (==): ((a, b) ->
+    __yo_op_eq(a, b)
+  )
+));
+impl(bool, Clone(bool)(
+  clone: ((self) ->
+    __yo_return_self(self)
+  )
+));
+impl(bool, Hash(
+  (hash): ((value) ->
+    cond(
+      value => u64(1),
+      true => u64(0)
+    )
+  )
+));
+impl(bool, ComptEq(bool)(
+  (==) : (fn(compt(lhs): bool, compt(rhs): bool) -> compt(bool))(
+    __yo_compt_boolean_eq(lhs, rhs)
+  )
+));
+impl(bool, {
+  (to_string) :: (fn(compt(self): bool) -> compt(compt_string))
+    __yo_compt_boolean_to_string(self)
+  ;
+  export to_string;
+});
+_boolean :: bool;
+export bool : _boolean;
+
+/// i8
+impl(i8, Send());
+impl(i8, Add(i8)(
+  (+): ((a, b) -> __yo_op_add(a, b))
+));
+impl(i8, Sub(i8)(
+  (-): ((a, b) -> __yo_op_sub(a, b))
+));
+impl(i8, Mul(i8)(
+  (*): ((a, b) -> __yo_op_mul(a, b))
+));
+impl(i8, Div(i8)(
+  (/): ((a, b) -> __yo_op_div(a, b))
+));
+impl(i8, Mod(i8)(
+  (%): ((a, b) -> __yo_op_mod(a, b))
+));
+impl(i8, Negate(i8)(
+  (neg): ((a) -> __yo_op_neg(a))
+));
+impl(i8, BitLeftShift(i8)(
+  (<<): ((a, b) -> __yo_op_bit_left_shift(a, b))
+));
+impl(i8, BitRightShift(i8)(
+  (>>): ((a, b) -> __yo_op_bit_right_shift(a, b))
+));
+impl(i8, LogicalNot(
+  (!): ((a) -> __yo_op_not(a))
+));
+impl(i8, BitNot(i8)(
+  (~): ((a) -> __yo_op_bit_complement(a))
+));
+impl(i8, BitAnd(i8)(
+  (&): ((a, b) -> __yo_op_bit_and(a, b))
+));
+impl(i8, BitOr(i8)(
+  (|): ((a, b) -> __yo_op_bit_or(a, b))
+));
+impl(i8, BitXor(i8)(
+  (^): ((a, b) -> __yo_op_bit_xor(a, b))
+));
+impl(i8, Eq(i8)(
+  (==) : ((a, b) -> __yo_op_eq(a, b)),
+  (!=) : ((a, b) -> __yo_op_neq(a, b))
+));
+impl(i8, Ord(i8)(
+  (<) : ((a, b) -> __yo_op_lt(a, b)),
+  (<=) : ((a, b) -> __yo_op_lte(a, b)),
+  (>) : ((a, b) -> __yo_op_gt(a, b)),
+  (>=) : ((a, b) -> __yo_op_gte(a, b))
+));
+impl(i8, Hash(
+  (hash): ((value) -> u64(value))
+));
+impl(i8, Clone(i8)(
+  clone: ((self) -> __yo_return_self(self))
+));
+impl(i8, ComptAdd(i8)(
+  (+) : (fn(compt(lhs): i8, compt(rhs): i8) -> compt(i8))(
+    __yo_i8_add(lhs, rhs)
+  )
+));
+impl(i8, ComptSub(i8)(
+  (-) : (fn(compt(lhs): i8, compt(rhs): i8) -> compt(i8))(
+    __yo_i8_sub(lhs, rhs)
+  )
+));
+impl(i8, ComptMul(i8)(
+  (*) : (fn(compt(lhs): i8, compt(rhs): i8) -> compt(i8))(
+    __yo_i8_mul(lhs, rhs)
+  )
+));
+impl(i8, ComptDiv(i8)(
+  (/) : (fn(compt(lhs): i8, compt(rhs): i8) -> compt(i8))(
+    __yo_i8_div(lhs, rhs)
+  )
+));
+impl(i8, ComptMod(i8)(
+  (%) : (fn(compt(lhs): i8, compt(rhs): i8) -> compt(i8))(
+    __yo_i8_mod(lhs, rhs)
+  )
+));
+impl(i8, ComptNegate(i8)(
+  (neg) : (fn(compt(self): i8) -> compt(i8))(
+    __yo_i8_neg(self)
+  )
+));
+impl(i8, ComptEq(i8)(
+  (==) : (fn(compt(lhs): i8, compt(rhs): i8) -> compt(bool))(
+    __yo_i8_eq(lhs, rhs)
+  ),
+  (!=) : (fn(compt(lhs): i8, compt(rhs): i8) -> compt(bool))(
+    __yo_i8_neq(lhs, rhs)
+  )
+));
+impl(i8, ComptOrd(i8)(
+  (<) : (fn(compt(lhs): i8, compt(rhs): i8) -> compt(bool))(
+    __yo_i8_lt(lhs, rhs)
+  ),
+  (<=) : (fn(compt(lhs): i8, compt(rhs): i8) -> compt(bool))(
+    __yo_i8_lte(lhs, rhs)
+  ),
+  (>) : (fn(compt(lhs): i8, compt(rhs): i8) -> compt(bool))(
+    __yo_i8_gt(lhs, rhs)
+  ),
+  (>=) : (fn(compt(lhs): i8, compt(rhs): i8) -> compt(bool))(
+    __yo_i8_gte(lhs, rhs)
+  )
+));
+impl(i8, {
+  (to_string) :: (fn(compt(self): i8) -> compt(compt_string))
+    __yo_i8_to_string(self)
+  ;
+  export to_string;
+});
+_i8 :: i8;
+export i8 : _i8;
+
+/// i16
+impl(i16, Send());
+impl(i16, Add(i16)(
+  (+): ((a, b) -> __yo_op_add(a, b))
+));
+impl(i16, Sub(i16)(
+  (-): ((a, b) -> __yo_op_sub(a, b))
+));
+impl(i16, Mul(i16)(
+  (*): ((a, b) -> __yo_op_mul(a, b))
+));
+impl(i16, Div(i16)(
+  (/): ((a, b) -> __yo_op_div(a, b))
+));
+impl(i16, Mod(i16)(
+  (%): ((a, b) -> __yo_op_mod(a, b))
+));
+impl(i16, Negate(i16)(
+  (neg): ((a) -> __yo_op_neg(a))
+));
+impl(i16, BitLeftShift(i16)(
+  (<<): ((a, b) -> __yo_op_bit_left_shift(a, b))
+));
+impl(i16, BitRightShift(i16)(
+  (>>): ((a, b) -> __yo_op_bit_right_shift(a, b))
+));
+impl(i16, LogicalNot(
+  (!): ((a) -> __yo_op_not(a))
+));
+impl(i16, BitNot(i16)(
+  (~): ((a) -> __yo_op_bit_complement(a))
+));
+impl(i16, BitAnd(i16)(
+  (&): ((a, b) -> __yo_op_bit_and(a, b))
+));
+impl(i16, BitOr(i16)(
+  (|): ((a, b) -> __yo_op_bit_or(a, b))
+));
+impl(i16, BitXor(i16)(
+  (^): ((a, b) -> __yo_op_bit_xor(a, b))
+));
+impl(i16, Eq(i16)(
+  (==) : ((a, b) -> __yo_op_eq(a, b)),
+  (!=) : ((a, b) -> __yo_op_neq(a, b))
+));
+impl(i16, Ord(i16)(
+  (<) : ((a, b) -> __yo_op_lt(a, b)),
+  (<=) : ((a, b) -> __yo_op_lte(a, b)),
+  (>) : ((a, b) -> __yo_op_gt(a, b)),
+  (>=) : ((a, b) -> __yo_op_gte(a, b))
+));
+impl(i16, Hash(
+  (hash): ((value) -> u64(value))
+));
+impl(i16, Clone(i16)(
+  clone: ((self) -> __yo_return_self(self))
+));
+impl(i16, ComptAdd(i16)(
+  (+) : (fn(compt(lhs): i16, compt(rhs): i16) -> compt(i16))(
+    __yo_i16_add(lhs, rhs)
+  )
+));
+impl(i16, ComptSub(i16)(
+  (-) : (fn(compt(lhs): i16, compt(rhs): i16) -> compt(i16))(
+    __yo_i16_sub(lhs, rhs)
+  )
+));
+impl(i16, ComptMul(i16)(
+  (*) : (fn(compt(lhs): i16, compt(rhs): i16) -> compt(i16))(
+    __yo_i16_mul(lhs, rhs)
+  )
+));
+impl(i16, ComptDiv(i16)(
+  (/) : (fn(compt(lhs): i16, compt(rhs): i16) -> compt(i16))(
+    __yo_i16_div(lhs, rhs)
+  )
+));
+impl(i16, ComptMod(i16)(
+  (%) : (fn(compt(lhs): i16, compt(rhs): i16) -> compt(i16))(
+    __yo_i16_mod(lhs, rhs)
+  )
+));
+impl(i16, ComptNegate(i16)(
+  (neg) : (fn(compt(self): i16) -> compt(i16))(
+    __yo_i16_neg(self)
+  )
+));
+impl(i16, ComptEq(i16)(
+  (==) : (fn(compt(lhs): i16, compt(rhs): i16) -> compt(bool))(
+    __yo_i16_eq(lhs, rhs)
+  ),
+  (!=) : (fn(compt(lhs): i16, compt(rhs): i16) -> compt(bool))(
+    __yo_i16_neq(lhs, rhs)
+  )
+));
+impl(i16, ComptOrd(i16)(
+  (<) : (fn(compt(lhs): i16, compt(rhs): i16) -> compt(bool))(
+    __yo_i16_lt(lhs, rhs)
+  ),
+  (<=) : (fn(compt(lhs): i16, compt(rhs): i16) -> compt(bool))(
+    __yo_i16_lte(lhs, rhs)
+  ),
+  (>) : (fn(compt(lhs): i16, compt(rhs): i16) -> compt(bool))(
+    __yo_i16_gt(lhs, rhs)
+  ),
+  (>=) : (fn(compt(lhs): i16, compt(rhs): i16) -> compt(bool))(
+    __yo_i16_gte(lhs, rhs)
+  )
+));
+impl(i16, {
+  (to_string) :: (fn(compt(self): i16) -> compt(compt_string))
+    __yo_i16_to_string(self)
+  ;
+  export to_string;
+});
+_i16 :: i16;
+export i16 : _i16;
+
+/// i32
+impl(i32, Send());
+impl(i32, Add(i32)(
+  (+): ((a, b) -> __yo_op_add(a, b))
+));
+impl(i32, Sub(i32)(
+  (-): ((a, b) -> __yo_op_sub(a, b))
+));
+impl(i32, Mul(i32)(
+  (*): ((a, b) -> __yo_op_mul(a, b))
+));
+impl(i32, Div(i32)(
+  (/): ((a, b) -> __yo_op_div(a, b))
+));
+impl(i32, Mod(i32)(
+  (%): ((a, b) -> __yo_op_mod(a, b))
+));
+impl(i32, Negate(i32)(
+  (neg): ((a) -> __yo_op_neg(a))
+));
+impl(i32, BitLeftShift(i32)(
+  (<<): ((a, b) -> __yo_op_bit_left_shift(a, b))
+));
+impl(i32, BitRightShift(i32)(
+  (>>): ((a, b) -> __yo_op_bit_right_shift(a, b))
+));
+impl(i32, LogicalNot(
+  (!): ((a) -> __yo_op_not(a))
+));
+impl(i32, BitNot(i32)(
+  (~): ((a) -> __yo_op_bit_complement(a))
+));
+impl(i32, BitAnd(i32)(
+  (&): ((a, b) -> __yo_op_bit_and(a, b))
+));
+impl(i32, BitOr(i32)(
+  (|): ((a, b) -> __yo_op_bit_or(a, b))
+));
+impl(i32, BitXor(i32)(
+  (^): ((a, b) -> __yo_op_bit_xor(a, b))
+));
+impl(i32, Eq(i32)(
+  (==) : ((a, b) -> __yo_op_eq(a, b)),
+  (!=) : ((a, b) -> __yo_op_neq(a, b))
+));
+impl(i32, Ord(i32)(
+  (<) : ((a, b) -> __yo_op_lt(a, b)),
+  (<=) : ((a, b) -> __yo_op_lte(a, b)),
+  (>) : ((a, b) -> __yo_op_gt(a, b)),
+  (>=) : ((a, b) -> __yo_op_gte(a, b))
+));
+impl(i32, Hash(
+  (hash): ((value) -> {
+    u32_value := u32(value);
+    u64(u32_value)
+  })
+));
+impl(i32, Clone(i32)(
+  clone: ((self) ->
+    __yo_return_self(self)
+  )
+));
+impl(i32, ComptAdd(i32)(
+  (+) : (fn(compt(lhs): i32, compt(rhs): i32) -> compt(i32))(
+    __yo_i32_add(lhs, rhs)
+  )
+));
+impl(i32, ComptSub(i32)(
+  (-) : (fn(compt(lhs): i32, compt(rhs): i32) -> compt(i32))(
+    __yo_i32_sub(lhs, rhs)
+  )
+));
+impl(i32, ComptMul(i32)(
+  (*) : (fn(compt(lhs): i32, compt(rhs): i32) -> compt(i32))(
+    __yo_i32_mul(lhs, rhs)
+  )
+));
+impl(i32, ComptDiv(i32)(
+  (/) : (fn(compt(lhs): i32, compt(rhs): i32) -> compt(i32))(
+    __yo_i32_div(lhs, rhs)
+  )
+));
+impl(i32, ComptMod(i32)(
+  (%) : (fn(compt(lhs): i32, compt(rhs): i32) -> compt(i32))(
+    __yo_i32_mod(lhs, rhs)
+  )
+));
+impl(i32, ComptNegate(i32)(
+  (neg) : (fn(compt(self): i32) -> compt(i32))(
+    __yo_i32_neg(self)
+  )
+));
+impl(i32, ComptEq(i32)(
+  (==) : (fn(compt(lhs): i32, compt(rhs): i32) -> compt(bool))(
+    __yo_i32_eq(lhs, rhs)
+  ),
+  (!=) : (fn(compt(lhs): i32, compt(rhs): i32) -> compt(bool))(
+    __yo_i32_neq(lhs, rhs)
+  )
+));
+impl(i32, ComptOrd(i32)(
+  (<) : (fn(compt(lhs): i32, compt(rhs): i32) -> compt(bool))(
+    __yo_i32_lt(lhs, rhs)
+  ),
+  (<=) : (fn(compt(lhs): i32, compt(rhs): i32) -> compt(bool))(
+    __yo_i32_lte(lhs, rhs)
+  ),
+  (>) : (fn(compt(lhs): i32, compt(rhs): i32) -> compt(bool))(
+    __yo_i32_gt(lhs, rhs)
+  ),
+  (>=) : (fn(compt(lhs): i32, compt(rhs): i32) -> compt(bool))(
+    __yo_i32_gte(lhs, rhs)
+  )
+));
+impl(i32, {
+  (to_string) :: (fn(compt(self): i32) -> compt(compt_string))
+    __yo_i32_to_string(self)
+  ;
+  export to_string;
+});
+_i32 :: i32;
+export i32 : _i32;
+
+/// i64
+impl(i64, Send());
+impl(i64, Add(i64)(
+  (+): ((a, b) -> __yo_op_add(a, b))
+));
+impl(i64, Sub(i64)(
+  (-): ((a, b) -> __yo_op_sub(a, b))
+));
+impl(i64, Mul(i64)(
+  (*): ((a, b) -> __yo_op_mul(a, b))
+));
+impl(i64, Div(i64)(
+  (/): ((a, b) -> __yo_op_div(a, b))
+));
+impl(i64, Mod(i64)(
+  (%): ((a, b) -> __yo_op_mod(a, b))
+));
+impl(i64, Negate(i64)(
+  (neg): ((a) -> __yo_op_neg(a))
+));
+impl(i64, BitLeftShift(i64)(
+  (<<): ((a, b) -> __yo_op_bit_left_shift(a, b))
+));
+impl(i64, BitRightShift(i64)(
+  (>>): ((a, b) -> __yo_op_bit_right_shift(a, b))
+));
+impl(i64, LogicalNot(
+  (!): ((a) -> __yo_op_not(a))
+));
+impl(i64, BitNot(i64)(
+  (~): ((a) -> __yo_op_bit_complement(a))
+));
+impl(i64, BitAnd(i64)(
+  (&): ((a, b) -> __yo_op_bit_and(a, b))
+));
+impl(i64, BitOr(i64)(
+  (|): ((a, b) -> __yo_op_bit_or(a, b))
+));
+impl(i64, BitXor(i64)(
+  (^): ((a, b) -> __yo_op_bit_xor(a, b))
+));
+impl(i64, Eq(i64)(
+  (==) : ((a, b) -> __yo_op_eq(a, b)),
+  (!=) : ((a, b) -> __yo_op_neq(a, b))
+));
+impl(i64, Ord(i64)(
+  (<) : ((a, b) -> __yo_op_lt(a, b)),
+  (<=) : ((a, b) -> __yo_op_lte(a, b)),
+  (>) : ((a, b) -> __yo_op_gt(a, b)),
+  (>=) : ((a, b) -> __yo_op_gte(a, b))
+));
+impl(i64, Hash(
+  (hash): ((value) -> u64(value))
+));
+impl(i64, Clone(i64)(
+  clone: ((self) -> __yo_return_self(self))
+));
+impl(i64, ComptAdd(i64)(
+  (+) : (fn(compt(lhs): i64, compt(rhs): i64) -> compt(i64))(
+    __yo_i64_add(lhs, rhs)
+  )
+));
+impl(i64, ComptSub(i64)(
+  (-) : (fn(compt(lhs): i64, compt(rhs): i64) -> compt(i64))(
+    __yo_i64_sub(lhs, rhs)
+  )
+));
+impl(i64, ComptMul(i64)(
+  (*) : (fn(compt(lhs): i64, compt(rhs): i64) -> compt(i64))(
+    __yo_i64_mul(lhs, rhs)
+  )
+));
+impl(i64, ComptDiv(i64)(
+  (/) : (fn(compt(lhs): i64, compt(rhs): i64) -> compt(i64))(
+    __yo_i64_div(lhs, rhs)
+  )
+));
+impl(i64, ComptMod(i64)(
+  (%) : (fn(compt(lhs): i64, compt(rhs): i64) -> compt(i64))(
+    __yo_i64_mod(lhs, rhs)
+  )
+));
+impl(i64, ComptNegate(i64)(
+  (neg) : (fn(compt(self): i64) -> compt(i64))(
+    __yo_i64_neg(self)
+  )
+));
+impl(i64, ComptEq(i64)(
+  (==) : (fn(compt(lhs): i64, compt(rhs): i64) -> compt(bool))(
+    __yo_i64_eq(lhs, rhs)
+  ),
+  (!=) : (fn(compt(lhs): i64, compt(rhs): i64) -> compt(bool))(
+    __yo_i64_neq(lhs, rhs)
+  )
+));
+impl(i64, ComptOrd(i64)(
+  (<) : (fn(compt(lhs): i64, compt(rhs): i64) -> compt(bool))(
+    __yo_i64_lt(lhs, rhs)
+  ),
+  (<=) : (fn(compt(lhs): i64, compt(rhs): i64) -> compt(bool))(
+    __yo_i64_lte(lhs, rhs)
+  ),
+  (>) : (fn(compt(lhs): i64, compt(rhs): i64) -> compt(bool))(
+    __yo_i64_gt(lhs, rhs)
+  ),
+  (>=) : (fn(compt(lhs): i64, compt(rhs): i64) -> compt(bool))(
+    __yo_i64_gte(lhs, rhs)
+  )
+));
+impl(i64, {
+  (to_string) :: (fn(compt(self): i64) -> compt(compt_string))
+    __yo_i64_to_string(self)
+  ;
+  export to_string;
+});
+_i64 :: i64;
+export i64 : _i64;
+
+/// u8
+impl(u8, Send());
+impl(u8, Add(u8)(
+  (+): ((a, b) -> __yo_op_add(a, b))
+));
+impl(u8, Sub(u8)(
+  (-): ((a, b) -> __yo_op_sub(a, b))
+));
+impl(u8, Mul(u8)(
+  (*): ((a, b) -> __yo_op_mul(a, b))
+));
+impl(u8, Div(u8)(
+  (/): ((a, b) -> __yo_op_div(a, b))
+));
+impl(u8, Mod(u8)(
+  (%): ((a, b) -> __yo_op_mod(a, b))
+));
+impl(u8, Negate(u8)(
+  (neg): ((a) -> __yo_op_neg(a))
+));
+impl(u8, BitLeftShift(u8)(
+  (<<): ((a, b) -> __yo_op_bit_left_shift(a, b))
+));
+impl(u8, BitRightShift(u8)(
+  (>>): ((a, b) -> __yo_op_bit_right_shift(a, b))
+));
+impl(u8, LogicalNot(
+  (!): ((a) -> __yo_op_not(a))
+));
+impl(u8, BitNot(u8)(
+  (~): ((a) -> __yo_op_bit_complement(a))
+));
+impl(u8, BitAnd(u8)(
+  (&): ((a, b) -> __yo_op_bit_and(a, b))
+));
+impl(u8, BitOr(u8)(
+  (|): ((a, b) -> __yo_op_bit_or(a, b))
+));
+impl(u8, BitXor(u8)(
+  (^): ((a, b) -> __yo_op_bit_xor(a, b))
+));
+impl(u8, Eq(u8)(
+  (==) : ((a, b) -> __yo_op_eq(a, b)),
+  (!=) : ((a, b) -> __yo_op_neq(a, b))
+));
+impl(u8, Ord(u8)(
+  (<) : ((a, b) -> __yo_op_lt(a, b)),
+  (<=) : ((a, b) -> __yo_op_lte(a, b)),
+  (>) : ((a, b) -> __yo_op_gt(a, b)),
+  (>=) : ((a, b) -> __yo_op_gte(a, b))
+));
+impl(u8, Hash(
+  (hash): ((value) -> u64(value))
+));
+impl(u8, Clone(u8)(
+  clone: ((self) -> __yo_return_self(self))
+));
+impl(u8, ComptAdd(u8)(
+  (+) : (fn(compt(lhs): u8, compt(rhs): u8) -> compt(u8))(
+    __yo_u8_add(lhs, rhs)
+  )
+));
+impl(u8, ComptSub(u8)(
+  (-) : (fn(compt(lhs): u8, compt(rhs): u8) -> compt(u8))(
+    __yo_u8_sub(lhs, rhs)
+  )
+));
+impl(u8, ComptMul(u8)(
+  (*) : (fn(compt(lhs): u8, compt(rhs): u8) -> compt(u8))(
+    __yo_u8_mul(lhs, rhs)
+  )
+));
+impl(u8, ComptDiv(u8)(
+  (/) : (fn(compt(lhs): u8, compt(rhs): u8) -> compt(u8))(
+    __yo_u8_div(lhs, rhs)
+  )
+));
+impl(u8, ComptMod(u8)(
+  (%) : (fn(compt(lhs): u8, compt(rhs): u8) -> compt(u8))(
+    __yo_u8_mod(lhs, rhs)
+  )
+));
+impl(u8, ComptEq(u8)(
+  (==) : (fn(compt(lhs): u8, compt(rhs): u8) -> compt(bool))(
+    __yo_u8_eq(lhs, rhs)
+  ),
+  (!=) : (fn(compt(lhs): u8, compt(rhs): u8) -> compt(bool))(
+    __yo_u8_neq(lhs, rhs)
+  )
+));
+impl(u8, ComptOrd(u8)(
+  (<) : (fn(compt(lhs): u8, compt(rhs): u8) -> compt(bool))(
+    __yo_u8_lt(lhs, rhs)
+  ),
+  (<=) : (fn(compt(lhs): u8, compt(rhs): u8) -> compt(bool))(
+    __yo_u8_lte(lhs, rhs)
+  ),
+  (>) : (fn(compt(lhs): u8, compt(rhs): u8) -> compt(bool))(
+    __yo_u8_gt(lhs, rhs)
+  ),
+  (>=) : (fn(compt(lhs): u8, compt(rhs): u8) -> compt(bool))(
+    __yo_u8_gte(lhs, rhs)
+  )
+));
+impl(u8, {
+  (to_string) :: (fn(compt(self): u8) -> compt(compt_string))
+    __yo_u8_to_string(self)
+  ;
+  export to_string;
+});
+_u8 :: u8;
+export u8 : _u8;
+
+/// u16
+impl(u16, Send());
+impl(u16, Add(u16)(
+  (+): ((a, b) -> __yo_op_add(a, b))
+));
+impl(u16, Sub(u16)(
+  (-): ((a, b) -> __yo_op_sub(a, b))
+));
+impl(u16, Mul(u16)(
+  (*): ((a, b) -> __yo_op_mul(a, b))
+));
+impl(u16, Div(u16)(
+  (/): ((a, b) -> __yo_op_div(a, b))
+));
+impl(u16, Mod(u16)(
+  (%): ((a, b) -> __yo_op_mod(a, b))
+));
+impl(u16, Negate(u16)(
+  (neg): ((a) -> __yo_op_neg(a))
+));
+impl(u16, BitLeftShift(u16)(
+  (<<): ((a, b) -> __yo_op_bit_left_shift(a, b))
+));
+impl(u16, BitRightShift(u16)(
+  (>>): ((a, b) -> __yo_op_bit_right_shift(a, b))
+));
+impl(u16, LogicalNot(
+  (!): ((a) -> __yo_op_not(a))
+));
+impl(u16, BitNot(u16)(
+  (~): ((a) -> __yo_op_bit_complement(a))
+));
+impl(u16, BitAnd(u16)(
+  (&): ((a, b) -> __yo_op_bit_and(a, b))
+));
+impl(u16, BitOr(u16)(
+  (|): ((a, b) -> __yo_op_bit_or(a, b))
+));
+impl(u16, BitXor(u16)(
+  (^): ((a, b) -> __yo_op_bit_xor(a, b))
+));
+impl(u16, Eq(u16)(
+  (==) : ((a, b) -> __yo_op_eq(a, b)),
+  (!=) : ((a, b) -> __yo_op_neq(a, b))
+));
+impl(u16, Ord(u16)(
+  (<) : ((a, b) -> __yo_op_lt(a, b)),
+  (<=) : ((a, b) -> __yo_op_lte(a, b)),
+  (>) : ((a, b) -> __yo_op_gt(a, b)),
+  (>=) : ((a, b) -> __yo_op_gte(a, b))
+));
+impl(u16, Hash(
+  (hash): ((value) -> u64(value))
+));
+impl(u16, Clone(u16)(
+  clone: ((self) -> __yo_return_self(self))
+));
+impl(u16, ComptAdd(u16)(
+  (+) : (fn(compt(lhs): u16, compt(rhs): u16) -> compt(u16))(
+    __yo_u16_add(lhs, rhs)
+  )
+));
+impl(u16, ComptSub(u16)(
+  (-) : (fn(compt(lhs): u16, compt(rhs): u16) -> compt(u16))(
+    __yo_u16_sub(lhs, rhs)
+  )
+));
+impl(u16, ComptMul(u16)(
+  (*) : (fn(compt(lhs): u16, compt(rhs): u16) -> compt(u16))(
+    __yo_u16_mul(lhs, rhs)
+  )
+));
+impl(u16, ComptDiv(u16)(
+  (/) : (fn(compt(lhs): u16, compt(rhs): u16) -> compt(u16))(
+    __yo_u16_div(lhs, rhs)
+  )
+));
+impl(u16, ComptMod(u16)(
+  (%) : (fn(compt(lhs): u16, compt(rhs): u16) -> compt(u16))(
+    __yo_u16_mod(lhs, rhs)
+  )
+));
+impl(u16, ComptEq(u16)(
+  (==) : (fn(compt(lhs): u16, compt(rhs): u16) -> compt(bool))(
+    __yo_u16_eq(lhs, rhs)
+  ),
+  (!=) : (fn(compt(lhs): u16, compt(rhs): u16) -> compt(bool))(
+    __yo_u16_neq(lhs, rhs)
+  )
+));
+impl(u16, ComptOrd(u16)(
+  (<) : (fn(compt(lhs): u16, compt(rhs): u16) -> compt(bool))(
+    __yo_u16_lt(lhs, rhs)
+  ),
+  (<=) : (fn(compt(lhs): u16, compt(rhs): u16) -> compt(bool))(
+    __yo_u16_lte(lhs, rhs)
+  ),
+  (>) : (fn(compt(lhs): u16, compt(rhs): u16) -> compt(bool))(
+    __yo_u16_gt(lhs, rhs)
+  ),
+  (>=) : (fn(compt(lhs): u16, compt(rhs): u16) -> compt(bool))(
+    __yo_u16_gte(lhs, rhs)
+  )
+));
+impl(u16, {
+  (to_string) :: (fn(compt(self): u16) -> compt(compt_string))
+    __yo_u16_to_string(self)
+  ;
+  export to_string;
+});
+_u16 :: u16;
+export u16 : _u16;
+
+/// u32
+impl(u32, Send());
+impl(u32, Add(u32)(
+  (+): ((a, b) -> __yo_op_add(a, b))
+));
+impl(u32, Sub(u32)(
+  (-): ((a, b) -> __yo_op_sub(a, b))
+));
+impl(u32, Mul(u32)(
+  (*): ((a, b) -> __yo_op_mul(a, b))
+));
+impl(u32, Div(u32)(
+  (/): ((a, b) -> __yo_op_div(a, b))
+));
+impl(u32, Mod(u32)(
+  (%): ((a, b) -> __yo_op_mod(a, b))
+));
+impl(u32, Negate(u32)(
+  (neg): ((a) -> __yo_op_neg(a))
+));
+impl(u32, BitLeftShift(u32)(
+  (<<): ((a, b) -> __yo_op_bit_left_shift(a, b))
+));
+impl(u32, BitRightShift(u32)(
+  (>>): ((a, b) -> __yo_op_bit_right_shift(a, b))
+));
+impl(u32, LogicalNot(
+  (!): ((a) -> __yo_op_not(a))
+));
+impl(u32, BitNot(u32)(
+  (~): ((a) -> __yo_op_bit_complement(a))
+));
+impl(u32, BitAnd(u32)(
+  (&): ((a, b) -> __yo_op_bit_and(a, b))
+));
+impl(u32, BitOr(u32)(
+  (|): ((a, b) -> __yo_op_bit_or(a, b))
+));
+impl(u32, BitXor(u32)(
+  (^): ((a, b) -> __yo_op_bit_xor(a, b))
+));
+impl(u32, Eq(u32)(
+  (==) : ((a, b) -> __yo_op_eq(a, b)),
+  (!=) : ((a, b) -> __yo_op_neq(a, b))
+));
+impl(u32, Ord(u32)(
+  (<) : ((a, b) -> __yo_op_lt(a, b)),
+  (<=) : ((a, b) -> __yo_op_lte(a, b)),
+  (>) : ((a, b) -> __yo_op_gt(a, b)),
+  (>=) : ((a, b) -> __yo_op_gte(a, b))
+));
+impl(u32, Hash(
+  (hash): ((value) -> u64(value))
+));
+impl(u32, Clone(u32)(
+  clone: ((self) -> __yo_return_self(self))
+));
+impl(u32, ComptAdd(u32)(
+  (+) : (fn(compt(lhs): u32, compt(rhs): u32) -> compt(u32))(
+    __yo_u32_add(lhs, rhs)
+  )
+));
+impl(u32, ComptSub(u32)(
+  (-) : (fn(compt(lhs): u32, compt(rhs): u32) -> compt(u32))(
+    __yo_u32_sub(lhs, rhs)
+  )
+));
+impl(u32, ComptMul(u32)(
+  (*) : (fn(compt(lhs): u32, compt(rhs): u32) -> compt(u32))(
+    __yo_u32_mul(lhs, rhs)
+  )
+));
+impl(u32, ComptDiv(u32)(
+  (/) : (fn(compt(lhs): u32, compt(rhs): u32) -> compt(u32))(
+    __yo_u32_div(lhs, rhs)
+  )
+));
+impl(u32, ComptMod(u32)(
+  (%) : (fn(compt(lhs): u32, compt(rhs): u32) -> compt(u32))(
+    __yo_u32_mod(lhs, rhs)
+  )
+));
+impl(u32, ComptEq(u32)(
+  (==) : (fn(compt(lhs): u32, compt(rhs): u32) -> compt(bool))(
+    __yo_u32_eq(lhs, rhs)
+  ),
+  (!=) : (fn(compt(lhs): u32, compt(rhs): u32) -> compt(bool))(
+    __yo_u32_neq(lhs, rhs)
+  )
+));
+impl(u32, ComptOrd(u32)(
+  (<) : (fn(compt(lhs): u32, compt(rhs): u32) -> compt(bool))(
+    __yo_u32_lt(lhs, rhs)
+  ),
+  (<=) : (fn(compt(lhs): u32, compt(rhs): u32) -> compt(bool))(
+    __yo_u32_lte(lhs, rhs)
+  ),
+  (>) : (fn(compt(lhs): u32, compt(rhs): u32) -> compt(bool))(
+    __yo_u32_gt(lhs, rhs)
+  ),
+  (>=) : (fn(compt(lhs): u32, compt(rhs): u32) -> compt(bool))(
+    __yo_u32_gte(lhs, rhs)
+  )
+));
+impl(u32, {
+  (to_string) :: (fn(compt(self): u32) -> compt(compt_string))
+    __yo_u32_to_string(self)
+  ;
+  export to_string;
+});
+_u32 :: u32;
+export u32 : _u32;
+
+/// u64
+impl(u64, Send());
+impl(u64, Add(u64)(
+  (+): ((a, b) -> __yo_op_add(a, b))
+));
+impl(u64, Sub(u64)(
+  (-): ((a, b) -> __yo_op_sub(a, b))
+));
+impl(u64, Mul(u64)(
+  (*): ((a, b) -> __yo_op_mul(a, b))
+));
+impl(u64, Div(u64)(
+  (/): ((a, b) -> __yo_op_div(a, b))
+));
+impl(u64, Mod(u64)(
+  (%): ((a, b) -> __yo_op_mod(a, b))
+));
+impl(u64, Negate(u64)(
+  (neg): ((a) -> __yo_op_neg(a))
+));
+impl(u64, BitLeftShift(u64)(
+  (<<): ((a, b) -> __yo_op_bit_left_shift(a, b))
+));
+impl(u64, BitRightShift(u64)(
+  (>>): ((a, b) -> __yo_op_bit_right_shift(a, b))
+));
+impl(u64, LogicalNot(
+  (!): ((a) -> __yo_op_not(a))
+));
+impl(u64, BitNot(u64)(
+  (~): ((a) -> __yo_op_bit_complement(a))
+));
+impl(u64, BitAnd(u64)(
+  (&): ((a, b) -> __yo_op_bit_and(a, b))
+));
+impl(u64, BitOr(u64)(
+  (|): ((a, b) -> __yo_op_bit_or(a, b))
+));
+impl(u64, BitXor(u64)(
+  (^): ((a, b) -> __yo_op_bit_xor(a, b))
+));
+impl(u64, Eq(u64)(
+  (==) : ((a, b) -> __yo_op_eq(a, b)),
+  (!=) : ((a, b) -> __yo_op_neq(a, b))
+));
+impl(u64, Ord(u64)(
+  (<) : ((a, b) -> __yo_op_lt(a, b)),
+  (<=) : ((a, b) -> __yo_op_lte(a, b)),
+  (>) : ((a, b) -> __yo_op_gt(a, b)),
+  (>=) : ((a, b) -> __yo_op_gte(a, b))
+));
+impl(u64, Hash(
+  (hash): ((value) -> value)
+));
+impl(u64, Clone(u64)(
+  clone: ((self) -> __yo_return_self(self))
+));
+impl(u64, ComptAdd(u64)(
+  (+) : (fn(compt(lhs): u64, compt(rhs): u64) -> compt(u64))(
+    __yo_u64_add(lhs, rhs)
+  )
+));
+impl(u64, ComptSub(u64)(
+  (-) : (fn(compt(lhs): u64, compt(rhs): u64) -> compt(u64))(
+    __yo_u64_sub(lhs, rhs)
+  )
+));
+impl(u64, ComptMul(u64)(
+  (*) : (fn(compt(lhs): u64, compt(rhs): u64) -> compt(u64))(
+    __yo_u64_mul(lhs, rhs)
+  )
+));
+impl(u64, ComptDiv(u64)(
+  (/) : (fn(compt(lhs): u64, compt(rhs): u64) -> compt(u64))(
+    __yo_u64_div(lhs, rhs)
+  )
+));
+impl(u64, ComptMod(u64)(
+  (%) : (fn(compt(lhs): u64, compt(rhs): u64) -> compt(u64))(
+    __yo_u64_mod(lhs, rhs)
+  )
+));
+impl(u64, ComptEq(u64)(
+  (==) : (fn(compt(lhs): u64, compt(rhs): u64) -> compt(bool))(
+    __yo_u64_eq(lhs, rhs)
+  ),
+  (!=) : (fn(compt(lhs): u64, compt(rhs): u64) -> compt(bool))(
+    __yo_u64_neq(lhs, rhs)
+  )
+));
+impl(u64, ComptOrd(u64)(
+  (<) : (fn(compt(lhs): u64, compt(rhs): u64) -> compt(bool))(
+    __yo_u64_lt(lhs, rhs)
+  ),
+  (<=) : (fn(compt(lhs): u64, compt(rhs): u64) -> compt(bool))(
+    __yo_u64_lte(lhs, rhs)
+  ),
+  (>) : (fn(compt(lhs): u64, compt(rhs): u64) -> compt(bool))(
+    __yo_u64_gt(lhs, rhs)
+  ),
+  (>=) : (fn(compt(lhs): u64, compt(rhs): u64) -> compt(bool))(
+    __yo_u64_gte(lhs, rhs)
+  )
+));
+impl(u64, {
+  (to_string) :: (fn(compt(self): u64) -> compt(compt_string))
+    __yo_u64_to_string(self)
+  ;
+  export to_string;
+});
+_u64 :: u64;
+export u64 : _u64;
+
+/// f32
+impl(f32, Send());
+impl(f32, Add(f32)(
+  (+): ((a, b) -> __yo_op_add(a, b))
+));
+impl(f32, Sub(f32)(
+  (-): ((a, b) -> __yo_op_sub(a, b))
+));
+impl(f32, Mul(f32)(
+  (*): ((a, b) -> __yo_op_mul(a, b))
+));
+impl(f32, Div(f32)(
+  (/): ((a, b) -> __yo_op_div(a, b))
+));
+impl(f32, Mod(f32)(
+  (%): ((a, b) -> __yo_op_mod(a, b))
+));
+impl(f32, Negate(f32)(
+  (neg): ((a) -> __yo_op_neg(a))
+));
+impl(f32, LogicalNot(
+  (!): ((a) -> __yo_op_not(a))
+));
+impl(f32, BitNot(f32)(
+  (~): ((a) -> __yo_op_bit_complement(a))
+));
+impl(f32, BitAnd(f32)(
+  (&): ((a, b) -> __yo_op_bit_and(a, b))
+));
+impl(f32, BitOr(f32)(
+  (|): ((a, b) -> __yo_op_bit_or(a, b))
+));
+impl(f32, BitXor(f32)(
+  (^): ((a, b) -> __yo_op_bit_xor(a, b))
+));
+impl(f32, Eq(f32)(
+  (==) : ((a, b) -> __yo_op_eq(a, b)),
+  (!=) : ((a, b) -> __yo_op_neq(a, b))
+));
+impl(f32, Ord(f32)(
+  (<) : ((a, b) -> __yo_op_lt(a, b)),
+  (<=) : ((a, b) -> __yo_op_lte(a, b)),
+  (>) : ((a, b) -> __yo_op_gt(a, b)),
+  (>=) : ((a, b) -> __yo_op_gte(a, b))
+));
+impl(f32, Hash(
+  (hash): ((value) -> u64(i32(value)))
+));
+impl(f32, Clone(f32)(
+  clone: ((self) -> __yo_return_self(self))
+));
+impl(f32, ComptAdd(f32)(
+  (+) : (fn(compt(lhs): f32, compt(rhs): f32) -> compt(f32))(
+    __yo_f32_add(lhs, rhs)
+  )
+));
+impl(f32, ComptSub(f32)(
+  (-) : (fn(compt(lhs): f32, compt(rhs): f32) -> compt(f32))(
+    __yo_f32_sub(lhs, rhs)
+  )
+));
+impl(f32, ComptMul(f32)(
+  (*) : (fn(compt(lhs): f32, compt(rhs): f32) -> compt(f32))(
+    __yo_f32_mul(lhs, rhs)
+  )
+));
+impl(f32, ComptDiv(f32)(
+  (/) : (fn(compt(lhs): f32, compt(rhs): f32) -> compt(f32))(
+    __yo_f32_div(lhs, rhs)
+  )
+));
+impl(f32, ComptNegate(f32)(
+  (neg) : (fn(compt(self): f32) -> compt(f32))(
+    __yo_f32_neg(self)
+  )
+));
+impl(f32, ComptEq(f32)(
+  (==) : (fn(compt(lhs): f32, compt(rhs): f32) -> compt(bool))(
+    __yo_f32_eq(lhs, rhs)
+  ),
+  (!=) : (fn(compt(lhs): f32, compt(rhs): f32) -> compt(bool))(
+    __yo_f32_neq(lhs, rhs)
+  )
+));
+impl(f32, ComptOrd(f32)(
+  (<) : (fn(compt(lhs): f32, compt(rhs): f32) -> compt(bool))(
+    __yo_f32_lt(lhs, rhs)
+  ),
+  (<=) : (fn(compt(lhs): f32, compt(rhs): f32) -> compt(bool))(
+    __yo_f32_lte(lhs, rhs)
+  ),
+  (>) : (fn(compt(lhs): f32, compt(rhs): f32) -> compt(bool))(
+    __yo_f32_gt(lhs, rhs)
+  ),
+  (>=) : (fn(compt(lhs): f32, compt(rhs): f32) -> compt(bool))(
+    __yo_f32_gte(lhs, rhs)
+  )
+));
+impl(f32, { 
+  (to_string) :: (fn(compt(self): f32) -> compt(compt_string))
+    __yo_f32_to_string(self)
+  ; 
+  export to_string; 
+});
+_f32 :: f32;
+export f32 : _f32;
+
+/// f64
+impl(f64, Send());
+impl(f64, Add(f64)(
+  (+): ((a, b) -> __yo_op_add(a, b))
+));
+impl(f64, Sub(f64)(
+  (-): ((a, b) -> __yo_op_sub(a, b))
+));
+impl(f64, Mul(f64)(
+  (*): ((a, b) -> __yo_op_mul(a, b))
+));
+impl(f64, Div(f64)(
+  (/): ((a, b) -> __yo_op_div(a, b))
+));
+impl(f64, Mod(f64)(
+  (%): ((a, b) -> __yo_op_mod(a, b))
+));
+impl(f64, Negate(f64)(
+  (neg): ((a) -> __yo_op_neg(a))
+));
+impl(f64, LogicalNot(
+  (!): ((a) -> __yo_op_not(a))
+));
+impl(f64, BitNot(f64)(
+  (~): ((a) -> __yo_op_bit_complement(a))
+));
+impl(f64, BitAnd(f64)(
+  (&): ((a, b) -> __yo_op_bit_and(a, b))
+));
+impl(f64, BitOr(f64)(
+  (|): ((a, b) -> __yo_op_bit_or(a, b))
+));
+impl(f64, BitXor(f64)(
+  (^): ((a, b) -> __yo_op_bit_xor(a, b))
+));
+impl(f64, Eq(f64)(
+  (==) : ((a, b) -> __yo_op_eq(a, b)),
+  (!=) : ((a, b) -> __yo_op_neq(a, b))
+));
+impl(f64, Ord(f64)(
+  (<) : ((a, b) -> __yo_op_lt(a, b)),
+  (<=) : ((a, b) -> __yo_op_lte(a, b)),
+  (>) : ((a, b) -> __yo_op_gt(a, b)),
+  (>=) : ((a, b) -> __yo_op_gte(a, b))
+));
+impl(f64, Hash(
+  (hash): ((value) -> u64(i64(value)))
+));
+impl(f64, Clone(f64)(
+  clone: ((self) -> __yo_return_self(self))
+));
+impl(f64, ComptAdd(f64)(
+  (+) : (fn(compt(lhs): f64, compt(rhs): f64) -> compt(f64))(
+    __yo_f64_add(lhs, rhs)
+  )
+));
+impl(f64, ComptSub(f64)(
+  (-) : (fn(compt(lhs): f64, compt(rhs): f64) -> compt(f64))(
+    __yo_f64_sub(lhs, rhs)
+  )
+));
+impl(f64, ComptMul(f64)(
+  (*) : (fn(compt(lhs): f64, compt(rhs): f64) -> compt(f64))(
+    __yo_f64_mul(lhs, rhs)
+  )
+));
+impl(f64, ComptDiv(f64)(
+  (/) : (fn(compt(lhs): f64, compt(rhs): f64) -> compt(f64))(
+    __yo_f64_div(lhs, rhs)
+  )
+));
+impl(f64, ComptNegate(f64)(
+  (neg) : (fn(compt(self): f64) -> compt(f64))(
+    __yo_f64_neg(self)
+  )
+));
+impl(f64, ComptEq(f64)(
+  (==) : (fn(compt(lhs): f64, compt(rhs): f64) -> compt(bool))(
+    __yo_f64_eq(lhs, rhs)
+  ),
+  (!=) : (fn(compt(lhs): f64, compt(rhs): f64) -> compt(bool))(
+    __yo_f64_neq(lhs, rhs)
+  )
+));
+impl(f64, ComptOrd(f64)(
+  (<) : (fn(compt(lhs): f64, compt(rhs): f64) -> compt(bool))(
+    __yo_f64_lt(lhs, rhs)
+  ),
+  (<=) : (fn(compt(lhs): f64, compt(rhs): f64) -> compt(bool))(
+    __yo_f64_lte(lhs, rhs)
+  ),
+  (>) : (fn(compt(lhs): f64, compt(rhs): f64) -> compt(bool))(
+    __yo_f64_gt(lhs, rhs)
+  ),
+  (>=) : (fn(compt(lhs): f64, compt(rhs): f64) -> compt(bool))(
+    __yo_f64_gte(lhs, rhs)
+  )
+));
+impl(f64, { 
+  (to_string) :: (fn(compt(self): f64) -> compt(compt_string))
+    __yo_f64_to_string(self)
+  ; 
+  export to_string;
+});
+_f64 :: f64;
+export f64 : _f64;
+
+/// isize
+impl(isize, Send());
+impl(isize, Add(isize)(
+  (+): ((a, b) -> __yo_op_add(a, b))
+));
+impl(isize, Sub(isize)(
+  (-): ((a, b) -> __yo_op_sub(a, b))
+));
+impl(isize, Mul(isize)(
+  (*): ((a, b) -> __yo_op_mul(a, b))
+));
+impl(isize, Div(isize)(
+  (/): ((a, b) -> __yo_op_div(a, b))
+));
+impl(isize, Mod(isize)(
+  (%): ((a, b) -> __yo_op_mod(a, b))
+));
+impl(isize, Negate(isize)(
+  (neg): ((a) -> __yo_op_neg(a))
+));
+impl(isize, BitLeftShift(isize)(
+  (<<): ((a, b) -> __yo_op_bit_left_shift(a, b))
+));
+impl(isize, BitRightShift(isize)(
+  (>>): ((a, b) -> __yo_op_bit_right_shift(a, b))
+));
+impl(isize, LogicalNot(
+  (!): ((a) -> __yo_op_not(a))
+));
+impl(isize, BitNot(isize)(
+  (~): ((a) -> __yo_op_bit_complement(a))
+));
+impl(isize, BitAnd(isize)(
+  (&): ((a, b) -> __yo_op_bit_and(a, b))
+));
+impl(isize, BitOr(isize)(
+  (|): ((a, b) -> __yo_op_bit_or(a, b))
+));
+impl(isize, BitXor(isize)(
+  (^): ((a, b) -> __yo_op_bit_xor(a, b))
+));
+impl(isize, Eq(isize)(
+  (==) : ((a, b) -> __yo_op_eq(a, b)),
+  (!=) : ((a, b) -> __yo_op_neq(a, b))
+));
+impl(isize, Ord(isize)(
+  (<) : ((a, b) -> __yo_op_lt(a, b)),
+  (<=) : ((a, b) -> __yo_op_lte(a, b)),
+  (>) : ((a, b) -> __yo_op_gt(a, b)),
+  (>=) : ((a, b) -> __yo_op_gte(a, b))
+));
+impl(isize, Hash(
+  (hash): ((value) -> u64(value))
+));
+impl(isize, Clone(isize)(
+  clone: ((self) -> __yo_return_self(self))
+));
+impl(isize, ComptAdd(isize)(
+  (+) : (fn(compt(lhs): isize, compt(rhs): isize) -> compt(isize))(
+    __yo_isize_add(lhs, rhs)
+  )
+));
+impl(isize, ComptSub(isize)(
+  (-) : (fn(compt(lhs): isize, compt(rhs): isize) -> compt(isize))(
+    __yo_isize_sub(lhs, rhs)
+  )
+));
+impl(isize, ComptMul(isize)(
+  (*) : (fn(compt(lhs): isize, compt(rhs): isize) -> compt(isize))(
+    __yo_isize_mul(lhs, rhs)
+  )
+));
+impl(isize, ComptDiv(isize)(
+  (/) : (fn(compt(lhs): isize, compt(rhs): isize) -> compt(isize))(
+    __yo_isize_div(lhs, rhs)
+  )
+));
+impl(isize, ComptMod(isize)(
+  (%) : (fn(compt(lhs): isize, compt(rhs): isize) -> compt(isize))(
+    __yo_isize_mod(lhs, rhs)
+  )
+));
+impl(isize, ComptNegate(isize)(
+  (neg) : (fn(compt(self): isize) -> compt(isize))(
+    __yo_isize_neg(self)
+  )
+));
+impl(isize, ComptEq(isize)(
+  (==) : (fn(compt(lhs): isize, compt(rhs): isize) -> compt(bool))(
+    __yo_isize_eq(lhs, rhs)
+  ),
+  (!=) : (fn(compt(lhs): isize, compt(rhs): isize) -> compt(bool))(
+    __yo_isize_neq(lhs, rhs)
+  )
+));
+impl(isize, ComptOrd(isize)(
+  (<) : (fn(compt(lhs): isize, compt(rhs): isize) -> compt(bool))(
+    __yo_isize_lt(lhs, rhs)
+  ),
+  (<=) : (fn(compt(lhs): isize, compt(rhs): isize) -> compt(bool))(
+    __yo_isize_lte(lhs, rhs)
+  ),
+  (>) : (fn(compt(lhs): isize, compt(rhs): isize) -> compt(bool))(
+    __yo_isize_gt(lhs, rhs)
+  ),
+  (>=) : (fn(compt(lhs): isize, compt(rhs): isize) -> compt(bool))(
+    __yo_isize_gte(lhs, rhs)
+  )
+));
+impl(isize, {
+  (to_string) :: (fn(compt(self): isize) -> compt(compt_string))
+    __yo_isize_to_string(self)
+  ; 
+  export to_string;
+});
+_isize :: isize;
+export isize : _isize;
+
+/// usize
+impl(usize, Send());
+impl(usize, Add(usize)(
+  (+): ((a, b) -> __yo_op_add(a, b))
+));
+impl(usize, Sub(usize)(
+  (-): ((a, b) -> __yo_op_sub(a, b))
+));
+impl(usize, Mul(usize)(
+  (*): ((a, b) -> __yo_op_mul(a, b))
+));
+impl(usize, Div(usize)(
+  (/): ((a, b) -> __yo_op_div(a, b))
+));
+impl(usize, Mod(usize)(
+  (%): ((a, b) -> __yo_op_mod(a, b))
+));
+impl(usize, Negate(usize)(
+  (neg): ((a) -> __yo_op_neg(a))
+));
+impl(usize, BitLeftShift(usize)(
+  (<<): ((a, b) -> __yo_op_bit_left_shift(a, b))
+));
+impl(usize, BitRightShift(usize)(
+  (>>): ((a, b) -> __yo_op_bit_right_shift(a, b))
+));
+impl(usize, LogicalNot(
+  (!): ((a) -> __yo_op_not(a))
+));
+impl(usize, BitNot(usize)(
+  (~): ((a) -> __yo_op_bit_complement(a))
+));
+impl(usize, BitAnd(usize)(
+  (&): ((a, b) -> __yo_op_bit_and(a, b))
+));
+impl(usize, BitOr(usize)(
+  (|): ((a, b) -> __yo_op_bit_or(a, b))
+));
+impl(usize, BitXor(usize)(
+  (^): ((a, b) -> __yo_op_bit_xor(a, b))
+));
+impl(usize, Eq(usize)(
+  (==) : ((a, b) -> __yo_op_eq(a, b)),
+  (!=) : ((a, b) -> __yo_op_neq(a, b))
+));
+impl(usize, Ord(usize)(
+  (<) : ((a, b) -> __yo_op_lt(a, b)),
+  (<=) : ((a, b) -> __yo_op_lte(a, b)),
+  (>) : ((a, b) -> __yo_op_gt(a, b)),
+  (>=) : ((a, b) -> __yo_op_gte(a, b))
+));
+impl(usize, Hash(
+  (hash): ((value) -> u64(value))
+));
+impl(usize, Clone(usize)(
+  clone: ((self) -> __yo_return_self(self))
+));
+impl(usize, ComptAdd(usize)(
+  (+) : (fn(compt(lhs): usize, compt(rhs): usize) -> compt(usize))(
+    __yo_usize_add(lhs, rhs)
+  )
+));
+impl(usize, ComptSub(usize)(
+  (-) : (fn(compt(lhs): usize, compt(rhs): usize) -> compt(usize))(
+    __yo_usize_sub(lhs, rhs)
+  )
+));
+impl(usize, ComptMul(usize)(
+  (*) : (fn(compt(lhs): usize, compt(rhs): usize) -> compt(usize))(
+    __yo_usize_mul(lhs, rhs)
+  )
+));
+impl(usize, ComptDiv(usize)(
+  (/) : (fn(compt(lhs): usize, compt(rhs): usize) -> compt(usize))(
+    __yo_usize_div(lhs, rhs)
+  )
+));
+impl(usize, ComptMod(usize)(
+  (%) : (fn(compt(lhs): usize, compt(rhs): usize) -> compt(usize))(
+    __yo_usize_mod(lhs, rhs)
+  )
+));
+impl(usize, ComptEq(usize)(
+  (==) : (fn(compt(lhs): usize, compt(rhs): usize) -> compt(bool))(
+    __yo_usize_eq(lhs, rhs)
+  ),
+  (!=) : (fn(compt(lhs): usize, compt(rhs): usize) -> compt(bool))(
+    __yo_usize_neq(lhs, rhs)
+  )
+));
+impl(usize, ComptOrd(usize)(
+  (<) : (fn(compt(lhs): usize, compt(rhs): usize) -> compt(bool))(
+    __yo_usize_lt(lhs, rhs)
+  ),
+  (<=) : (fn(compt(lhs): usize, compt(rhs): usize) -> compt(bool))(
+    __yo_usize_lte(lhs, rhs)
+  ),
+  (>) : (fn(compt(lhs): usize, compt(rhs): usize) -> compt(bool))(
+    __yo_usize_gt(lhs, rhs)
+  ),
+  (>=) : (fn(compt(lhs): usize, compt(rhs): usize) -> compt(bool))(
+    __yo_usize_gte(lhs, rhs)
+  )
+));
+impl(usize, {
+  (to_string) :: (fn(compt(self): usize) -> compt(compt_string))
+    __yo_usize_to_string(self)
+  ;
+  export to_string;
+});
+_usize :: usize;
+export usize : _usize;
+
+/// char
+impl(char, Send());
+impl(char, Add(char)(
+  (+): ((a, b) -> __yo_op_add(a, b))
+));
+impl(char, Sub(char)(
+  (-): ((a, b) -> __yo_op_sub(a, b))
+));
+impl(char, Mul(char)(
+  (*): ((a, b) -> __yo_op_mul(a, b))
+));
+impl(char, Div(char)(
+  (/): ((a, b) -> __yo_op_div(a, b))
+));
+impl(char, Mod(char)(
+  (%): ((a, b) -> __yo_op_mod(a, b))
+));
+impl(char, Negate(char)(
+  (neg): ((a) -> __yo_op_neg(a))
+));
+impl(char, LogicalNot(
+  (!): ((a) -> __yo_op_not(a))
+));
+impl(char, BitNot(char)(
+  (~): ((a) -> __yo_op_bit_complement(a))
+));
+impl(char, BitAnd(char)(
+  (&): ((a, b) -> __yo_op_bit_and(a, b))
+));
+impl(char, BitOr(char)(
+  (|): ((a, b) -> __yo_op_bit_or(a, b))
+));
+impl(char, BitXor(char)(
+  (^): ((a, b) -> __yo_op_bit_xor(a, b))
+));
+impl(char, Eq(char)(
+  (==) : ((a, b) -> __yo_op_eq(a, b)),
+  (!=) : ((a, b) -> __yo_op_neq(a, b))
+));
+impl(char, Ord(char)(
+  (<) : ((a, b) -> __yo_op_lt(a, b)),
+  (<=) : ((a, b) -> __yo_op_lte(a, b)),
+  (>) : ((a, b) -> __yo_op_gt(a, b)),
+  (>=) : ((a, b) -> __yo_op_gte(a, b))
+));
+impl(char, Hash(
+  (hash): ((value) -> u64(value))
+));
+impl(char, Clone(char)(
+  clone: ((self) -> __yo_return_self(self))
+));
+_char :: char;
+export char : _char;
+
+/// int
+impl(int, Send());
+impl(int, Add(int)(
+  (+): ((a, b) -> __yo_op_add(a, b))
+));
+impl(int, Sub(int)(
+  (-): ((a, b) -> __yo_op_sub(a, b))
+));
+impl(int, Mul(int)(
+  (*): ((a, b) -> __yo_op_mul(a, b))
+));
+impl(int, Div(int)(
+  (/): ((a, b) -> __yo_op_div(a, b))
+));
+impl(int, Mod(int)(
+  (%): ((a, b) -> __yo_op_mod(a, b))
+));
+impl(int, Negate(int)(
+  (neg): ((a) -> __yo_op_neg(a))
+));
+impl(int, LogicalNot(
+  (!): ((a) -> __yo_op_not(a))
+));
+impl(int, BitNot(int)(
+  (~): ((a) -> __yo_op_bit_complement(a))
+));
+impl(int, BitAnd(int)(
+  (&): ((a, b) -> __yo_op_bit_and(a, b))
+));
+impl(int, BitOr(int)(
+  (|): ((a, b) -> __yo_op_bit_or(a, b))
+));
+impl(int, BitXor(int)(
+  (^): ((a, b) -> __yo_op_bit_xor(a, b))
+));
+impl(int, Eq(int)(
+  (==) : ((a, b) -> __yo_op_eq(a, b)),
+  (!=) : ((a, b) -> __yo_op_neq(a, b))
+));
+impl(int, Ord(int)(
+  (<) : ((a, b) -> __yo_op_lt(a, b)),
+  (<=) : ((a, b) -> __yo_op_lte(a, b)),
+  (>) : ((a, b) -> __yo_op_gt(a, b)),
+  (>=) : ((a, b) -> __yo_op_gte(a, b))
+));
+impl(int, Hash(
+  (hash): ((value) -> u64(value))
+));
+impl(int, Clone(int)(
+  clone: ((self) -> __yo_return_self(self))
+));
+_int :: int;
+export int : _int;
+
+/// uint
+impl(uint, Send());
+impl(uint, Add(uint)(
+  (+): ((a, b) -> __yo_op_add(a, b))
+));
+impl(uint, Sub(uint)(
+  (-): ((a, b) -> __yo_op_sub(a, b))
+));
+impl(uint, Mul(uint)(
+  (*): ((a, b) -> __yo_op_mul(a, b))
+));
+impl(uint, Div(uint)(
+  (/): ((a, b) -> __yo_op_div(a, b))
+));
+impl(uint, Mod(uint)(
+  (%): ((a, b) -> __yo_op_mod(a, b))
+));
+impl(uint, Negate(uint)(
+  (neg): ((a) -> __yo_op_neg(a))
+));
+impl(uint, LogicalNot(
+  (!): ((a) -> __yo_op_not(a))
+));
+impl(uint, BitNot(uint)(
+  (~): ((a) -> __yo_op_bit_complement(a))
+));
+impl(uint, BitAnd(uint)(
+  (&): ((a, b) -> __yo_op_bit_and(a, b))
+));
+impl(uint, BitOr(uint)(
+  (|): ((a, b) -> __yo_op_bit_or(a, b))
+));
+impl(uint, BitXor(uint)(
+  (^): ((a, b) -> __yo_op_bit_xor(a, b))
+));
+impl(uint, Eq(uint)(
+  (==) : ((a, b) -> __yo_op_eq(a, b)),
+  (!=) : ((a, b) -> __yo_op_neq(a, b))
+));
+impl(uint, Ord(uint)(
+  (<) : ((a, b) -> __yo_op_lt(a, b)),
+  (<=) : ((a, b) -> __yo_op_lte(a, b)),
+  (>) : ((a, b) -> __yo_op_gt(a, b)),
+  (>=) : ((a, b) -> __yo_op_gte(a, b))
+));
+impl(uint, Hash(
+  (hash): ((value) -> u64(value))
+));
+impl(uint, Clone(uint)(
+  clone: ((self) -> __yo_return_self(self))
+));
+_uint :: uint;
+export uint : _uint;
+
+/// short
+impl(short, Send());
+impl(short, Add(short)(
+  (+): ((a, b) -> __yo_op_add(a, b))
+));
+impl(short, Sub(short)(
+  (-): ((a, b) -> __yo_op_sub(a, b))
+));
+impl(short, Mul(short)(
+  (*): ((a, b) -> __yo_op_mul(a, b))
+));
+impl(short, Div(short)(
+  (/): ((a, b) -> __yo_op_div(a, b))
+));
+impl(short, Mod(short)(
+  (%): ((a, b) -> __yo_op_mod(a, b))
+));
+impl(short, Negate(short)(
+  (neg): ((a) -> __yo_op_neg(a))
+));
+impl(short, LogicalNot(
+  (!): ((a) -> __yo_op_not(a))
+));
+impl(short, BitNot(short)(
+  (~): ((a) -> __yo_op_bit_complement(a))
+));
+impl(short, BitAnd(short)(
+  (&): ((a, b) -> __yo_op_bit_and(a, b))
+));
+impl(short, BitOr(short)(
+  (|): ((a, b) -> __yo_op_bit_or(a, b))
+));
+impl(short, BitXor(short)(
+  (^): ((a, b) -> __yo_op_bit_xor(a, b))
+));
+impl(short, Eq(short)(
+  (==) : ((a, b) -> __yo_op_eq(a, b)),
+  (!=) : ((a, b) -> __yo_op_neq(a, b))
+));
+impl(short, Ord(short)(
+  (<) : ((a, b) -> __yo_op_lt(a, b)),
+  (<=) : ((a, b) -> __yo_op_lte(a, b)),
+  (>) : ((a, b) -> __yo_op_gt(a, b)),
+  (>=) : ((a, b) -> __yo_op_gte(a, b))
+));
+impl(short, Hash(
+  (hash): ((value) -> u64(value))
+));
+impl(short, Clone(short)(
+  clone: ((self) -> __yo_return_self(self))
+));
+_short :: short;
+export short : _short;
+
+/// ushort
+impl(ushort, Send());
+impl(ushort, Add(ushort)(
+  (+): ((a, b) -> __yo_op_add(a, b))
+));
+impl(ushort, Sub(ushort)(
+  (-): ((a, b) -> __yo_op_sub(a, b))
+));
+impl(ushort, Mul(ushort)(
+  (*): ((a, b) -> __yo_op_mul(a, b))
+));
+impl(ushort, Div(ushort)(
+  (/): ((a, b) -> __yo_op_div(a, b))
+));
+impl(ushort, Mod(ushort)(
+  (%): ((a, b) -> __yo_op_mod(a, b))
+));
+impl(ushort, Negate(ushort)(
+  (neg): ((a) -> __yo_op_neg(a))
+));
+impl(ushort, LogicalNot(
+  (!): ((a) -> __yo_op_not(a))
+));
+impl(ushort, BitNot(ushort)(
+  (~): ((a) -> __yo_op_bit_complement(a))
+));
+impl(ushort, BitAnd(ushort)(
+  (&): ((a, b) -> __yo_op_bit_and(a, b))
+));
+impl(ushort, BitOr(ushort)(
+  (|): ((a, b) -> __yo_op_bit_or(a, b))
+));
+impl(ushort, BitXor(ushort)(
+  (^): ((a, b) -> __yo_op_bit_xor(a, b))
+));
+impl(ushort, Eq(ushort)(
+  (==) : ((a, b) -> __yo_op_eq(a, b)),
+  (!=) : ((a, b) -> __yo_op_neq(a, b))
+));
+impl(ushort, Ord(ushort)(
+  (<) : ((a, b) -> __yo_op_lt(a, b)),
+  (<=) : ((a, b) -> __yo_op_lte(a, b)),
+  (>) : ((a, b) -> __yo_op_gt(a, b)),
+  (>=) : ((a, b) -> __yo_op_gte(a, b))
+));
+impl(ushort, Hash(
+  (hash): ((value) -> u64(value))
+));
+impl(ushort, Clone(ushort)(
+  clone: ((self) -> __yo_return_self(self))
+));
+_ushort :: ushort;
+export ushort : _ushort;
+
+/// long
+impl(long, Send());
+impl(long, Add(long)(
+  (+): ((a, b) -> __yo_op_add(a, b))
+));
+impl(long, Sub(long)(
+  (-): ((a, b) -> __yo_op_sub(a, b))
+));
+impl(long, Mul(long)(
+  (*): ((a, b) -> __yo_op_mul(a, b))
+));
+impl(long, Div(long)(
+  (/): ((a, b) -> __yo_op_div(a, b))
+));
+impl(long, Mod(long)(
+  (%): ((a, b) -> __yo_op_mod(a, b))
+));
+impl(long, Negate(long)(
+  (neg): ((a) -> __yo_op_neg(a))
+));
+impl(long, LogicalNot(
+  (!): ((a) -> __yo_op_not(a))
+));
+impl(long, BitNot(long)(
+  (~): ((a) -> __yo_op_bit_complement(a))
+));
+impl(long, BitAnd(long)(
+  (&): ((a, b) -> __yo_op_bit_and(a, b))
+));
+impl(long, BitOr(long)(
+  (|): ((a, b) -> __yo_op_bit_or(a, b))
+));
+impl(long, BitXor(long)(
+  (^): ((a, b) -> __yo_op_bit_xor(a, b))
+));
+impl(long, Eq(long)(
+  (==) : ((a, b) -> __yo_op_eq(a, b)),
+  (!=) : ((a, b) -> __yo_op_neq(a, b))
+));
+impl(long, Ord(long)(
+  (<) : ((a, b) -> __yo_op_lt(a, b)),
+  (<=) : ((a, b) -> __yo_op_lte(a, b)),
+  (>) : ((a, b) -> __yo_op_gt(a, b)),
+  (>=) : ((a, b) -> __yo_op_gte(a, b))
+));
+impl(long, Hash(
+  (hash): ((value) -> u64(value))
+));
+impl(long, Clone(long)(
+  clone: ((self) -> __yo_return_self(self))
+));
+_long :: long;
+export long : _long;
+
+
+/// ulong
+impl(ulong, Send());
+impl(ulong, Add(ulong)(
+  (+): ((a, b) -> __yo_op_add(a, b))
+));
+impl(ulong, Sub(ulong)(
+  (-): ((a, b) -> __yo_op_sub(a, b))
+));
+impl(ulong, Mul(ulong)(
+  (*): ((a, b) -> __yo_op_mul(a, b))
+));
+impl(ulong, Div(ulong)(
+  (/): ((a, b) -> __yo_op_div(a, b))
+));
+impl(ulong, Mod(ulong)(
+  (%): ((a, b) -> __yo_op_mod(a, b))
+));
+impl(ulong, Negate(ulong)(
+  (neg): ((a) -> __yo_op_neg(a))
+));
+impl(ulong, LogicalNot(
+  (!): ((a) -> __yo_op_not(a))
+));
+impl(ulong, BitNot(ulong)(
+  (~): ((a) -> __yo_op_bit_complement(a))
+));
+impl(ulong, BitAnd(ulong)(
+  (&): ((a, b) -> __yo_op_bit_and(a, b))
+));
+impl(ulong, BitOr(ulong)(
+  (|): ((a, b) -> __yo_op_bit_or(a, b))
+));
+impl(ulong, BitXor(ulong)(
+  (^): ((a, b) -> __yo_op_bit_xor(a, b))
+));
+impl(ulong, Eq(ulong)(
+  (==) : ((a, b) -> __yo_op_eq(a, b)),
+  (!=) : ((a, b) -> __yo_op_neq(a, b))
+));
+impl(ulong, Ord(ulong)(
+  (<) : ((a, b) -> __yo_op_lt(a, b)),
+  (<=) : ((a, b) -> __yo_op_lte(a, b)),
+  (>) : ((a, b) -> __yo_op_gt(a, b)),
+  (>=) : ((a, b) -> __yo_op_gte(a, b))
+));
+impl(ulong, Hash(
+  (hash): ((value) -> u64(value))
+));
+impl(ulong, Clone(ulong)(
+  clone: ((self) -> __yo_return_self(self))
+));
+_ulong :: ulong;
+export ulong : _ulong;
+
+/// longlong
+impl(longlong, Send());
+impl(longlong, Add(longlong)(
+  (+): ((a, b) -> __yo_op_add(a, b))
+));
+impl(longlong, Sub(longlong)(
+  (-): ((a, b) -> __yo_op_sub(a, b))
+));
+impl(longlong, Mul(longlong)(
+  (*): ((a, b) -> __yo_op_mul(a, b))
+));
+impl(longlong, Div(longlong)(
+  (/): ((a, b) -> __yo_op_div(a, b))
+));
+impl(longlong, Mod(longlong)(
+  (%): ((a, b) -> __yo_op_mod(a, b))
+));
+impl(longlong, Negate(longlong)(
+  (neg): ((a) -> __yo_op_neg(a))
+));
+impl(longlong, LogicalNot(
+  (!): ((a) -> __yo_op_not(a))
+));
+impl(longlong, BitNot(longlong)(
+  (~): ((a) -> __yo_op_bit_complement(a))
+));
+impl(longlong, BitAnd(longlong)(
+  (&): ((a, b) -> __yo_op_bit_and(a, b))
+));
+impl(longlong, BitOr(longlong)(
+  (|): ((a, b) -> __yo_op_bit_or(a, b))
+));
+impl(longlong, BitXor(longlong)(
+  (^): ((a, b) -> __yo_op_bit_xor(a, b))
+));
+impl(longlong, Eq(longlong)(
+  (==) : ((a, b) -> __yo_op_eq(a, b)),
+  (!=) : ((a, b) -> __yo_op_neq(a, b))
+));
+impl(longlong, Ord(longlong)(
+  (<) : ((a, b) -> __yo_op_lt(a, b)),
+  (<=) : ((a, b) -> __yo_op_lte(a, b)),
+  (>) : ((a, b) -> __yo_op_gt(a, b)),
+  (>=) : ((a, b) -> __yo_op_gte(a, b))
+));
+impl(longlong, Hash(
+  (hash): ((value) -> u64(value))
+));
+impl(longlong, Clone(longlong)(
+  clone: ((self) -> __yo_return_self(self))
+));
+_longlong :: longlong;
+export longlong : _longlong;
+
+/// ulonglong
+impl(ulonglong, Send());
+impl(ulonglong, Add(ulonglong)(
+  (+): ((a, b) -> __yo_op_add(a, b))
+));
+impl(ulonglong, Sub(ulonglong)(
+  (-): ((a, b) -> __yo_op_sub(a, b))
+));
+impl(ulonglong, Mul(ulonglong)(
+  (*): ((a, b) -> __yo_op_mul(a, b))
+));
+impl(ulonglong, Div(ulonglong)(
+  (/): ((a, b) -> __yo_op_div(a, b))
+));
+impl(ulonglong, Mod(ulonglong)(
+  (%): ((a, b) -> __yo_op_mod(a, b))
+));
+impl(ulonglong, Negate(ulonglong)(
+  (neg): ((a) -> __yo_op_neg(a))
+));
+impl(ulonglong, LogicalNot(
+  (!): ((a) -> __yo_op_not(a))
+));
+impl(ulonglong, BitNot(ulonglong)(
+  (~): ((a) -> __yo_op_bit_complement(a))
+));
+impl(ulonglong, BitAnd(ulonglong)(
+  (&): ((a, b) -> __yo_op_bit_and(a, b))
+));
+impl(ulonglong, BitOr(ulonglong)(
+  (|): ((a, b) -> __yo_op_bit_or(a, b))
+));
+impl(ulonglong, BitXor(ulonglong)(
+  (^): ((a, b) -> __yo_op_bit_xor(a, b))
+));
+impl(ulonglong, Eq(ulonglong)(
+  (==) : ((a, b) -> __yo_op_eq(a, b)),
+  (!=) : ((a, b) -> __yo_op_neq(a, b))
+));
+impl(ulonglong, Ord(ulonglong)(
+  (<) : ((a, b) -> __yo_op_lt(a, b)),
+  (<=) : ((a, b) -> __yo_op_lte(a, b)),
+  (>) : ((a, b) -> __yo_op_gt(a, b)),
+  (>=) : ((a, b) -> __yo_op_gte(a, b))
+));
+impl(ulonglong, Hash(
+  (hash): ((value) -> u64(value))
+));
+impl(ulonglong, Clone(ulonglong)(
+  clone: ((self) -> __yo_return_self(self))
+));
+_ulonglong :: ulonglong;
+export ulonglong : _ulonglong;
+
+/// longdouble
+impl(longdouble, Send());
+impl(longdouble, Add(longdouble)(
+  (+): ((a, b) -> __yo_op_add(a, b))
+));
+impl(longdouble, Sub(longdouble)(
+  (-): ((a, b) -> __yo_op_sub(a, b))
+));
+impl(longdouble, Mul(longdouble)(
+  (*): ((a, b) -> __yo_op_mul(a, b))
+));
+impl(longdouble, Div(longdouble)(
+  (/): ((a, b) -> __yo_op_div(a, b))
+));
+impl(longdouble, Mod(longdouble)(
+  (%): ((a, b) -> __yo_op_mod(a, b))
+));
+impl(longdouble, Negate(longdouble)(
+  (neg): ((a) -> __yo_op_neg(a))
+));
+impl(longdouble, LogicalNot(
+  (!): ((a) -> __yo_op_not(a))
+));
+impl(longdouble, BitNot(longdouble)(
+  (~): ((a) -> __yo_op_bit_complement(a))
+));
+impl(longdouble, BitAnd(longdouble)(
+  (&): ((a, b) -> __yo_op_bit_and(a, b))
+));
+impl(longdouble, BitOr(longdouble)(
+  (|): ((a, b) -> __yo_op_bit_or(a, b))
+));
+impl(longdouble, BitXor(longdouble)(
+  (^): ((a, b) -> __yo_op_bit_xor(a, b))
+));
+impl(longdouble, Eq(longdouble)(
+  (==) : ((a, b) -> __yo_op_eq(a, b)),
+  (!=) : ((a, b) -> __yo_op_neq(a, b))
+));
+impl(longdouble, Ord(longdouble)(
+  (<) : ((a, b) -> __yo_op_lt(a, b)),
+  (<=) : ((a, b) -> __yo_op_lte(a, b)),
+  (>) : ((a, b) -> __yo_op_gt(a, b)),
+  (>=) : ((a, b) -> __yo_op_gte(a, b))
+));
+impl(longdouble, Hash(
+  (hash): ((value) -> u64(i64(value)))
+));
+impl(longdouble, Clone(longdouble)(
+  clone: ((self) -> __yo_return_self(self))
+));
+_longdouble :: longdouble;
+export longdouble : _longdouble;
+
+
+/// compt_int
+impl(compt_int, ComptAdd(compt_int)(
+  (+) : (fn(compt(lhs): compt_int, compt(rhs): compt_int) -> compt(compt_int))(
+    __yo_compt_int_add(lhs, rhs)
+  )
+));
+impl(compt_int, ComptSub(compt_int)(
+  (-) : (fn(compt(lhs): compt_int, compt(rhs): compt_int) -> compt(compt_int))(
+    __yo_compt_int_sub(lhs, rhs)
+  )
+));
+impl(compt_int, ComptMul(compt_int)(
+  (*) : (fn(compt(lhs): compt_int, compt(rhs): compt_int) -> compt(compt_int))(
+    __yo_compt_int_mul(lhs, rhs)
+  )
+));
+impl(compt_int, ComptDiv(compt_int)(
+  (/) : (fn(compt(lhs): compt_int, compt(rhs): compt_int) -> compt(compt_int))(
+    __yo_compt_int_div(lhs, rhs)
+  )
+));
+impl(compt_int, ComptMod(compt_int)(
+  (%) : (fn(compt(lhs): compt_int, compt(rhs): compt_int) -> compt(compt_int))(
+    __yo_compt_int_mod(lhs, rhs)
+  )
+));
+impl(compt_int, ComptNegate(compt_int)(
+  (neg) : (fn(compt(self): compt_int) -> compt(compt_int))(
+    __yo_compt_int_neg(self)
+  )
+));
+impl(compt_int, ComptEq(compt_int)(
+  (==) : (fn(compt(lhs): compt_int, compt(rhs): compt_int) -> compt(bool))(
+    __yo_compt_int_eq(lhs, rhs)
+  ),
+  (!=) : (fn(compt(lhs): compt_int, compt(rhs): compt_int) -> compt(bool))(
+    __yo_compt_int_neq(lhs, rhs)
+  )
+));
+impl(compt_int, ComptOrd(compt_int)(
+  (<) : (fn(compt(lhs): compt_int, compt(rhs): compt_int) -> compt(bool))(
+    __yo_compt_int_lt(lhs, rhs)
+  ),
+  (<=) : (fn(compt(lhs): compt_int, compt(rhs): compt_int) -> compt(bool))(
+    __yo_compt_int_lte(lhs, rhs)
+  ),
+  (>) : (fn(compt(lhs): compt_int, compt(rhs): compt_int) -> compt(bool))(
+    __yo_compt_int_gt(lhs, rhs)
+  ),
+  (>=) : (fn(compt(lhs): compt_int, compt(rhs): compt_int) -> compt(bool))(
+    __yo_compt_int_gte(lhs, rhs)
+  )
+));
+impl(compt_int, {
+  (to_string) :: (fn(compt(self): compt_int) -> compt(compt_string))(
+    __yo_compt_int_to_string(self)
+  );
+  export to_string;
+});
+_compt_int :: compt_int;
+export compt_int : _compt_int;
+
+/// compt_float
+impl(compt_float, ComptAdd(compt_float)(
+  (+) : (fn(compt(lhs): compt_float, compt(rhs): compt_float) -> compt(compt_float))(
+    __yo_compt_float_add(lhs, rhs)
+  )
+));
+impl(compt_float, ComptSub(compt_float)(
+  (-) : (fn(compt(lhs): compt_float, compt(rhs): compt_float) -> compt(compt_float))(
+    __yo_compt_float_sub(lhs, rhs)
+  )
+));
+impl(compt_float, ComptMul(compt_float)(
+  (*) : (fn(compt(lhs): compt_float, compt(rhs): compt_float) -> compt(compt_float))(
+    __yo_compt_float_mul(lhs, rhs)
+  )
+));
+impl(compt_float, ComptDiv(compt_float)(
+  (/) : (fn(compt(lhs): compt_float, compt(rhs): compt_float) -> compt(compt_float))(
+    __yo_compt_float_div(lhs, rhs)
+  )
+));
+impl(compt_float, ComptNegate(compt_float)(
+  (neg) : (fn(compt(self): compt_float) -> compt(compt_float))(
+    __yo_compt_float_neg(self)
+  )
+));
+impl(compt_float, ComptEq(compt_float)(
+  (==) : (fn(compt(lhs): compt_float, compt(rhs): compt_float) -> compt(bool))(
+    __yo_compt_float_eq(lhs, rhs)
+  ),
+  (!=) : (fn(compt(lhs): compt_float, compt(rhs): compt_float) -> compt(bool))(
+    __yo_compt_float_neq(lhs, rhs)
+  )
+));
+impl(compt_float, ComptOrd(compt_float)(
+  (<) : (fn(compt(lhs): compt_float, compt(rhs): compt_float) -> compt(bool))(
+    __yo_compt_float_lt(lhs, rhs)
+  ),
+  (<=) : (fn(compt(lhs): compt_float, compt(rhs): compt_float) -> compt(bool))(
+    __yo_compt_float_lte(lhs, rhs)
+  ),
+  (>) : (fn(compt(lhs): compt_float, compt(rhs): compt_float) -> compt(bool))(
+    __yo_compt_float_gt(lhs, rhs)
+  ),
+  (>=) : (fn(compt(lhs): compt_float, compt(rhs): compt_float) -> compt(bool))(
+    __yo_compt_float_gte(lhs, rhs)
+  )
+));
+impl(compt_float, {
+  (to_string) :: (fn(compt(self): compt_float) -> compt(compt_string))(
+    __yo_compt_float_to_string(self)
+  );
+  export to_string;
+});
+_compt_float :: compt_float;
+export compt_float : _compt_float;
+
+/// compt_string
+impl(compt_string, ComptAdd(compt_string)(
+  (+) : (fn(compt(lhs): compt_string, compt(rhs): compt_string) -> compt(compt_string))(
+    __yo_compt_string_concat(lhs, rhs)
+  )
+));
+impl(compt_string, ComptEq(compt_string)(
+  (==) : (fn(compt(lhs): compt_string, compt(rhs): compt_string) -> compt(bool))(
+    __yo_compt_string_eq(lhs, rhs)
+  ),
+  (!=) : (fn(compt(lhs): compt_string, compt(rhs): compt_string) -> compt(bool))(
+    __yo_compt_string_neq(lhs, rhs)
+  )
+));
+impl(compt_string, ComptOrd(compt_string)(
+  (<) : (fn(compt(lhs): compt_string, compt(rhs): compt_string) -> compt(bool))(
+    __yo_compt_string_lt(lhs, rhs)
+  ),
+  (<=) : (fn(compt(lhs): compt_string, compt(rhs): compt_string) -> compt(bool))(
+    __yo_compt_string_lte(lhs, rhs)
+  ),
+  (>) : (fn(compt(lhs): compt_string, compt(rhs): compt_string) -> compt(bool))(
+    __yo_compt_string_gt(lhs, rhs)
+  ),
+  (>=) : (fn(compt(lhs): compt_string, compt(rhs): compt_string) -> compt(bool))(
+    __yo_compt_string_gte(lhs, rhs)
+  )
+));
+impl(compt_string, {
+  len :: (fn(compt(self): compt_string) -> compt(compt_int))(
+    __yo_compt_string_length(self)
+  );
+  export len;
+
+  (to_upper) :: (fn(compt(self): compt_string) -> compt(compt_string))(
+    __yo_compt_string_to_upper(self)
+  );
+  export to_upper;
+
+  (to_lower) :: (fn(compt(self): compt_string) -> compt(compt_string))(
+    __yo_compt_string_to_lower(self)
+  );
+  export to_lower;
+
+  slice :: (fn(compt(self): compt_string, compt(start): compt_int, compt(end): compt_int) -> compt(compt_string))(
+    __yo_compt_string_slice(self, start, end)
+  );
+  export slice;
+});
+_compt_string :: compt_string;
+export compt_string : _compt_string;
+
+/// Ptr
+impl(forall(T : Type), where(T <: Send), *(T), Send());
+/*
+impl(forall(T : Type), *(T), Add(usize, *(T))(
+  (+) : ((lhs, rhs) -> __yo_ptr_add(lhs, rhs))
+));
+impl(forall(T : Type), *(T), Sub(usize, *(T))(
+  (-) : ((lhs, rhs) -> __yo_ptr_sub(lhs, rhs))
+));
+impl(forall(T : Type), *(T), Eq(*(T))(
+  (==) : ((lhs, rhs) -> __yo_ptr_eq(lhs, rhs)),
+  (!=) : ((lhs, rhs) -> __yo_ptr_neq(lhs, rhs))
+));
+impl(forall(T : Type), *(T), Ord(*(T))(
+  (<) : ((lhs, rhs) -> __yo_ptr_lt(lhs, rhs)),
+  (<=) : ((lhs, rhs) -> __yo_ptr_lte(lhs, rhs)),
+  (>) : ((lhs, rhs) -> __yo_ptr_gt(lhs, rhs)),
+  (>=) : ((lhs, rhs) -> __yo_ptr_gte(lhs, rhs))
+));
+impl(forall(T : Type), *(T), {
+  diff :: (fn(lhs : Self, rhs : Self) -> isize) {
+    return __yo_ptr_diff(lhs, rhs);
+  };
+  cast :: (fn(self : Self, compt(Target) : Type) -> Target) {
+    return __yo_as(self, Target);
+  };
+  export diff, cast;
+});
+*/
+impl(forall(T : Type), *(T), {
+  (&+) :: (fn(self : Self, offset : usize) -> Self)
+    __yo_ptr_add(self, offset)
+  ;
+  (&-) :: (fn(self : Self, offset : usize) -> Self)
+    __yo_ptr_sub(self, offset)
+  ;
+  (&==) :: (fn(self : Self, another : Self) -> bool)
+    __yo_ptr_eq(self, another)
+  ;
+  (&!=) :: (fn(self : Self, another : Self) -> bool)
+    __yo_ptr_neq(self, another)
+  ;
+  (&<) :: (fn(self : Self, another : Self) -> bool)
+    __yo_ptr_lt(self, another)
+  ;
+  (&<=) :: (fn(self : Self, another : Self) -> bool)
+    __yo_ptr_lte(self, another)
+  ;
+  (&>) :: (fn(self : Self, another : Self) -> bool)
+    __yo_ptr_gt(self, another)
+  ;
+  (&>=) :: (fn(self : Self, another : Self) -> bool)
+    __yo_ptr_gte(self, another)
+  ;
+  (&/) :: (fn(self : Self, another : Self) -> isize)
+    __yo_ptr_diff(self, another)
+  ;
+ 
+  export (&+), (&-), (&==), (&!=), (&<), (&<=), (&>), (&>=), (&/);
+});
+
+/// Array
+impl(forall(T : Type, U : usize), where(T <: Send), Array(T, U), Send());
+impl(forall(T : Type, U : usize), Array(T, U), {
+  len :: (fn(self : *(Self)) -> usize) {
+    return U;
+  };
+
+  export len;
+});
+
+/// Slice
+impl(forall(T : Type), Slice(T), {
+  len :: (fn(self : Self) -> usize)(
+    __yo_slice_len(self)
+  );
+  export len;
+});
+
+/// ComptList
+impl(forall(T : Type), ComptList(T), {
+  car :: (fn(compt(self): Self) -> compt(__yo_compt_list_element_type(Self)))(
+    __yo_compt_list_car(self)
+  );
+  cdr :: (fn(compt(self): Self) -> compt(Self))(
+    __yo_compt_list_cdr(self)
+  );
+  first :: car;
+  rest :: cdr;
+  append :: (fn(compt(self): Self, compt(another): Self) -> compt(Self))(
+    __yo_compt_list_append(self, another)
+  );
+  len :: (fn(compt(self): Self) -> compt(usize))(
+    __yo_compt_list_length(self)
+  );
+  export car, cdr, first, rest, append, len;
+});
+
+/// ExprList
+ExprList :: ComptList(Expr);
+export ExprList;
+
+/// Expr
+impl(Expr, ComptEq(Expr)(
+  (==) : (fn(compt(lhs): Expr, compt(rhs): Expr) -> compt(bool))(
+    __yo_expr_eq(lhs, rhs)
+  )
+));
+impl(Expr, {
+  is_atom :: (fn(compt(self): Expr) -> compt(bool))(
+    __yo_expr_is_atom(self)
+  );
+  export is_atom;
+
+  is_fn_call :: (fn(compt(self): Expr) -> compt(bool))(
+    __yo_expr_is_fn_call(self)
+  );
+  export is_fn_call;
+
+  get_callee :: (fn(compt(self): Expr) -> compt(Expr))(
+    __yo_expr_get_callee(self)
+  );
+  export get_callee;
+
+  get_args :: (fn(compt(self): Expr) -> compt(ExprList))(
+    __yo_expr_get_args(self)
+  );
+  export get_args;
+
+  cons :: (fn(compt(self): Expr, compt(rest): ExprList) -> compt(ExprList))(
+    __yo_compt_list_cons(self, rest)
+  );
+  export cons;
+
+  (to_string) :: (fn(compt(self): Expr) -> compt(compt_string))(
+    __yo_expr_to_string(self)
+  );
+  export to_string;
+});
+_Expr :: Expr;
+export Expr : _Expr;
+
+// Type
+impl(Type, {
+  to_string :: (fn(compt(self): Type) -> compt(compt_string))({
+     return __yo_type_to_string(self);
+  });
+  export to_string;
+
+  is_compatible_with :: (fn(compt(self): Type, compt(expected_type): Type) -> compt(bool))({
+     return __yo_are_types_compatible(expected_type, self);
+  });
+  export is_compatible_with;
+
+  contains_gc_type :: (fn(compt(self): Type) -> compt(bool))({
+    return __yo_type_contains_gc_type(self);
+  });
+  export contains_gc_type;
+
+  can_form_gc_cycle :: (fn(compt(self): Type) -> compt(bool))({
+    return __yo_type_can_form_gc_cycle(self);
+  });
+  export can_form_gc_cycle;
+
+  impls :: (fn(compt(self): Type, compt(marker): Module) -> compt(bool))({
+    return __yo_type_impls(self, marker);
+  });
+  export impls;
+});
+_Type :: Type;
+export Type : _Type;
+
+// Variable
+Var :: impl({
+  print_info :: (fn(quote(variable) : Expr) -> unquote(Expr)) {
+    return quote {
+      __yo_var_print_info(unquote(variable));
+    };
+  };
+  export print_info;
+
+  is_owning_the_gc_value :: (fn(quote(variable) : Expr) -> unquote(Expr)) {
+    return quote __yo_var_is_owning_the_gc_value(unquote(variable));
+  };
+  export is_owning_the_gc_value;
+
+  has_other_aliases :: (fn(quote(variable) : Expr) -> unquote(Expr)) {
+    return quote __yo_var_has_other_aliases(unquote(variable));
+  };
+  export has_other_aliases;
+});
+export Var;
+
+// === Data Types ===
+/// === Option ===
+Option :: (fn(compt(T) : Type) -> compt(Type))
+  enum(
+    None,
+    Some(value: T),
+
+    unwrap :: (fn(self : Self) -> T)(
+      match(self,
+        .Some(value) => value,
+        .None => panic("Called unwrap on a None value")
+      )
+    ),
+
+    is_some :: (fn(self : Self) -> bool)(
+      match(self,
+        .Some(_) => true,
+        .None => false
+      )
+    ),
+
+    is_none :: (fn(self : Self) -> bool)(
+      match(self,
+        .None => true,
+        .Some(_) => false
+      )
+    )
+  )
+;
+// Alias of the Option type
+? :: Option;
+// Nullable pointer
+(?*) :: (fn(compt(T): Type) -> compt(Type))
+  Option(*(T))
+;
+export 
+  Option,
+  ?,
+  (?*)
+;
+
+
+/// === Result ===
+Result :: (fn(compt(OkType): Type, compt(ErrorType): Type) -> compt(Type))
+  enum
+    Ok(value: OkType),
+    Err(error: ErrorType),
+
+    unwrap :: (fn(self : Self) -> OkType)(
+      match(self,
+        .Ok(value) => value,
+        .Err(_) => panic("Called unwrap on an Error value")
+      )
+    ),
+
+    is_ok :: (fn(self : Self) -> bool)(
+      match(self,
+        .Ok(_) => true,
+        .Err(_) => false
+      )
+    ),
+
+    is_err :: (fn(self : Self) -> bool)(
+      match(self,
+        .Err(_) => true,
+        .Ok(_) => false
+      )
+    )
+;
+export
+  Result
+;
+
+/// === Box ===
+Box :: (fn(compt(V) : Type) -> compt(Type))
+  object(
+    (*) : V
+  )
+;
+box :: (fn(forall(V : Type), value : V) -> Box(V))
+  Box(V)(value)
+;
+impl(forall(T : Type), Box(T), Isolation(
+  can_isolate : ((self) -> (rc(self) == 1))
+));
+
+export
+  Box,
+  box
+;
+
+/// === Iso ===
+impl(forall(T : Type), Iso(T), Send());
+impl(forall(T : Type), Iso(T), {
+  extract :: (fn(self : Self) -> Option(T))(
+    __yo_iso_extract(self)
+  );
+  export extract;
+});
+
+(^) :: (fn(quote(v) : Expr) -> unquote(Expr))({
+  temp :: cond(
+    v.is_atom() => v, 
+    true => gensym("iso_extract_temp")
+  );
+  temp_type :: gensym("iso_extract_temp_type");
+  assignment :: cond(
+    v.is_atom() => quote(()),
+    true => quote(unquote(temp) := unquote(v))
+  );
+  return quote {
+    unquote(assignment);
+    unquote(temp_type) :: typeof(unquote(temp));
+    cond(
+      Type.contains_gc_type(unquote(temp_type)) =>  // compile-time check
+        cond(
+          Type.can_form_gc_cycle(unquote(temp_type)) => { // compile-time check
+            consume(unquote(temp));
+            compt_assert(false, "Cannot isolate value of type containing GC type that can form cycles");
+            Option(Iso(unquote(temp_type))).None
+          },
+          !(Var.is_owning_the_gc_value(unquote(temp))) => { // compile-time check
+            consume(unquote(temp));
+            compt_assert(false, "Cannot isolate value of type that is not owned");
+            Option(Iso(unquote(temp_type))).None
+          },
+          (Var.has_other_aliases(unquote(temp))) => { // compile-time check
+            consume(unquote(temp));
+            compt_assert(false, "Cannot isolate value of type that has other aliases");
+            Option(Iso(unquote(temp_type))).None
+          },
+          (unquote(temp_type) <: Isolation).can_isolate(unquote(temp)) => // run-time check
+            Option(Iso(unquote(temp_type))).Some(Iso(unquote(temp_type))(unquote(temp))),
+          true => { // run-time check
+            consume(unquote(temp));
+            Option(Iso(unquote(temp_type))).None
+          }
+        ),
+      true => { // compile-time check
+        compt_assert(false, "Cannot isolate value type that does not contain GC type");
+        Option(Iso(unquote(temp_type))).Some(Iso(unquote(temp_type))(unquote(temp)))
+      }
+    )
+  };
+});
+export (^);
+
+/// === MaybeUninit ===
+extern "Yo",
+  __yo_maybe_uninit_new : 
+    (fn(compt(_Self) : Type) -> _Self),
+  __yo_maybe_uninit_as_ptr : 
+    (fn(compt(_Self) : Type, compt(BaseType): Type, self: *(_Self)) -> *(BaseType)),
+  __yo_maybe_uninit_assume_init : 
+    (fn(compt(_Self) : Type, compt(BaseType): Type, self: _Self) -> BaseType)
+;
+
+MaybeUninit :: (fn(compt(BaseType): Type) -> compt(Type))
+  struct(
+    value: BaseType,
+
+    new :: (fn() -> Self)(__yo_maybe_uninit_new(Self)),
+
+    as_ptr :: (fn(self: *(Self)) -> *(BaseType))(
+      __yo_maybe_uninit_as_ptr(Self, BaseType, self)
+    ),
+
+    assume_init :: (fn(self : Self) -> BaseType)(
+      __yo_maybe_uninit_assume_init(Self, BaseType, self)
+    )
+  )
+;
+
+export
+  MaybeUninit
+;
+
+// === Modules again ===
+/// === Iterator ===
+Iterator :: (fn(compt(Item) : Type) -> compt(Module)) {
+  return module(
+    Item := Item,
+    next :
+      fn(self : *(Self)) -> Option(Self.Item)
+  );
+};
+export Iterator;
+
+/// === IntoIterator ===
+IntoIterator :: (fn(
+  compt(Item) : Type,
+  compt(IntoIter) : Type,
+  where(IntoIter <: Iterator(Item))) -> compt(Module)) {
+  return module(
+    Item := Item,
+    IntoIter := IntoIter,
+    into_iter : 
+      fn(self : Self) -> Self.IntoIter
+  );
+};
+export IntoIterator;
+
+
+// === Macros ===
+/// === if ===
+if :: (fn(quote(condition) : Expr,
+        quote(then) : Expr,
+        (quote(else) : Expr) ?= quote(())
+      ) -> unquote(Expr))
+  quote
+    cond 
+      unquote(condition) => unquote(then),
+      true => unquote(else)
+;
+export 
+  if
+;
+
+/// === runtval ===
+
+/**
+ * This function is used to construct a runtime value from an expression.
+ */
+runtval :: (fn(quote(val_expr) : Expr) -> unquote(Expr)) {
+  temp :: gensym("runtval");
+  quote {
+    unquote(temp) := unquote(val_expr);
+    unquote(temp)
+  }
+};
+export
+  runtval
+;
+
+
+/**
+* try macro for handling Result types.
+*/
+try :: (fn(quote(expr_to_try): Expr) -> unquote(Expr)) {
+  temp :: gensym("try");
+  quote {
+    unquote(temp) := unquote(expr_to_try);
+    match(unquote(temp),
+      .Ok => unquote(temp).value,
+      .Err => {
+        return unquote(temp).error;
+      }
+    )
+  }
+};
+export try;
+
+/**
+ * `for` macro to run while loop over an iterator
+ * eg:
+ * 
+ *   for box.into_iter(), (value) => {
+ *     printf("value %d\n", value);
+ *   };
+ *
+ * transforms to
+ * 
+ * iter := box.into_iter();
+ * while true, {
+ *   value := iter.next();
+ *   match(value,
+ *     .Some(value) => {
+ *       printf("value %d\n", value);
+ *     }),
+ *     .None => { break; } 
+ * }
+ */
+for :: (fn(
+  quote(iter) : Expr,
+  quote(handle) : Expr
+  ) -> unquote(Expr)) {
+  // Check if `handle` is a function call of `=>`
+  return cond(
+    (handle.is_fn_call()) => {
+      callee :: handle.get_callee();
+      cond(
+        (callee.is_atom() && (callee == quote(=>))) => {
+          args :: handle.get_args();
+          compt_assert(args.len() == 2, "'for' macro requires 2 arguments in the function handle");
+          variable :: args.car();
+          body :: args.cdr().car();
+
+          iter_var :: gensym("for_iter_var");
+          temp_var :: gensym("for_temp_var");
+          quote({
+            unquote(iter_var) := unquote(iter);
+            while runtval(true), {
+              unquote(temp_var) := &(unquote(iter_var)).next();
+              match(unquote(temp_var),
+                .Some(unquote(variable)) => unquote(body),
+                .None => { break; }
+              )
+            };
+          })
+        },
+        true => {
+          compt_assert(false, "for macro requires a function handle with `=>`");
+          quote(false)
+        }
+      )
+    },
+    true => {
+      compt_assert(false, "for macro requires a function handle with `=>`");
+      quote(false)
+    });
+};
+export for;