Split main by files

src/main.rs

@@ -1,7 +1,13 @@
-use std::collections::HashMap;
 use std::io;
 use std::io::Write;
 
+mod tokenizer;
+use tokenizer::tokenizer;
+
+mod rpn;
+use rpn::to_rpn;
+
+
 fn main() {
   let stdin = io::stdin();
   let mut buffer = String::new();
@@ -12,107 +18,9 @@ fn main() {
 
     stdin.read_line(&mut buffer).unwrap();
 
-    let tokens = tokenisator(&buffer);
+    let tokens = tokenizer(&buffer);
     let rpn = to_rpn(tokens);
 
     buffer.clear();
   }
 }
-
-fn tokenisator(task: &str) -> Vec<Token> {
-  let mut tokens = Vec::<Token>::new();
-  let chars: Vec<char> = task.chars().collect();
-  let mut pointer = 0;
-
-  while pointer < task.len() {
-    dbg!(pointer, task.len());
-
-    let c = chars[pointer];
-    match c {
-      '0' .. '9' => {
-        let mut end = pointer;
-        while end < task.len() {
-          let cur_c = chars[end];
-          if !cur_c.is_ascii_digit() {
-            break;
-          }
-          end += 1;
-        }
-        tokens.push(Token::Number(
-          task.get(pointer..end).unwrap().parse::<i32>().unwrap()
-        ));
-        pointer = end-1;
-      }
-      '+' => tokens.push(Token::Addition),
-      '-' => tokens.push(Token::Substruction),
-      '*' => tokens.push(Token::Multiplication),
-      '/' => tokens.push(Token::Division),
-      '(' => tokens.push(Token::BracketOpen),
-      ')' => tokens.push(Token::BracketClose),
-      _ => {}
-    }
-
-    pointer += 1;
-  }
-
-  println!("{}", task);
-
-  for t in &tokens {
-    println!("{:?}", t);
-  }
-
-  return tokens;
-}
-
-fn to_rpn(tokens: Vec<Token>) -> Vec<Token> {
-  let mut out_buf = Vec::<Token>::new();
-  let mut act_buf = Vec::<Token>::new();
-
-  let priority = HashMap::from([
-    (Token::BracketOpen,    0),
-    (Token::Addition,       1),
-    (Token::Substruction,   1),
-    (Token::Multiplication, 2),
-    (Token::Division,       2),
-  ]);
-
-  for t in tokens {
-    match t {
-      Token::Number(_) => out_buf.push(t),
-      Token::BracketOpen => act_buf.push(t),
-      Token::BracketClose => {
-        while matches!(act_buf.last().unwrap(), Token::BracketOpen) {
-          out_buf.push(act_buf.pop().unwrap());
-        }
-        act_buf.pop();
-      }
-      _ => {
-        if !act_buf.is_empty() {
-          while priority.get(&t).unwrap() < priority.get(act_buf.last().unwrap()).unwrap() {
-            out_buf.push(act_buf.pop().unwrap());
-            if act_buf.is_empty() { break; }
-          }
-        }
-
-        act_buf.push(t);
-      }
-    }
-  }
-
-  act_buf.reverse();
-  out_buf.append(&mut act_buf);
-
-  return out_buf;
-}
-
-#[derive(Debug)]
-#[derive(Eq, Hash, PartialEq)]
-enum Token {
-  Number(i32),
-  Addition,
-  Substruction,
-  Multiplication,
-  Division,
-  BracketOpen,
-  BracketClose,
-}

src/rpn.rs

@@ -0,0 +1,45 @@
+use std::collections::HashMap;
+
+use crate::tokenizer::Token;
+
+
+pub fn to_rpn(tokens: Vec<Token>) -> Vec<Token> {
+  let mut out_buf = Vec::<Token>::new();
+  let mut act_buf = Vec::<Token>::new();
+
+  let priority = HashMap::from([
+    (Token::BracketOpen,    0),
+    (Token::Addition,       1),
+    (Token::Substruction,   1),
+    (Token::Multiplication, 2),
+    (Token::Division,       2),
+  ]);
+
+  for t in tokens {
+    match t {
+      Token::Number(_) => out_buf.push(t),
+      Token::BracketOpen => act_buf.push(t),
+      Token::BracketClose => {
+        while matches!(act_buf.last().unwrap(), Token::BracketOpen) {
+          out_buf.push(act_buf.pop().unwrap());
+        }
+        act_buf.pop();
+      }
+      _ => {
+        if !act_buf.is_empty() {
+          while priority.get(&t).unwrap() < priority.get(act_buf.last().unwrap()).unwrap() {
+            out_buf.push(act_buf.pop().unwrap());
+            if act_buf.is_empty() { break; }
+          }
+        }
+
+        act_buf.push(t);
+      }
+    }
+  }
+
+  act_buf.reverse();
+  out_buf.append(&mut act_buf);
+
+  return out_buf;
+}

src/tokenizer.rs

@@ -0,0 +1,57 @@
+#[derive(Debug)]
+#[derive(Eq, Hash, PartialEq)]
+pub enum Token {
+  Number(i32),
+  Addition,
+  Substruction,
+  Multiplication,
+  Division,
+  BracketOpen,
+  BracketClose,
+}
+
+
+pub fn tokenizer(task: &str) -> Vec<Token> {
+  let mut tokens = Vec::<Token>::new();
+  let chars: Vec<char> = task.chars().collect();
+  let mut pointer = 0;
+
+  while pointer < task.len() {
+    dbg!(pointer, task.len());
+
+    let c = chars[pointer];
+    match c {
+      '0' .. '9' => {
+        let mut end = pointer;
+        while end < task.len() {
+          let cur_c = chars[end];
+          if !cur_c.is_ascii_digit() {
+            break;
+          }
+          end += 1;
+        }
+        tokens.push(Token::Number(
+          task.get(pointer..end).unwrap().parse::<i32>().unwrap()
+        ));
+        pointer = end-1;
+      }
+      '+' => tokens.push(Token::Addition),
+      '-' => tokens.push(Token::Substruction),
+      '*' => tokens.push(Token::Multiplication),
+      '/' => tokens.push(Token::Division),
+      '(' => tokens.push(Token::BracketOpen),
+      ')' => tokens.push(Token::BracketClose),
+      _ => {}
+    }
+
+    pointer += 1;
+  }
+
+  println!("{}", task);
+
+  for t in &tokens {
+    println!("{:?}", t);
+  }
+
+  return tokens;
+}