feat(ex05): done + rustfmt oops

src/adder.rs

@@ -12,4 +12,3 @@ pub fn adder(a: u32, b: u32) -> u32 {
     }
     result
 }
-

src/ast.rs

@@ -1,22 +1,24 @@
 mod tests;
 
-
-#[derive(Debug, Clone, PartialEq)]
+#[derive(Debug, Clone, Copy, PartialEq)]
 pub enum Token {
     Negation,
     Conjunction,
     Disjunction,
     ExclusiveDisjunction,
     MaterialCondition,
-    LogicalEquivalence
+    LogicalEquivalence,
 }
 
 #[derive(Debug, Clone, PartialEq)]
-pub enum Node<T> {
+pub enum Node<T>
+where
+    T: Clone + std::fmt::Debug,
+{
     Leaf(T),
     Unary {
         operator: Token,
-        operand: Box<Node<T>>
+        operand: Box<Node<T>>,
     },
     Binary {
         operator: Token,
@@ -25,6 +27,208 @@ pub enum Node<T> {
     },
 }
 
+impl<T> Node<T>
+where
+    T: Clone + std::fmt::Debug,
+{
+    fn negation_conjunction_to_nnf(lhs: &Box<Node<T>>, rhs: &Box<Node<T>>) -> Node<T> {
+        Node::Binary {
+            operator: Token::Disjunction,
+            lhs: Box::new(Node::Unary {
+                operator: Token::Negation,
+                operand: Box::new(*lhs.clone()),
+            }),
+            rhs: Box::new(Node::Unary {
+                operator: Token::Negation,
+                operand: Box::new(*rhs.clone()),
+            }),
+        }
+    }
+
+    fn negation_disjunction_to_nnf(lhs: &Box<Node<T>>, rhs: &Box<Node<T>>) -> Node<T> {
+        Node::Binary {
+            operator: Token::Conjunction,
+            lhs: Box::new(Node::Unary {
+                operator: Token::Negation,
+                operand: Box::new(*lhs.clone()),
+            }),
+            rhs: Box::new(Node::Unary {
+                operator: Token::Negation,
+                operand: Box::new(*rhs.clone()),
+            }),
+        }
+    }
+
+    fn negation_material_condition_to_nnf(lhs: &Box<Node<T>>, rhs: &Box<Node<T>>) -> Node<T> {
+        Node::Binary {
+            operator: Token::Conjunction,
+            lhs: Box::new(*lhs.clone()),
+            rhs: Box::new(Node::Unary {
+                operator: Token::Negation,
+                operand: Box::new(*rhs.clone()),
+            }),
+        }
+    }
+
+    fn material_condition_to_nnf(lhs: &Box<Node<T>>, rhs: &Box<Node<T>>) -> Node<T> {
+        Node::Binary {
+            operator: Token::Disjunction,
+            lhs: Box::new(Node::Unary {
+                operator: Token::Negation,
+                operand: Box::new(*lhs.clone()),
+            }),
+            rhs: Box::new(*rhs.clone()),
+        }
+    }
+
+    fn negation_exclusive_disjunction_to_nnf(lhs: &Box<Node<T>>, rhs: &Box<Node<T>>) -> Node<T> {
+        Node::Binary {
+            operator: Token::Disjunction,
+            lhs: Box::new(Node::Binary {
+                operator: Token::Conjunction,
+                lhs: Box::new(Node::Unary {
+                    operator: Token::Negation,
+                    operand: Box::new(*lhs.clone()),
+                }),
+                rhs: Box::new(Node::Unary {
+                    operator: Token::Negation,
+                    operand: Box::new(*rhs.clone()),
+                }),
+            }),
+            rhs: Box::new(Node::Binary {
+                operator: Token::Conjunction,
+                lhs: Box::new(*lhs.clone()),
+                rhs: Box::new(*rhs.clone()),
+            }),
+        }
+    }
+
+    fn exclusive_disjunction_to_nnf(lhs: &Box<Node<T>>, rhs: &Box<Node<T>>) -> Node<T> {
+        Node::Binary {
+            operator: Token::Conjunction,
+            lhs: Box::new(Node::Binary {
+                operator: Token::Disjunction,
+                lhs: Box::new(*lhs.clone()),
+                rhs: Box::new(*rhs.clone()),
+            }),
+            rhs: Box::new(Node::Binary {
+                operator: Token::Disjunction,
+                lhs: Box::new(Node::Unary {
+                    operator: Token::Negation,
+                    operand: Box::new(*lhs.clone()),
+                }),
+                rhs: Box::new(Node::Unary {
+                    operator: Token::Negation,
+                    operand: Box::new(*rhs.clone()),
+                }),
+            }),
+        }
+    }
+
+    fn logical_equivalence_to_nnf(lhs: &Box<Node<T>>, rhs: &Box<Node<T>>) -> Node<T> {
+        Node::Binary {
+            operator: Token::Conjunction,
+            lhs: Box::new(Node::Binary {
+                operator: Token::Disjunction,
+                lhs: Box::new(Node::Unary {
+                    operator: Token::Negation,
+                    operand: Box::new(*lhs.clone()),
+                }),
+                rhs: Box::new(*rhs.clone()),
+            }),
+            rhs: Box::new(Node::Binary {
+                operator: Token::Disjunction,
+                lhs: Box::new(Node::Unary {
+                    operator: Token::Negation,
+                    operand: Box::new(*rhs.clone()),
+                }),
+                rhs: Box::new(*lhs.clone()),
+            }),
+        }
+    }
+
+    fn negation_logical_equivalence_to_nnf(lhs: &Box<Node<T>>, rhs: &Box<Node<T>>) -> Node<T> {
+        Node::Binary {
+            operator: Token::Disjunction,
+            lhs: Box::new(Node::Binary {
+                operator: Token::Conjunction,
+                lhs: Box::new(*lhs.clone()),
+                rhs: Box::new(Node::Unary {
+                    operator: Token::Negation,
+                    operand: Box::new(*rhs.clone()),
+                }),
+            }),
+            rhs: Box::new(Node::Binary {
+                operator: Token::Conjunction,
+                lhs: Box::new(*rhs.clone()),
+                rhs: Box::new(Node::Unary {
+                    operator: Token::Negation,
+                    operand: Box::new(*lhs.clone()),
+                }),
+            }),
+        }
+    }
+
+    pub fn simplify(&mut self) {
+        match self {
+            Node::Unary { operator, operand } if *operator == Token::Negation => match &**operand {
+                Node::Unary {
+                    operator: inner_op,
+                    operand: inner_operand,
+                } if *inner_op == Token::Negation => {
+                    *self = *inner_operand.clone();
+                    self.simplify();
+                }
+                Node::Binary {
+                    operator: inner_op,
+                    lhs: inner_lhs,
+                    rhs: inner_rhs,
+                } => {
+                    *self = match *inner_op {
+                        Token::Conjunction => {
+                            Self::negation_conjunction_to_nnf(inner_lhs, inner_rhs)
+                        }
+                        Token::Disjunction => {
+                            Self::negation_disjunction_to_nnf(inner_lhs, inner_rhs)
+                        }
+                        Token::ExclusiveDisjunction => {
+                            Self::negation_exclusive_disjunction_to_nnf(inner_lhs, inner_rhs)
+                        }
+                        Token::LogicalEquivalence => {
+                            Self::negation_logical_equivalence_to_nnf(inner_lhs, inner_rhs)
+                        }
+                        Token::MaterialCondition => {
+                            Self::negation_material_condition_to_nnf(inner_lhs, inner_rhs)
+                        }
+                        _ => unreachable!(),
+                    };
+                    self.simplify();
+                }
+                _ => (),
+            },
+            Node::Binary {
+                operator, lhs, rhs, ..
+            } => {
+                if let Some(node) = match *operator {
+                    Token::ExclusiveDisjunction => {
+                        Some(Self::exclusive_disjunction_to_nnf(lhs, rhs))
+                    }
+                    Token::LogicalEquivalence => Some(Self::logical_equivalence_to_nnf(lhs, rhs)),
+                    Token::MaterialCondition => Some(Self::material_condition_to_nnf(lhs, rhs)),
+                    _ => None,
+                } {
+                    *self = node.clone();
+                    self.simplify();
+                } else {
+                    lhs.simplify();
+                    rhs.simplify();
+                }
+            }
+            _ => (),
+        }
+    }
+}
+
 impl Node<bool> {
     pub fn parse_formula(formula: &str) -> Node<bool> {
         let mut stack = vec![];
@@ -38,29 +242,29 @@ impl Node<bool> {
                 '^' => add_binary_node(&mut stack, Token::ExclusiveDisjunction),
                 '>' => add_binary_node(&mut stack, Token::MaterialCondition),
                 '=' => add_binary_node(&mut stack, Token::LogicalEquivalence),
-                _ => panic!("Error: {} is not a valid character", c)
+                _ => panic!("Error: {} is not a valid character", c),
             }
         }
         stack.pop().unwrap()
     }
 
-    pub fn ast_to_formula(ast: Node<bool>) -> String {
+    pub fn ast_to_formula(ast: &Node<bool>) -> String {
         let mut str = String::from("");
         match ast {
             Node::Unary { operator, operand } => {
-                str.push_str(Self::ast_to_formula(*operand).as_str());
-                str.push(token_to_char(operator));
-            },
+                str.push_str(Self::ast_to_formula(operand).as_str());
+                str.push(token_to_char(*operator));
+            }
             Node::Binary { operator, lhs, rhs } => {
-                str.push_str(Self::ast_to_formula(*lhs).as_str());
-                str.push_str(Self::ast_to_formula(*rhs).as_str());
-                str.push(token_to_char(operator));
-            },
-            Node::Leaf(b) => str.push(bool_to_char(b)),
+                str.push_str(Self::ast_to_formula(lhs).as_str());
+                str.push_str(Self::ast_to_formula(rhs).as_str());
+                str.push(token_to_char(*operator));
+            }
+            Node::Leaf(b) => str.push(bool_to_char(*b)),
         };
         str
     }
-}   
+}
 
 impl Node<char> {
     pub fn parse_formula(formula: &str) -> Node<char> {
@@ -74,31 +278,34 @@ impl Node<char> {
                 '^' => add_binary_node(&mut stack, Token::ExclusiveDisjunction),
                 '>' => add_binary_node(&mut stack, Token::MaterialCondition),
                 '=' => add_binary_node(&mut stack, Token::LogicalEquivalence),
-                _ => panic!("Error: {} is not a valid character", c)
+                _ => panic!("Error: {} is not a valid character", c),
             }
         }
         stack.pop().unwrap()
     }
 
-    pub fn ast_to_formula(ast: Node<char>) -> String {
+    pub fn ast_to_formula(ast: &Node<char>) -> String {
         let mut str = String::from("");
         match ast {
             Node::Unary { operator, operand } => {
-                str.push_str(Self::ast_to_formula(*operand).as_str());
-                str.push(token_to_char(operator));
-            },
+                str.push_str(Self::ast_to_formula(operand).as_str());
+                str.push(token_to_char(*operator));
+            }
             Node::Binary { operator, lhs, rhs } => {
-                str.push_str(Self::ast_to_formula(*lhs).as_str());
-                str.push_str(Self::ast_to_formula(*rhs).as_str());
-                str.push(token_to_char(operator));
-            },
-            Node::Leaf(c) => str.push(c),
+                str.push_str(Self::ast_to_formula(lhs).as_str());
+                str.push_str(Self::ast_to_formula(rhs).as_str());
+                str.push(token_to_char(*operator));
+            }
+            Node::Leaf(c) => str.push(*c),
         };
         str
     }
 }
 
-pub fn add_unary_node<T>(stack: &mut Vec<Node<T>>, token: Token) {
+pub fn add_unary_node<T>(stack: &mut Vec<Node<T>>, token: Token)
+where
+    T: Clone + std::fmt::Debug,
+{
     let operand = Box::new(stack.pop().unwrap());
     stack.push(Node::Unary {
         operator: token,
@@ -106,31 +313,33 @@ pub fn add_unary_node<T>(stack: &mut Vec<Node<T>>, token: Token) {
     });
 }
 
-pub fn add_binary_node<T>(stack: &mut Vec<Node<T>>, token: Token) {
+pub fn add_binary_node<T>(stack: &mut Vec<Node<T>>, token: Token)
+where
+    T: Clone + std::fmt::Debug,
+{
     let rhs = Box::new(stack.pop().unwrap());
     let lhs = Box::new(stack.pop().unwrap());
     stack.push(Node::Binary {
         operator: token,
         lhs,
-        rhs
+        rhs,
     });
 }
 
 fn bool_to_char(b: bool) -> char {
     match b {
         false => '0',
-        true => '1'
+        true => '1',
     }
 }
 
 fn token_to_char(token: Token) -> char {
     match token {
         Token::Negation => '!',
-        Token::Conjunction =>'&',
+        Token::Conjunction => '&',
         Token::Disjunction => '|',
         Token::ExclusiveDisjunction => '^',
         Token::MaterialCondition => '>',
         Token::LogicalEquivalence => '=',
     }
 }
-

src/ast/tests.rs

@@ -1,6 +1,6 @@
 #[cfg(test)]
 mod tests {
-    use crate::ast::{ add_binary_node, Node, Token };
+    use crate::ast::{add_binary_node, Node, Token};
 
     #[test]
     fn add_nodes() {
@@ -8,7 +8,7 @@ mod tests {
         let rhs = vec![Node::Binary {
             operator: Token::Conjunction,
             lhs: Box::new(Node::Leaf(true)),
-            rhs: Box::new(Node::Leaf(false))
+            rhs: Box::new(Node::Leaf(false)),
         }];
         add_binary_node(&mut stack, Token::Conjunction);
         assert_eq!(stack, rhs);
@@ -17,28 +17,58 @@ mod tests {
     #[test]
     fn ast_to_formula_bool() {
         let formula = "01&";
-        assert_eq!(Node::<bool>::ast_to_formula(Node::<bool>::parse_formula(formula)), formula);
+        assert_eq!(
+            Node::<bool>::ast_to_formula(&Node::<bool>::parse_formula(formula)),
+            formula
+        );
         let formula = "01&00|&";
-        assert_eq!(Node::<bool>::ast_to_formula(Node::<bool>::parse_formula(formula)), formula);
+        assert_eq!(
+            Node::<bool>::ast_to_formula(&Node::<bool>::parse_formula(formula)),
+            formula
+        );
         let formula = "01&00|&11^&";
-        assert_eq!(Node::<bool>::ast_to_formula(Node::<bool>::parse_formula(formula)), formula);
+        assert_eq!(
+            Node::<bool>::ast_to_formula(&Node::<bool>::parse_formula(formula)),
+            formula
+        );
         let formula = "01&00|&11=^";
-        assert_eq!(Node::<bool>::ast_to_formula(Node::<bool>::parse_formula(formula)), formula);
+        assert_eq!(
+            Node::<bool>::ast_to_formula(&Node::<bool>::parse_formula(formula)),
+            formula
+        );
         let formula = "01&00|&0!=";
-        assert_eq!(Node::<bool>::ast_to_formula(Node::<bool>::parse_formula(formula)), formula);
+        assert_eq!(
+            Node::<bool>::ast_to_formula(&Node::<bool>::parse_formula(formula)),
+            formula
+        );
     }
 
     #[test]
     fn ast_to_formula_char() {
         let formula = "AB&";
-        assert_eq!(Node::<char>::ast_to_formula(Node::<char>::parse_formula(formula)), formula);
+        assert_eq!(
+            Node::<char>::ast_to_formula(&Node::<char>::parse_formula(formula)),
+            formula
+        );
         let formula = "AB&CD|&";
-        assert_eq!(Node::<char>::ast_to_formula(Node::<char>::parse_formula(formula)), formula);
+        assert_eq!(
+            Node::<char>::ast_to_formula(&Node::<char>::parse_formula(formula)),
+            formula
+        );
         let formula = "AB&AC|&DE^&";
-        assert_eq!(Node::<char>::ast_to_formula(Node::<char>::parse_formula(formula)), formula);
+        assert_eq!(
+            Node::<char>::ast_to_formula(&Node::<char>::parse_formula(formula)),
+            formula
+        );
         let formula = "AB&CD|&EF=^";
-        assert_eq!(Node::<char>::ast_to_formula(Node::<char>::parse_formula(formula)), formula);
+        assert_eq!(
+            Node::<char>::ast_to_formula(&Node::<char>::parse_formula(formula)),
+            formula
+        );
         let formula = "AB&CD|&E!=";
-        assert_eq!(Node::<char>::ast_to_formula(Node::<char>::parse_formula(formula)), formula);
+        assert_eq!(
+            Node::<char>::ast_to_formula(&Node::<char>::parse_formula(formula)),
+            formula
+        );
     }
-}
+}

src/boolean_evaluation.rs

@@ -1,6 +1,6 @@
 mod tests;
 
-use crate::ast::{ Token, Node };
+use crate::ast::{Node, Token};
 
 fn compute(operator: Token, lhs: bool, rhs: bool) -> bool {
     match operator {
@@ -9,7 +9,7 @@ fn compute(operator: Token, lhs: bool, rhs: bool) -> bool {
         Token::Disjunction => lhs | rhs,
         Token::ExclusiveDisjunction => lhs ^ rhs,
         Token::MaterialCondition => !(lhs && !rhs),
-        Token::LogicalEquivalence => lhs == rhs
+        Token::LogicalEquivalence => lhs == rhs,
     }
 }
 
@@ -24,4 +24,4 @@ fn evaluate(tree: Node<bool>) -> bool {
 pub fn eval_formula(formula: &str) -> bool {
     let tree = Node::<bool>::parse_formula(formula);
     evaluate(tree)
-}
+}

src/boolean_evaluation/tests.rs

@@ -22,7 +22,10 @@ mod tests {
         assert_eq!(eval_formula("1!!"), true);
         assert_eq!(eval_formula("0!!"), false);
         assert_eq!(eval_formula("0!!!"), true);
-        assert_eq!(eval_formula("1!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"), true);
+        assert_eq!(
+            eval_formula("1!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"),
+            true
+        );
     }
 
     #[test]

src/gray_code.rs

@@ -10,4 +10,3 @@ pub fn gray_code(n: u32) -> u32 {
     }
     result
 }
-

src/gray_code/tests.rs

@@ -20,6 +20,6 @@ mod tests {
     fn msb_u32() {
         assert_eq!(gray_code(3_000_000_000), 3_954_733_312);
         assert_eq!(gray_code(2_147_483_648), 3_221_225_472);
-		assert_eq!(gray_code(4_294_967_295), 2_147_483_648);
+        assert_eq!(gray_code(4_294_967_295), 2_147_483_648);
     }
 }

src/main.rs

@@ -1,10 +1,10 @@
 mod adder;
-mod multiplier;
-mod gray_code;
-mod boolean_evaluation;
-mod truth_table;
 mod ast;
+mod boolean_evaluation;
+mod gray_code;
+mod multiplier;
 mod negation_normal_form;
+mod truth_table;
 
 use gray_code::gray_code;
 use truth_table::print_truth_table;

src/multiplier.rs

@@ -4,7 +4,7 @@ use crate::adder::adder;
 
 pub fn multiplier(a: u32, b: u32) -> u32 {
     let mut result = 0;
-    
+
     for i in 0..32 {
         if a >> i & 1 == 1 {
             result = adder(result, b << i);

src/negation_normal_form.rs

@@ -2,29 +2,8 @@ mod tests;
 
 use crate::ast::Node;
 
-// fn cancel_double_negation(ast: Node<char>) {
-//     let mut new_ast = ast.clone();
-
-//     fn recursion(ast: &mut Node<char>, node_count: usize) {
-//         match ast {
-//             Node::Unary { operator: _, operand } => {
-//                 recursion(&mut *operand, node_count + 1);
-//             },
-//             Node::Binary { operator: _, lhs, rhs } => {
-//                 recursion(&mut *lhs, node_count + 1);
-//                 recursion(&mut *rhs, node_count + 1);
-//             },
-//             Node::Leaf(c) => (),
-//         }
-//     }
-
-//     recursion(&mut new_ast, 0);
-
-//     new_ast
-// }
-
 fn negation_normal_form(formula: &str) -> String {
-    let ast = Node::<char>::parse_formula(formula);
-
-    Node::<char>::ast_to_formula(ast)
-}
+    let mut ast = Node::<char>::parse_formula(formula);
+    ast.simplify();
+    Node::<char>::ast_to_formula(&ast)
+}

src/negation_normal_form/tests.rs

@@ -3,21 +3,66 @@ mod tests {
     use crate::negation_normal_form::negation_normal_form;
 
     #[test]
-    fn double_neg() {
+    fn double_neg_simple() {
         assert_eq!(negation_normal_form("A!!"), "A");
-        assert_eq!(negation_normal_form("A!!!!"), "A");
-        assert_eq!(negation_normal_form("A!!!"), "A!");
-        assert_eq!(negation_normal_form("A!!!!!!!!!!!!!!!!"), "A");
-        assert_eq!(negation_normal_form("A!!!!!!!!!!!!!!!"), "A!");
+        assert_eq!(negation_normal_form("B!!!!"), "B");
+        assert_eq!(negation_normal_form("C!!!"), "C!");
+        assert_eq!(negation_normal_form("D!!!!!!!!!!!!!!!!"), "D");
+        assert_eq!(negation_normal_form("E!!!!!!!!!!!!!!!"), "E!");
+    }
+
+    #[test]
+    fn double_neg() {
+        assert_eq!(negation_normal_form("A!!Z&"), "AZ&");
+        assert_eq!(negation_normal_form("B!!Z!!&"), "BZ&");
+        assert_eq!(negation_normal_form("C!!Z!&"), "CZ!&");
+        assert_eq!(negation_normal_form("D!!Z&!!!!"), "DZ&");
+        assert_eq!(negation_normal_form("E!!Z!!!!&!!"), "EZ&");
+        assert_eq!(negation_normal_form("F!!Z!&!!!!!!!!"), "FZ!&");
     }
 
     #[test]
     fn neg_and() {
-        assert_eq!(negation_normal_form("AB&!"), "A!B!|");
+        assert_eq!(negation_normal_form("AZ&!"), "A!Z!|");
+        assert_eq!(negation_normal_form("BZ&!BZ&!&"), "B!Z!|B!Z!|&");
+        assert_eq!(negation_normal_form("CZ&!CZ&!&!"), "CZ&CZ&|");
     }
 
     #[test]
     fn neg_or() {
-        assert_eq!(negation_normal_form("AB|!"), "A!B!&");
+        assert_eq!(negation_normal_form("AZ|!"), "A!Z!&");
+        assert_eq!(negation_normal_form("BZ|!BZ|!|"), "B!Z!&B!Z!&|");
+        assert_eq!(negation_normal_form("CZ|!CZ|!|!"), "CZ|CZ|&");
     }
-}
+
+    #[test]
+    fn material_condition() {
+        assert_eq!(negation_normal_form("AZ>"), "A!Z|");
+        assert_eq!(negation_normal_form("BZ>!"), "BZ!&");
+    }
+
+    #[test]
+    fn exclusive_disjunction() {
+        assert_eq!(negation_normal_form("AZ^"), "AZ|A!Z!|&");
+        assert_eq!(negation_normal_form("BZ^!"), "B!Z!&BZ&|");
+    }
+
+    #[test]
+    fn logical_equivalence() {
+        assert_eq!(negation_normal_form("AZ="), "A!Z|Z!A|&");
+        assert_eq!(negation_normal_form("BZ=!"), "BZ!&ZB!&|");
+    }
+
+    #[test]
+    fn subject_tests() {
+        assert_eq!(negation_normal_form("AB&!"), "A!B!|");
+        assert_eq!(negation_normal_form("AB|!"), "A!B!&");
+        assert_eq!(negation_normal_form("AB>"), "A!B|");
+        assert_eq!(negation_normal_form("AB|C&!"), "A!B!&C!|");
+    }
+
+    #[test]
+    fn complex_tests() {
+        assert_eq!("A", "A");
+    }
+}

src/truth_table.rs

@@ -1,7 +1,7 @@
 mod tests;
 
+use crate::ast::{add_binary_node, add_unary_node, Node, Token};
 use std::collections::HashSet;
-use crate::ast::{ Token, Node, add_unary_node, add_binary_node };
 
 fn parse_formula(formula: &str) -> Node<bool> {
     let mut stack = vec![];
@@ -15,7 +15,7 @@ fn parse_formula(formula: &str) -> Node<bool> {
             '^' => add_binary_node(&mut stack, Token::ExclusiveDisjunction),
             '>' => add_binary_node(&mut stack, Token::MaterialCondition),
             '=' => add_binary_node(&mut stack, Token::LogicalEquivalence),
-            _ => panic!("Error: {} is not a valid character", c)
+            _ => panic!("Error: {} is not a valid character", c),
         }
     }
     stack.pop().unwrap()
@@ -28,7 +28,7 @@ fn compute(operator: Token, lhs: bool, rhs: bool) -> bool {
         Token::Disjunction => lhs | rhs,
         Token::ExclusiveDisjunction => lhs ^ rhs,
         Token::MaterialCondition => !(lhs && !rhs),
-        Token::LogicalEquivalence => lhs == rhs
+        Token::LogicalEquivalence => lhs == rhs,
     }
 }
 
@@ -45,7 +45,9 @@ fn get_hashset(formula: &str) -> HashSet<char> {
 
     for c in formula.chars() {
         match c {
-            'A'..='Z' => { hashset.insert(c); },
+            'A'..='Z' => {
+                hashset.insert(c);
+            }
             '!' | '&' | '|' | '^' | '>' | '=' => (),
             _ => panic!("Error: {} is not a valid character", c),
         }
@@ -61,8 +63,16 @@ fn eval_formula(formula: &str) -> bool {
 fn recursive_fn(formula: &str, mut vec: Vec<char>, format: String) {
     let char = vec.pop();
     if let Some(c) = char {
-        recursive_fn(formula.replace(c, "0").as_str(), vec.clone(), format!("{format} 0 |"));
-        recursive_fn(formula.replace(c, "1").as_str(), vec.clone(), format!("{format} 1 |"));
+        recursive_fn(
+            formula.replace(c, "0").as_str(),
+            vec.clone(),
+            format!("{format} 0 |"),
+        );
+        recursive_fn(
+            formula.replace(c, "1").as_str(),
+            vec.clone(),
+            format!("{format} 1 |"),
+        );
     } else {
         match eval_formula(formula) {
             false => println!("{format} 0 |"),
@@ -89,5 +99,5 @@ pub fn print_truth_table(formula: &str) {
     println!("{separator}");
     //dbg!(vec.clone());
     recursive_fn(formula, vec.into_iter().rev().collect(), String::from("|"));
-    // call eval formula a lot 
-}
+    // call eval formula a lot
+}