refactor

src/main.rs

@@ -2,7 +2,7 @@ use std::io;
 
 #[derive(Debug, PartialEq, Eq)]
 enum Symbol {
-    Number { value: u64 },
+    Number(i64),
     LeftBracket,
     RightBracket,
     Add,
@@ -96,31 +96,11 @@ fn try_tokenizing() {
     let tokenized_input: Vec<Vec<Symbol>> = input.iter().map(|s| tokenize(s).unwrap()).collect();
 
     let result: Vec<Vec<Symbol>> = vec![
-        vec![
-            Symbol::Number { value: 1 },
-            Symbol::Add,
-            Symbol::Number { value: 2 },
-        ],
-        vec![
-            Symbol::Number { value: 3 },
-            Symbol::Sub,
-            Symbol::Number { value: 4 },
-        ],
-        vec![
-            Symbol::Number { value: 5 },
-            Symbol::Mul,
-            Symbol::Number { value: 6 },
-        ],
-        vec![
-            Symbol::Number { value: 7 },
-            Symbol::Div,
-            Symbol::Number { value: 8 },
-        ],
-        vec![
-            Symbol::Number { value: 8 },
-            Symbol::Exp,
-            Symbol::Number { value: 9 },
-        ],
+        vec![Symbol::Number(1), Symbol::Add, Symbol::Number(2)],
+        vec![Symbol::Number(3), Symbol::Sub, Symbol::Number(4)],
+        vec![Symbol::Number(5), Symbol::Mul, Symbol::Number(6)],
+        vec![Symbol::Number(7), Symbol::Div, Symbol::Number(8)],
+        vec![Symbol::Number(8), Symbol::Exp, Symbol::Number(9)],
     ];
     assert!(tokenized_input == result);
 }
@@ -131,11 +111,10 @@ fn tokenize(input: &str) -> Result<Vec<Symbol>, ParseError> {
 
     for (i, c) in input.chars().enumerate() {
         if !c.is_ascii_digit() && !acc.is_empty() {
-            tokens.push(Symbol::Number {
-                value: acc
-                    .parse()
+            tokens.push(Symbol::Number(
+                acc.parse()
                     .map_err(|_| ParseError::WrongTokenError { pos: 1 })?,
-            });
+            ));
             acc.clear();
         };
         match c {
@@ -156,12 +135,11 @@ fn tokenize(input: &str) -> Result<Vec<Symbol>, ParseError> {
         }
     }
     if !acc.is_empty() {
-        tokens.push(Symbol::Number {
-            value: acc
-                .parse()
-                .map_err(|_| ParseError::WrongTokenError { pos: 1 })?,
-        });
-    }
+        tokens.push(Symbol::Number(
+            acc.parse()
+                .map_err(|_| ParseError::WrongTokenError { pos: 5 })?,
+        ));
+    };
 
     Ok(tokens)
 }
@@ -175,22 +153,28 @@ fn ast(input: Vec<Symbol>) -> Result<Node, ParseError> {
     while i < length {
         let s = &input[i];
         match s {
-            Symbol::Number { value } => {
-                stack.push(Node::Number { value: *value });
+            Symbol::Number(value) => {
+                // stack.push(Node::Number { value: *value });
             }
             Symbol::Add => {
-                let left = stack.pop();
+                // let left = stack.pop();
                 // increment
+                let left = input.get(i - 1);
                 let right = input.get(i + 1);
                 i += 1;
 
+                if let Some(l) = left {
+                    if let Some(r) = right {
+                        if let Symbol::Number(v1) = l {}
+                    }
+                }
                 match (left, right) {
                     (Some(left), Some(right)) => {
                         match right {
-                            Symbol::Number { value } => {
+                            Symbol::Number(right) => {
                                 stack.push(Node::Add {
-                                    left: (Box::new(left)),
-                                    right: (Box::new(Node::Number { value: *value })),
+                                    left: (Box::new(Node::Number(left))),
+                                    right: (Box::new(Node::Number(right))),
                                 });
                             }
                             _ => return Err(ParseError::WrongTokenError { pos: 1 }),
@@ -216,3 +200,13 @@ fn ast(input: Vec<Symbol>) -> Result<Node, ParseError> {
     }
     Ok(stack[0].clone())
 }
+
+fn push_to_ast(s: &Symbol, stack: &mut Vec<Node>, input: &mut Vec<Symbol>, index: usize) {
+    let left = stack.pop();
+    // increment
+    let right = input.get(index + 1);
+    match s {
+        Symbol::Add => {}
+        _ => {}
+    }
+}