hacking

crates/library2/std/src/num/int/ops.fe

@@ -1,14 +1,9 @@
+use ingot::ops::{Add, Sub, Div, Mul, Exp}
+
 extern {
     fn __invalid() -> !
 }
 
-
-// Addition `x + y`
-
-pub trait Add<RHS, Out> {
-    fn add(self, rhs: RHS) -> Out
-}
-
 impl Add<Self, Self> for i8 {
     fn add(self, rhs: Self) -> Self { __invalid() }
 }
@@ -57,12 +52,6 @@ impl Add<Self, Self> for u256 {
     fn add(self, rhs: Self) -> Self { __invalid() }
 }
 
-// Subtraction `x - y`
-
-pub trait Sub<RHS, Out> {
-    fn sub(self, rhs: RHS) -> Out
-}
-
 impl Sub<Self, Self> for i8 {
     fn sub(self, rhs: Self) -> Self { __invalid() }
 }
@@ -111,12 +100,6 @@ impl Sub<Self, Self> for u256 {
     fn sub(self, rhs: Self) -> Self { __invalid() }
 }
 
-// Multiplication `x * y`
-
-pub trait Mul<RHS, Out> {
-    fn mul(self, rhs: RHS) -> Out
-}
-
 impl Mul<Self, Self> for i8 {
     fn mul(self, rhs: Self) -> Self { __invalid() }
 }
@@ -165,12 +148,6 @@ impl Mul<Self, Self> for u256 {
     fn mul(self, rhs: Self) -> Self { __invalid() }
 }
 
-// Division `x / y`
-
-pub trait Div<RHS, Out> {
-    fn div(self, rhs: RHS) -> Out
-}
-
 impl Div<Self, Self> for i8 {
     fn div(self, rhs: Self) -> Self { __invalid() }
 }
@@ -219,11 +196,6 @@ impl Div<Self, Self> for u256 {
     fn div(self, rhs: Self) -> Self { __invalid() }
 }
 
-// Exponentiation `x^y`
-
-pub trait Exp<RHS, Out> {
-    fn exp(self, rhs: RHS) -> Out
-}
 
 impl Exp<Self, Self> for i8 {
     fn exp(self, rhs: Self) -> Self { __invalid() }

crates/library2/std/src/ops/arith.fe

@@ -0,0 +1,64 @@
+/// Addition (e.g. `x + y`)
+pub trait Add<RHS, Out> {
+    fn add(self, rhs: RHS) -> Out
+}
+
+/// Subtraction (e.g. `x - y`)
+pub trait Sub<RHS, Out> {
+    fn sub(self, rhs: RHS) -> Out
+}
+
+/// Multiplication (e.g. `x * y`)
+pub trait Mul<RHS, Out> {
+    fn mul(self, rhs: RHS) -> Out
+}
+
+/// Division (e.g. `x / y`)
+pub trait Div<RHS, Out> {
+    fn div(self, rhs: RHS) -> Out
+}
+
+/// Modulo (e.g. `x % y`)
+pub trait Mod<RHS, Out> {
+    fn mod_(self, rhs: RHS) -> Out
+}
+
+/// Exponentiation (e.g. `x ** y`)
+pub trait Exp<RHS, Out> {
+    fn exp(self, rhs: RHS) -> Out
+}
+
+/// Left shift (e.g. `x << y`)
+pub trait Shl<RHS, Out> {
+    fn shl(self, rhs: RHS) -> Out
+}
+
+/// Right shift (e.g. `x >> y`)
+pub trait Shr<RHS, Out> {
+    fn shr(self, rhs: RHS) -> Out
+}
+
+/// Plus (e.g. `+x`)
+pub trait Plus<Out> {
+    fn plus(self) -> Out
+}
+
+/// Minus (e.g. `-x`)
+pub trait Minus<Out> {
+    fn minus(self) -> Out
+}
+
+/// Bitwise and (e.g. `x && y`)
+pub trait BitAnd<RHS, Out> {
+    fn bit_and(self, rhs: RHS) -> Out
+}
+
+/// Bitwise or (e.g. `x || y`)
+pub trait BitOr<RHS, Out> {
+    fn bit_or(self, rhs: RHS) -> Out
+}
+
+/// Bitwise not (e.g. `~x`)
+pub trait BitNot<Out> {
+    fn bit_or(self) -> Out
+}

crates/library2/std/src/ops/comp.fe

@@ -0,0 +1,30 @@
+/// Equal (e.g. `x == y`)
+pub trait Eq<RHS, Out> {
+    fn eq(self, rhs: RHS) -> Out
+}
+
+/// `Not equal (e.g. `x != y`)
+pub trait NotEq<RHS, Out> {
+    fn not_eq(self, rhs: RHS) -> Out
+}
+
+/// Less than (e.g. `x < y`)
+pub trait Lt<RHS, Out> {
+    fn lt(self, rhs: RHS) -> Out
+}
+
+/// Less than or equal (e.g. `x <= y`)
+pub trait LtEq<RHS, Out> {
+    fn lt_eq(self, rhs: RHS) -> Out
+}
+
+/// Greater than (e.g. `x > y`)
+pub trait Gt<RHS, Out> {
+    fn gt(self, rhs: RHS) -> Out
+}
+
+/// Greater than or equal (e.g. `x >= y`)
+pub trait GtEq<RHS, Out> {
+    fn gt_eq(self, rhs: RHS) -> Out
+}
+

crates/library2/std/src/ops/logical.fe

@@ -0,0 +1,15 @@
+/// Logical and (e.g. `x && y`)
+pub trait And<RHS, Out> {
+    fn and(self, rhs: RHS) -> Out
+}
+
+/// Logical or (e.g. `x || y`)
+pub trait Or<RHS, Out> {
+    fn or(self, rhs: RHS) -> Out
+}
+
+/// Logical not (e.g. `!x`)
+pub trait Not<Out> {
+    fn not(self) -> Out
+}
+

crates/library2/std/src/ops/mod.fe

@@ -0,0 +1,4 @@
+// / Overloaded operations of Fe.
+// /
+// / Each trait in this module corresponds with a syntax opperator. During compilation,
+// / these syntax opperators are replaced with calls to the trait methods defiend here.