From 99b9ee975a704e1f37c5a055653493d0b198cf14 Mon Sep 17 00:00:00 2001 From: Mark Date: Mon, 4 Mar 2024 17:59:05 -0800 Subject: [PATCH] Board cleanup --- src/{ => board}/board.rs | 177 ++++----------------------------------- src/board/mod.rs | 12 +++ src/board/tree.rs | 143 +++++++++++++++++++++++++++++++ 3 files changed, 171 insertions(+), 161 deletions(-) rename src/{ => board}/board.rs (71%) create mode 100644 src/board/mod.rs create mode 100644 src/board/tree.rs diff --git a/src/board.rs b/src/board/board.rs similarity index 71% rename from src/board.rs rename to src/board/board.rs index dc75c35..0693019 100644 --- a/src/board.rs +++ b/src/board/board.rs @@ -1,169 +1,22 @@ -use std::fmt::{Debug, Display}; +use std::fmt::Display; + use termion::color; -use crate::{Player, Symb}; - -#[derive(Debug, PartialEq, Clone)] -pub enum Token { - Value(String), - OpAdd, - OpSub, - OpMult, - OpDiv, -} - -#[derive(PartialEq, Clone)] -pub enum TreeElement { - Partial(String), - Number(f32), - Add { - l: Box, - r: Box, - }, - Sub { - l: Box, - r: Box, - }, - Mul { - l: Box, - r: Box, - }, - Div { - l: Box, - r: Box, - }, - Neg { - r: Box, - }, -} - -impl Display for TreeElement { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - match self { - Self::Partial(s) => write!(f, "{s}")?, - Self::Number(n) => write!(f, "{n}")?, - Self::Add { l, r } => write!(f, "({l}+{r})")?, - Self::Div { l, r } => write!(f, "({l}÷{r})")?, - Self::Mul { l, r } => write!(f, "({l}×{r})")?, - Self::Sub { l, r } => write!(f, "({l}-{r})")?, - Self::Neg { r } => write!(f, "(-{r})")?, - } - Ok(()) - } -} - -impl Debug for TreeElement { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - Display::fmt(&self, f) - } -} +use super::{PlayerAction, TreeElement}; +use crate::util::{Player, Symb}; enum InterTreeElement { Unprocessed(Token), Processed(TreeElement), } -#[allow(dead_code)] -impl TreeElement { - pub fn left(&self) -> Option<&TreeElement> { - match self { - Self::Add { l, .. } - | Self::Sub { l, .. } - | Self::Mul { l, .. } - | Self::Div { l, .. } => Some(&**l), - _ => None, - } - } - - pub fn right(&self) -> Option<&TreeElement> { - match self { - Self::Add { r, .. } - | Self::Neg { r, .. } - | Self::Sub { r, .. } - | Self::Mul { r, .. } - | Self::Div { r, .. } => Some(&**r), - _ => None, - } - } - - pub fn left_mut(&mut self) -> Option<&mut TreeElement> { - match self { - Self::Add { l, .. } - | Self::Sub { l, .. } - | Self::Mul { l, .. } - | Self::Div { l, .. } => Some(&mut **l), - _ => None, - } - } - - pub fn right_mut(&mut self) -> Option<&mut TreeElement> { - match self { - Self::Add { r, .. } - | Self::Neg { r, .. } - | Self::Sub { r, .. } - | Self::Mul { r, .. } - | Self::Div { r, .. } => Some(&mut **r), - _ => None, - } - } -} - -pub struct PlayerAction { - pub symb: Symb, - pub pos: usize, -} - -impl TreeElement { - pub fn evaluate(&self) -> Option { - match self { - Self::Number(x) => Some(*x), - Self::Partial(_) => None, - Self::Add { l, r } => { - let l = l.evaluate(); - let r = r.evaluate(); - if let (Some(l), Some(r)) = (l, r) { - Some(l + r) - } else { - None - } - } - Self::Mul { l, r } => { - let l = l.evaluate(); - let r = r.evaluate(); - if let (Some(l), Some(r)) = (l, r) { - Some(l * r) - } else { - None - } - } - Self::Div { l, r } => { - let l = l.evaluate(); - let r = r.evaluate(); - if let (Some(l), Some(r)) = (l, r) { - Some(l / r) - } else { - None - } - } - Self::Sub { l, r } => { - let l = l.evaluate(); - let r = r.evaluate(); - if let (Some(l), Some(r)) = (l, r) { - Some(l - r) - } else { - None - } - } - Self::Neg { r } => { - let r = r.evaluate(); - if let Some(r) = r { - Some(-r) - } else { - None - } - } - } - } +#[derive(Debug, PartialEq, Clone)] +enum Token { + Value(String), + OpAdd, + OpSub, + OpMult, + OpDiv, } #[derive(Clone)] @@ -299,7 +152,7 @@ impl Board { true } - pub fn tokenize(&self) -> Vec { + fn tokenize(&self) -> Vec { let mut tokens = Vec::new(); let mut is_neg = true; // if true, - is negative. if false, subtract. let mut current_num = String::new(); @@ -353,7 +206,9 @@ impl Board { tokens } - pub fn treeify(tokens: &Vec) -> TreeElement { + pub fn to_tree(&self) -> TreeElement { + let tokens = self.tokenize(); + let mut tree: Vec<_> = tokens .iter() .map(|x| InterTreeElement::Unprocessed(x.clone())) @@ -468,7 +323,7 @@ impl Board { } pub fn evaluate(&self) -> Option { - Self::treeify(&self.tokenize()).evaluate() + self.to_tree().evaluate() } /// Hacky method to parse a board from a string diff --git a/src/board/mod.rs b/src/board/mod.rs new file mode 100644 index 0000000..aabb28c --- /dev/null +++ b/src/board/mod.rs @@ -0,0 +1,12 @@ +mod board; +mod tree; + +pub use board::Board; +pub use tree::TreeElement; + +use crate::Symb; + +pub struct PlayerAction { + pub symb: Symb, + pub pos: usize, +} diff --git a/src/board/tree.rs b/src/board/tree.rs new file mode 100644 index 0000000..8152766 --- /dev/null +++ b/src/board/tree.rs @@ -0,0 +1,143 @@ +use std::fmt::{Debug, Display}; + +#[derive(PartialEq, Clone)] +pub enum TreeElement { + Partial(String), + Number(f32), + Add { + l: Box, + r: Box, + }, + Sub { + l: Box, + r: Box, + }, + Mul { + l: Box, + r: Box, + }, + Div { + l: Box, + r: Box, + }, + Neg { + r: Box, + }, +} + +impl Display for TreeElement { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + Self::Partial(s) => write!(f, "{s}")?, + Self::Number(n) => write!(f, "{n}")?, + Self::Add { l, r } => write!(f, "({l}+{r})")?, + Self::Div { l, r } => write!(f, "({l}÷{r})")?, + Self::Mul { l, r } => write!(f, "({l}×{r})")?, + Self::Sub { l, r } => write!(f, "({l}-{r})")?, + Self::Neg { r } => write!(f, "(-{r})")?, + } + Ok(()) + } +} + +impl Debug for TreeElement { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + Display::fmt(&self, f) + } +} + +#[allow(dead_code)] +impl TreeElement { + pub fn left(&self) -> Option<&TreeElement> { + match self { + Self::Add { l, .. } + | Self::Sub { l, .. } + | Self::Mul { l, .. } + | Self::Div { l, .. } => Some(&**l), + _ => None, + } + } + + pub fn right(&self) -> Option<&TreeElement> { + match self { + Self::Add { r, .. } + | Self::Neg { r, .. } + | Self::Sub { r, .. } + | Self::Mul { r, .. } + | Self::Div { r, .. } => Some(&**r), + _ => None, + } + } + + pub fn left_mut(&mut self) -> Option<&mut TreeElement> { + match self { + Self::Add { l, .. } + | Self::Sub { l, .. } + | Self::Mul { l, .. } + | Self::Div { l, .. } => Some(&mut **l), + _ => None, + } + } + + pub fn right_mut(&mut self) -> Option<&mut TreeElement> { + match self { + Self::Add { r, .. } + | Self::Neg { r, .. } + | Self::Sub { r, .. } + | Self::Mul { r, .. } + | Self::Div { r, .. } => Some(&mut **r), + _ => None, + } + } + + pub fn evaluate(&self) -> Option { + match self { + Self::Number(x) => Some(*x), + Self::Partial(_) => None, + Self::Add { l, r } => { + let l = l.evaluate(); + let r = r.evaluate(); + if let (Some(l), Some(r)) = (l, r) { + Some(l + r) + } else { + None + } + } + Self::Mul { l, r } => { + let l = l.evaluate(); + let r = r.evaluate(); + if let (Some(l), Some(r)) = (l, r) { + Some(l * r) + } else { + None + } + } + Self::Div { l, r } => { + let l = l.evaluate(); + let r = r.evaluate(); + if let (Some(l), Some(r)) = (l, r) { + Some(l / r) + } else { + None + } + } + Self::Sub { l, r } => { + let l = l.evaluate(); + let r = r.evaluate(); + if let (Some(l), Some(r)) = (l, r) { + Some(l - r) + } else { + None + } + } + Self::Neg { r } => { + let r = r.evaluate(); + if let Some(r) = r { + Some(-r) + } else { + None + } + } + } + } +}