got node handlers on enum rails, making box not necessary and fixing

potential memory losses

src/node/handler.rs

@@ -1,53 +1,15 @@
-pub trait NodeHandler {
-    fn run(&self, inputs: Vec<f64>) -> f64;
+pub enum NodeHandler {
+    Number { number: f64 },
+    Function { function: fn(Vec<f64>) -> f64 },
+    Variable { getter: fn() -> f64 },
 }
 
-pub struct NodeFunction {
-    function: fn(Vec<f64>) -> f64,
-}
-
-impl NodeFunction {
-    pub fn new(function: fn(Vec<f64>) -> f64) -> NodeFunction {
-        NodeFunction { function }
-    }
-}
-
-impl NodeHandler for NodeFunction {
-    fn run(&self, inputs: Vec<f64>) -> f64 {
-        (self.function)(inputs)
-    }
-}
-
-pub struct NodeNumber {
-    number: f64,
-}
-
-impl NodeNumber {
-    pub fn new(number: Option<f64>) -> NodeNumber {
-        NodeNumber {
-            number: number.unwrap_or(0f64),
+impl NodeHandler {
+    pub fn run(&self, inputs: Vec<f64>) -> f64 {
+        match self {
+            NodeHandler::Number { number } => number.clone(),
+            NodeHandler::Function { function } => function(inputs),
+            NodeHandler::Variable { getter } => getter(),
         }
     }
 }
-
-impl NodeHandler for NodeNumber {
-    fn run(&self, inputs: Vec<f64>) -> f64 {
-        self.number
-    }
-}
-
-pub struct NodeVariable {
-    getter: fn() -> f64,
-}
-
-impl NodeVariable {
-    pub fn new(getter: fn() -> f64) -> NodeVariable {
-        NodeVariable { getter }
-    }
-}
-
-impl NodeHandler for NodeVariable {
-    fn run(&self, inputs: Vec<f64>) -> f64 {
-        (self.getter)()
-    }
-}

src/node/mod.rs

@@ -6,17 +6,14 @@ mod node_modifier;
 
 pub struct Node {
     children: Vec<Node>,
-    handler: Box<dyn NodeHandler>,
+    handler: NodeHandler,
 }
 
 impl Node {
-    pub fn new<T>(children: Option<Vec<Node>>, handler: T) -> Self
-    where
-        T: NodeHandler + 'static,
-    {
+    pub fn new(children: Option<Vec<Node>>, handler: NodeHandler) -> Self {
         Self {
             children: children.unwrap_or(vec![]),
-            handler: Box::new(handler),
+            handler: handler,
         }
     }
     pub fn get_value(&self) -> f64 {
@@ -36,19 +33,19 @@ impl Node {
     pub fn number(n: f64) -> Node {
         Node {
             children: vec![],
-            handler: Box::new(NodeNumber::new(Some(n))),
+            handler: NodeHandler::Number { number: n },
         }
     }
     pub fn function(func: fn(Vec<f64>) -> f64) -> Node {
         Node {
             children: vec![],
-            handler: Box::new(NodeFunction::new(func)),
+            handler: NodeHandler::Function { function: func },
         }
     }
     pub fn variable(getter: fn() -> f64) -> Node {
         Node {
             children: vec![],
-            handler: Box::new(NodeVariable::new(getter)),
+            handler: NodeHandler::Variable { getter },
         }
     }
 }