Bring back bigint.

1 files changed, 22 insertions, 22 deletions

diff --git a/src/op.rs b/src/op.rs
index b2f2a3f..e29de52 100644
--- a/src/op.rs
+++ b/src/op.rs
@@ -1,4 +1,5 @@
 use crate::eval::Num;
+use num::BigInt;
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub enum UnOp {
@@ -16,29 +17,28 @@ pub enum UnOp {
     Floor,
     Ceil,
     Round,
-    Trunc,
     Abs,
 }
 
 impl UnOp {
     fn eval(self, x: Num) -> Num {
+        use UnOp::*;
         match self {
-            UnOp::Neg => Num::Int(0).sub(x),
-            UnOp::Sin => x.sin(),
-            UnOp::Cos => x.cos(),
-            UnOp::Tan => x.tan(),
-            UnOp::Asin => x.asin(),
-            UnOp::Acos => x.acos(),
-            UnOp::Atan => x.atan(),
-            UnOp::Sqrt => x.sqrt(),
-            UnOp::Log => x.log(),
-            UnOp::Log10 => x.log10(),
-            UnOp::Log2 => x.log2(),
-            UnOp::Floor => x.floor(),
-            UnOp::Ceil => x.ceil(),
-            UnOp::Round => x.round(),
-            UnOp::Trunc => x.trunc(),
-            UnOp::Abs => x.abs(),
+            Neg => Num::Int(BigInt::from(0)).sub(x),
+            Sin => x.sin(),
+            Cos => x.cos(),
+            Tan => x.tan(),
+            Asin => x.asin(),
+            Acos => x.acos(),
+            Atan => x.atan(),
+            Sqrt => x.sqrt(),
+            Log => x.log(),
+            Log10 => x.log10(),
+            Log2 => x.log2(),
+            Floor => x.floor(),
+            Ceil => x.ceil(),
+            Round => x.round(),
+            Abs => x.abs(),
         }
     }
 }
@@ -58,7 +58,7 @@ impl BinOp {
     fn eval(self, x: Num, y: Num) -> Num {
         match self {
             BinOp::Pow => x.pow(y),
-            BinOp::Mul => x.mul(y),
+            BinOp::Mul => x.mul(&y),
             BinOp::Div => x.div(y),
             BinOp::IntDiv => x.int_div(y),
             BinOp::Mod => x.modulo(y),
@@ -68,18 +68,18 @@ impl BinOp {
     }
 }
 
-#[derive(Clone, Copy, Debug, PartialEq)]
+#[derive(Debug, PartialEq)]
 pub enum Op {
     Num(Num),
     Un(UnOp),
     Bin(BinOp),
 }
 
-pub fn eval(ops: &[Op]) -> Num {
+pub fn eval(ops: impl Iterator<Item = Op>) -> Num {
     let mut stack = Vec::new();
     for op in ops {
         match op {
-            Op::Num(n) => stack.push(*n),
+            Op::Num(n) => stack.push(n),
             Op::Un(op) => {
                 let n = stack.pop().unwrap();
                 stack.push(op.eval(n));
@@ -91,5 +91,5 @@ pub fn eval(ops: &[Op]) -> Num {
             }
         }
     }
-    stack[0]
+    stack.pop().unwrap()
 }