opportunistic move

should be way faster now

src/systems/stl/num.rs

@@ -7,7 +7,7 @@ use crate::foreign::ExternError;
 use crate::interpreted::TryFromExprInst;
 use crate::representations::interpreted::{Clause, ExprInst};
 use crate::representations::{Literal, Primitive};
-use crate::systems::cast_exprinst::with_lit;
+use crate::systems::cast_exprinst::get_literal;
 use crate::systems::AssertionError;
 use crate::{define_fn, ConstTree, Interner};
 
@@ -42,12 +42,12 @@ impl Numeric {
   }
 }
 impl TryFromExprInst for Numeric {
-  fn from_exi(exi: &ExprInst) -> Result<Self, Rc<dyn ExternError>> {
-    with_lit(exi, |l| match l {
-      Literal::Uint(i) => Ok(Numeric::Uint(*i)),
-      Literal::Num(n) => Ok(Numeric::Num(*n)),
-      _ => AssertionError::fail(exi.clone(), "an integer or number")?,
-    })
+  fn from_exi(exi: ExprInst) -> Result<Self, Rc<dyn ExternError>> {
+    match get_literal(exi)? {
+      (Literal::Uint(i), _) => Ok(Numeric::Uint(i)),
+      (Literal::Num(n), _) => Ok(Numeric::Num(n)),
+      (_, location) => AssertionError::fail(location, "an integer or number")?,
+    }
   }
 }
 
@@ -69,42 +69,36 @@ define_fn! {
   /// number, the output is number.
   Add { a: Numeric, b: Numeric } => match (a, b) {
     (Numeric::Uint(a), Numeric::Uint(b)) => {
-      a.checked_add(*b)
+      a.checked_add(b)
         .map(Numeric::Uint)
         .ok_or_else(|| ArithmeticError::Overflow.into_extern())
     }
     (Numeric::Num(a), Numeric::Num(b)) => Numeric::num(*(a + b)),
     (Numeric::Num(a), Numeric::Uint(b)) | (Numeric::Uint(b), Numeric::Num(a))
-    => Numeric::num(a.into_inner() + *b as f64),
-  }.map(Numeric::into)
-}
+    => Numeric::num(*a + b as f64),
+  }.map(Numeric::into);
 
-define_fn! {
   /// Subtract a number from another. Always returns Number.
   Subtract { a: Numeric, b: Numeric } => match (a, b) {
-    (Numeric::Uint(a), Numeric::Uint(b)) => Numeric::num(*a as f64 - *b as f64),
+    (Numeric::Uint(a), Numeric::Uint(b)) => Numeric::num(a as f64 - b as f64),
     (Numeric::Num(a), Numeric::Num(b)) => Numeric::num(*(a - b)),
-    (Numeric::Num(a), Numeric::Uint(b)) => Numeric::num(**a - *b as f64),
-    (Numeric::Uint(a), Numeric::Num(b)) => Numeric::num(*a as f64 - **b),
-  }.map(Numeric::into)
-}
+    (Numeric::Num(a), Numeric::Uint(b)) => Numeric::num(*a - b as f64),
+    (Numeric::Uint(a), Numeric::Num(b)) => Numeric::num(a as f64 - *b),
+  }.map(Numeric::into);
 
-define_fn! {
   /// Multiply two numbers. If they're both uint, the output is uint. If either
   /// is number, the output is number.
   Multiply { a: Numeric, b: Numeric } => match (a, b) {
     (Numeric::Uint(a), Numeric::Uint(b)) => {
-      a.checked_mul(*b)
+      a.checked_mul(b)
         .map(Numeric::Uint)
         .ok_or_else(|| ArithmeticError::Overflow.into_extern())
     }
     (Numeric::Num(a), Numeric::Num(b)) => Numeric::num(*(a * b)),
     (Numeric::Uint(a), Numeric::Num(b)) | (Numeric::Num(b), Numeric::Uint(a))
-      => Numeric::num(*a as f64 * **b),
-  }.map(Numeric::into)
-}
+      => Numeric::num(a as f64 * *b),
+  }.map(Numeric::into);
 
-define_fn! {
   /// Divide a number by another. Always returns Number.
   Divide { a: Numeric, b: Numeric } => {
     let a: f64 = a.as_f64();
@@ -113,21 +107,19 @@ define_fn! {
       return Err(ArithmeticError::DivByZero.into_extern())
     }
     Numeric::num(a / b).map(Numeric::into)
-  }
-}
+  };
 
-define_fn! {
   /// Take the remainder of two numbers.  If they're both uint, the output is
   /// uint. If either is number, the output is number.
   Remainder { a: Numeric, b: Numeric } => match (a, b) {
     (Numeric::Uint(a), Numeric::Uint(b)) => {
-      a.checked_rem(*b)
+      a.checked_rem(b)
         .map(Numeric::Uint)
         .ok_or_else(|| ArithmeticError::DivByZero.into_extern())
     }
     (Numeric::Num(a), Numeric::Num(b)) => Numeric::num(*(a % b)),
-    (Numeric::Uint(a), Numeric::Num(b)) => Numeric::num(*a as f64 % **b),
-    (Numeric::Num(a), Numeric::Uint(b)) => Numeric::num(**a % *b as f64),
+    (Numeric::Uint(a), Numeric::Num(b)) => Numeric::num(a as f64 % *b),
+    (Numeric::Num(a), Numeric::Uint(b)) => Numeric::num(*a % b as f64),
   }.map(Numeric::into)
 }