diff --git a/src/nodes/eval.rs b/src/nodes/eval.rs
index 7be6bf7..cd37cb3 100644
--- a/src/nodes/eval.rs
+++ b/src/nodes/eval.rs
@@ -28,8 +28,8 @@ impl Nodes {
         let len = nodes.len();
         collapse_toplevel(nodes, len)?;
 
-        match nodes.pop() {
-            Some(Node::Number(n)) => Ok(n),
+        match nodes.pop().unwrap() {
+            Node::Number(n) => Ok(n),
             _ => Err(Error::CollapseFailed(self)),
         }
     }
@@ -41,7 +41,7 @@ fn collapse_toplevel(nodes: &mut Vec<Node>, mut end: usize) -> Result<(), Error>
         .rposition(|n| *n == Node::ParenthesisStart)
         .unwrap_or(0);
 
-    while let Some((index, function)) = nodes[start..end]
+    while let Some((index, variant)) = nodes[start..end]
         .iter()
         .enumerate()
         .filter_map(|(i, n)| match n {
@@ -58,7 +58,20 @@ fn collapse_toplevel(nodes: &mut Vec<Node>, mut end: usize) -> Result<(), Error>
             return Err(Error::MissingArgument(node.clone()));
         };
 
-        function.for_float()(n);
+        match variant {
+            Function::Sqrt => n.sqrt_mut(),
+
+            Function::Ln => n.ln_mut(),
+
+            Function::Sine => n.sin_mut(),
+            Function::ArcSine => n.asin_mut(),
+            Function::Cosine => n.cos_mut(),
+            Function::ArcCosine => n.acos_mut(),
+            Function::Tangent => n.tan_mut(),
+            Function::ArcTangent => n.atan_mut(),
+            Function::Secant => n.sec_mut(),
+            Function::CoSecant => n.csc_mut(),
+        };
 
         nodes.remove(start + index);
         end -= 1;
@@ -172,54 +185,23 @@ fn collapse_toplevel(nodes: &mut Vec<Node>, mut end: usize) -> Result<(), Error>
     Ok(())
 }
 
-impl Function {
-    fn for_float(&self) -> impl FnMut(&mut Float) {
-        match self {
-            Function::Sqrt => Float::sqrt_mut,
-
-            Function::Ln => Float::ln_mut,
-
-            Function::Sine => Float::sin_mut,
-            Function::ArcSine => Float::asin_mut,
-            Function::Cosine => Float::cos_mut,
-            Function::ArcCosine => Float::acos_mut,
-            Function::Tangent => Float::tan_mut,
-            Function::ArcTangent => Float::atan_mut,
-            Function::Secant => Float::sec_mut,
-            Function::CoSecant => Float::csc_mut,
-        }
-    }
-}
-
 #[cfg(test)]
-mod tests {
-    use super::super::PREC;
-    use super::*;
-    use std::assert_matches;
+use super::PREC;
 
-    #[test]
-    fn basic() {
-        assert_eq!(
-            Nodes(vec![
-                Node::Function(Function::Sine),
-                Node::ParenthesisStart,
-                Node::Number(Float::with_val(PREC, 2)),
-                Node::ParenthesisEnd,
-                Node::Operator(Operator::Plus),
-                Node::Number(Float::with_val(PREC, 1))
-            ])
-            .evaluate()
-            .unwrap()
-            .to_f64(),
-            1.9092974268256817,
-        );
-    }
-
-    #[test]
-    fn zerosized() {
-        assert_matches!(
-            Nodes(vec![Node::ParenthesisStart, Node::ParenthesisEnd]).evaluate(),
-            Err(Error::CollapseFailed(Nodes(v))) if v.is_empty()
-        )
-    }
+#[test]
+fn test() {
+    assert_eq!(
+        Nodes(vec![
+            Node::Function(Function::Sine),
+            Node::ParenthesisStart,
+            Node::Number(Float::with_val(PREC, 2)),
+            Node::ParenthesisEnd,
+            Node::Operator(Operator::Plus),
+            Node::Number(Float::with_val(PREC, 1))
+        ])
+        .evaluate()
+        .unwrap()
+        .to_f64(),
+        1.9092974268256817,
+    );
 }
diff --git a/src/nodes/parse.rs b/src/nodes/parse.rs
index 0405be0..31a2088 100644
--- a/src/nodes/parse.rs
+++ b/src/nodes/parse.rs
@@ -195,49 +195,43 @@ impl FromStr for Nodes {
     }
 }
 
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn basic() {
-        assert_eq!(
-            Nodes::from_str("sin(2) + 1").unwrap().as_ref(),
-            &[
-                Node::Function(Function::Sine),
-                Node::ParenthesisStart,
-                Node::from(2),
-                Node::ParenthesisEnd,
-                Node::Operator(Operator::Plus),
-                Node::from(1),
-            ],
-        )
-    }
-
-    #[test]
-    fn e_constant() {
-        assert_eq!(
-            Nodes::from_str("5e * 5").unwrap().as_ref(),
-            &[
-                Node::from(5),
-                Node::Operator(Operator::Mult),
-                Node::from(f64::consts::E),
-                Node::Operator(Operator::Mult),
-                Node::from(5),
-            ],
-        )
-    }
-    #[test]
-    fn unary_op() {
-        assert_eq!(
-            Nodes::from_str("5(-5)").unwrap().as_ref(),
-            &[
-                Node::from(5),
-                Node::Operator(Operator::Mult),
-                Node::ParenthesisStart,
-                Node::from(-5),
-                Node::ParenthesisEnd,
-            ],
-        )
-    }
+#[test]
+fn test() {
+    assert_eq!(
+        Nodes::from_str("sin(2) + 1").unwrap().as_ref(),
+        &[
+            Node::Function(Function::Sine),
+            Node::ParenthesisStart,
+            Node::from(2),
+            Node::ParenthesisEnd,
+            Node::Operator(Operator::Plus),
+            Node::from(1),
+        ],
+    )
+}
+#[test]
+fn test_e() {
+    assert_eq!(
+        Nodes::from_str("5e * 5").unwrap().as_ref(),
+        &[
+            Node::from(5),
+            Node::Operator(Operator::Mult),
+            Node::from(f64::consts::E),
+            Node::Operator(Operator::Mult),
+            Node::from(5),
+        ],
+    )
+}
+#[test]
+fn test_unary_op() {
+    assert_eq!(
+        Nodes::from_str("5(-5)").unwrap().as_ref(),
+        &[
+            Node::from(5),
+            Node::Operator(Operator::Mult),
+            Node::ParenthesisStart,
+            Node::from(-5),
+            Node::ParenthesisEnd,
+        ],
+    )
 }