fmt. Removed some usage of macros

Dockerfile

@@ -12,7 +12,7 @@ RUN npm install
 RUN USER=root npm install -g @typespec/compiler && npm install -g @redocly/cli
 RUN npm run tsp-compile && npm run redoc-build
 
-FROM rust:1.79 as build
+FROM rust:1.80.1 as build
 
 COPY --from=static ./src/resources/static ./static
 

src/expressions/helpers.rs

@@ -1,6 +1,6 @@
-use std::rc::Rc;
 use crate::expressions::expression::Expression;
 use crate::expressions::operator::BinaryOperator;
+use std::rc::Rc;
 
 impl Expression {
     #[inline]
@@ -65,7 +65,11 @@ where
     L: Into<Rc<Expression>>,
     R: Into<Rc<Expression>>,
 {
-    Expression::Binary { left: left.into(), operator, right: right.into() }
+    Expression::Binary {
+        left: left.into(),
+        operator,
+        right: right.into(),
+    }
 }
 
 #[inline]

src/expressions/mod.rs

@@ -1,5 +1,5 @@
 pub mod expression;
-pub mod operator;
 pub mod helpers;
+pub mod operator;
 pub mod simplify;
-pub mod truth_table;
+pub mod truth_table;

src/expressions/operator.rs

@@ -9,6 +9,7 @@ pub enum BinaryOperator {
 }
 
 impl BinaryOperator {
+    #[must_use]
     pub fn eval(&self, left: bool, right: bool) -> bool {
         match self {
             BinaryOperator::And => left && right,
@@ -17,10 +18,12 @@ impl BinaryOperator {
         }
     }
 
+    #[must_use]
     pub fn is_and(&self) -> bool {
         matches!(self, BinaryOperator::And)
     }
 
+    #[must_use]
     pub fn is_or(&self) -> bool {
         matches!(self, BinaryOperator::Or)
     }

src/expressions/simplify.rs

@@ -146,7 +146,8 @@ macro_rules! absorption_law_opposites {
 
 #[macro_export]
 macro_rules! distributive_law_atomic_vs_binary {
-    ($left:expr, $right:expr, $operations:expr, $op:pat, $func1:expr, $func2:expr) => {
+    ($left:expr, $right:expr, $operations:expr, $op:pat, $func1:expr, $func2:expr) => {{
+        let before = $func2($left.clone(), $right.clone());
         match ($left.as_ref(), $right.as_ref()) {
             (
                 Expression::Atomic(_),
@@ -155,19 +156,13 @@ macro_rules! distributive_law_atomic_vs_binary {
                     operator: $op,
                     right: right_right,
                 },
-            ) => {
+            ) => do_it(
-                let right_left = right_left.distributive_law($operations);
+                &before,
-                let right_right = right_right.distributive_law($operations);
+                &right_left,
-                let before = $func2($left.clone(), $right.clone());
+                &right_right,
-                let after = $func1(
+                |left, right| $func1($func2($left.clone(), left), $func2($left.clone(), right)),
-                    $func2($left.clone(), right_left),
+                $operations,
-                    $func2($left.clone(), right_right),
+            ),
-                );
-                if let Some(operation) = Operation::new(&before, &after, Law::DistributiveLaw) {
-                    $operations.push(operation);
-                }
-                after
-            }
             (
                 Expression::Binary {
                     left: left_left,
@@ -175,25 +170,36 @@ macro_rules! distributive_law_atomic_vs_binary {
                     right: left_right,
                 },
                 Expression::Atomic(_),
-            ) => {
+            ) => do_it(
-                let left_left = left_left.distributive_law($operations);
+                &before,
-                let left_right = left_right.distributive_law($operations);
+                &left_left,
-                let before = $func2($left.clone(), $right.clone());
+                &left_right,
-                let after = $func1(
+                |left, right| $func1($func2(left, $right.clone()), $func2(right, $right.clone())),
-                    $func2(left_left, $right.clone()),
+                $operations,
-                    $func2(left_right, $right.clone()),
+            ),
-                );
-                if let Some(operation) = Operation::new(&before, &after, Law::DistributiveLaw) {
-                    $operations.push(operation);
-                }
-                after
-            }
             (left, right) => $func2(
                 left.distributive_law($operations),
                 right.distributive_law($operations),
             ),
         }
-    };
+    }};
+}
+
+// TODO name it
+fn do_it(
+    before: &Expression,
+    left: &Expression,
+    right: &Expression,
+    after_callback: impl Fn(Expression, Expression) -> Expression,
+    operations: &mut Vec<Operation>,
+) -> Expression {
+    let right_left = left.distributive_law(operations);
+    let right_right = right.distributive_law(operations);
+    let after = after_callback(right_left, right_right);
+    if let Some(operation) = Operation::new(before, &after, Law::DistributiveLaw) {
+        operations.push(operation);
+    }
+    after
 }
 
 #[derive(Debug, Default)]
@@ -330,13 +336,13 @@ impl Expression {
             } => {
                 #[rustfmt::skip] // TODO refactor
                 let after = if Expression::eq(left, right, ignore_case)
-                    || (operator.is_and() && (left.is_and() && right.is_in(left) || right.is_or()  && left.is_in(right)))
+                    || (operator.is_and() && (left.is_and() && right.is_in(left) || right.is_or() && left.is_in(right)))
-                    || (operator.is_or()  && (left.is_or()  && right.is_in(left) || right.is_and() && left.is_in(right)))
+                    || (operator.is_or() && (left.is_or() && right.is_in(left) || right.is_and() && left.is_in(right)))
                 {
                     left
                 } else if
-                       (operator.is_and() && (left.is_or()  && right.is_in(left) || right.is_and() && left.is_in(right)))
+                (operator.is_and() && (left.is_or() && right.is_in(left) || right.is_and() && left.is_in(right)))
-                    || (operator.is_or()  && (left.is_and() && right.is_in(left) || right.is_or()  && left.is_in(right)))
+                    || (operator.is_or() && (left.is_and() && right.is_in(left) || right.is_or() && left.is_in(right)))
                 {
                     right
                 } else {
@@ -411,7 +417,7 @@ impl Expression {
     }
 
     // A ⋀ (B ⋀ C) <=> (A ⋀ B) ⋀ C
-    fn associative_law(&self, operations: &mut Vec<Operation>) -> Self {
+    fn _associative_law(&self, _operations: &mut Vec<Operation>) -> Self {
         todo!("? | Associative law: (a ⋀ b) ⋀ c == a ⋀ (b ⋀ c) and (a ⋁ b) ⋁ c == a ⋁ (b ⋁ c)")
     }
 
@@ -423,28 +429,99 @@ impl Expression {
                 operator: BinaryOperator::And,
                 right,
             } => {
-                distributive_law_atomic_vs_binary!(
+                let before = and(left.clone(), right.clone());
-                    left,
+                match (left.as_ref(), right.as_ref()) {
-                    right,
+                    (
-                    operations,
+                        Expression::Atomic(_),
-                    BinaryOperator::Or,
+                        Expression::Binary {
-                    or,
+                            left: right_left,
-                    and
+                            operator: BinaryOperator::Or,
-                )
+                            right: right_right,
+                        },
+                    ) => do_it(
+                        &before,
+                        right_left,
+                        right_right,
+                        |inner_left, inner_right| {
+                            or(
+                                and(left.clone(), inner_left),
+                                and(left.clone(), inner_right),
+                            )
+                        },
+                        operations,
+                    ),
+                    (
+                        Expression::Binary {
+                            left: left_left,
+                            operator: BinaryOperator::Or,
+                            right: left_right,
+                        },
+                        Expression::Atomic(_),
+                    ) => do_it(
+                        &before,
+                        left_left,
+                        left_right,
+                        |inner_left, inner_right| {
+                            or(
+                                and(inner_left, right.clone()),
+                                and(inner_right, right.clone()),
+                            )
+                        },
+                        operations,
+                    ),
+                    (left, right) => and(
+                        left.distributive_law(operations),
+                        right.distributive_law(operations),
+                    ),
+                }
             }
             Expression::Binary {
                 left,
                 operator: BinaryOperator::Or,
                 right,
             } => {
-                distributive_law_atomic_vs_binary!(
+                let before = or(left.clone(), right.clone());
-                    left,
+                match (left.as_ref(), right.as_ref()) {
-                    right,
+                    (
-                    operations,
+                        Expression::Atomic(_),
-                    BinaryOperator::And,
+                        Expression::Binary {
-                    and,
+                            left: right_left,
-                    or
+                            operator: BinaryOperator::And,
-                )
+                            right: right_right,
+                        },
+                    ) => do_it(
+                        &before,
+                        right_left,
+                        right_right,
+                        |inner_left, inner_right| {
+                            and(or(left.clone(), inner_left), or(left.clone(), inner_right))
+                        },
+                        operations,
+                    ),
+                    (
+                        Expression::Binary {
+                            left: left_left,
+                            operator: BinaryOperator::And,
+                            right: left_right,
+                        },
+                        Expression::Atomic(_),
+                    ) => do_it(
+                        &before,
+                        left_left,
+                        left_right,
+                        |inner_left, inner_right| {
+                            and(
+                                or(inner_left, right.clone()),
+                                or(inner_right, right.clone()),
+                            )
+                        },
+                        operations,
+                    ),
+                    (left, right) => or(
+                        left.distributive_law(operations),
+                        right.distributive_law(operations),
+                    ),
+                }
             }
             Expression::Binary {
                 left,
@@ -460,7 +537,7 @@ impl Expression {
         }
     }
 
-    fn commutative_law(&self, operations: &mut Vec<Operation>) -> Self {
+    fn commutative_law(&self, _operations: &mut Vec<Operation>) -> Self {
         todo!("? | Order of operands does not matter in AND and OR operations.")
     }
 }
@@ -705,7 +782,7 @@ mod tests {
             expression,
             or(
                 and(not(atomic("a")), not(atomic("b"))),
-                and(not(atomic("c")), not(atomic("d")))
+                and(not(atomic("c")), not(atomic("d"))),
             )
         ); // ¬(a ⋁ b) ⋀ ¬(c ⋁ d) == (¬a ⋀ ¬b) ⋁ (¬c ⋀ ¬d)
         assert_eq!(operations.len(), 3);

src/expressions/truth_table.rs

@@ -36,16 +36,27 @@ pub enum Sort {
 }
 
 impl TruthTable {
-    pub fn new(expression: &Expression, options: TruthTableOptions) -> Self {
+    pub fn new(
+        expression: &Expression,
+        TruthTableOptions {
+            hide,
+            hide_intermediate_steps,
+            sort,
+        }: TruthTableOptions,
+    ) -> Self {
         let mut header = Self::extract_header(expression);
-        let mut truth_matrix = Self::generate_truth_matrix(expression, &header, options.hide, options.hide_intermediate_steps);
+        let mut truth_matrix =
-        if !matches!(options.sort, Sort::Default) {
+            Self::generate_truth_matrix(expression, &header, hide, hide_intermediate_steps);
-            Self::sort_matrix(&mut truth_matrix, options.sort);
+        if !matches!(sort, Sort::Default) {
+            Self::sort_matrix(&mut truth_matrix, sort);
         }
-        if options.hide_intermediate_steps {
+        if hide_intermediate_steps {
             header = Self::remove_non_atomic_from_header(&header);
         }
-        Self { header, truth_matrix }
+        Self {
+            header,
+            truth_matrix,
+        }
     }
 
     fn sort_matrix(truth_matrix: &mut TruthMatrix, sort: Sort) {
@@ -57,7 +68,8 @@ impl TruthTable {
     }
 
     fn remove_non_atomic_from_header(header: &[String]) -> Vec<String> {
-        header.iter()
+        header
+            .iter()
             .enumerate()
             .filter_map(|(index, s)| {
                 if !Self::contains_operator(s) || index == header.len() - 1 {
@@ -105,38 +117,62 @@ impl TruthTable {
         }
     }
 
-    fn generate_truth_matrix(expression: &Expression, header: &[String], hide: Hide, hide_intermediate: bool) -> TruthMatrix {
+    fn generate_truth_matrix(
-        let mut atomics = expression.get_atomic_values()
+        expression: &Expression,
-            .into_iter().collect::<Vec<String>>();
+        header: &[String],
+        hide: Hide,
+        hide_intermediate: bool,
+    ) -> TruthMatrix {
+        let mut atomics = expression
+            .get_atomic_values()
+            .into_iter()
+            .collect::<Vec<String>>();
         if atomics.is_empty() {
             return vec![];
         }
         atomics.sort();
-        Self::truth_combinations(atomics.len() as u32).iter()
+        Self::truth_combinations(atomics.len() as u32)
+            .iter()
             .filter_map(|combo| {
-                let expression = Self::resolve_expression(expression, &atomics.iter()
+                let expression = Self::resolve_expression(
-                    .enumerate()
+                    expression,
-                    .map(|(index, value)| (value.clone(), combo[index]))
+                    &atomics
-                    .collect(), header, hide_intermediate);
+                        .iter()
+                        .enumerate()
+                        .map(|(index, value)| (value.clone(), combo[index]))
+                        .collect(),
+                    header,
+                    hide_intermediate,
+                );
                 match (hide, expression.last()) {
                     (Hide::True, Some(false)) => Some(expression),
                     (Hide::False, Some(true)) => Some(expression),
                     (Hide::None, _) => Some(expression),
                     _ => None,
                 }
-            }).collect()
+            })
+            .collect()
     }
 
     fn truth_combinations(count: u32) -> TruthMatrix {
         let row_len = 2usize.pow(count);
         let rows = 0..row_len;
-        rows.map(|index| (0..count).rev()
+        rows.map(|index| {
-            // Just trust me bro
+            (0..count)
-            .map(|shift| (index >> shift) & 1 == 0).collect()
+                .rev()
-        ).collect()
+                // Just trust me bro
+                .map(|shift| (index >> shift) & 1 == 0)
+                .collect()
+        })
+        .collect()
     }
 
-    fn resolve_expression(expression: &Expression, booleans: &HashMap<String, bool>, header: &[String], hide_intermediate: bool) -> Vec<bool> {
+    fn resolve_expression(
+        expression: &Expression,
+        booleans: &HashMap<String, bool>,
+        header: &[String],
+        hide_intermediate: bool,
+    ) -> Vec<bool> {
         let Some(last_expression) = header.last() else {
             return vec![];
         };
@@ -145,17 +181,23 @@ impl TruthTable {
         if hide_intermediate {
             expression_map = Self::remove_intermediate_steps(expression_map, last_expression);
         }
-        let string_map = expression_map.into_iter()
+        let string_map = expression_map
+            .into_iter()
             .map(|(key, value)| (key.to_string(), value))
             .collect::<HashMap<String, bool>>();
 
-        header.iter()
+        header
+            .iter()
             .filter_map(|s_expr| string_map.get(s_expr).copied())
             .collect()
     }
 
-    fn remove_intermediate_steps<'a>(expression_map: HashMap<&'a Expression, bool>, top_level_expression: &'a str) -> HashMap<&'a Expression, bool> {
+    fn remove_intermediate_steps<'a>(
-        expression_map.into_iter()
+        expression_map: HashMap<&'a Expression, bool>,
+        top_level_expression: &'a str,
+    ) -> HashMap<&'a Expression, bool> {
+        expression_map
+            .into_iter()
             .filter_map(|(key, value)| {
                 if key.is_atomic() || key.to_string() == top_level_expression {
                     Some((key, value))
@@ -166,7 +208,10 @@ impl TruthTable {
             .collect()
     }
 
-    fn _resolve_expression<'a>(expression: &'a Expression, booleans: &HashMap<String, bool>) -> HashMap<&'a Expression, bool> {
+    fn _resolve_expression<'a>(
+        expression: &'a Expression,
+        booleans: &HashMap<String, bool>,
+    ) -> HashMap<&'a Expression, bool> {
         match expression {
             Expression::Not(expr) => {
                 let mut map = Self::_resolve_expression(expr, booleans);
@@ -175,12 +220,18 @@ impl TruthTable {
                 }
                 map
             }
-            Expression::Binary { left, right, operator } => {
+            Expression::Binary {
+                left,
+                right,
+                operator,
+            } => {
                 let left_map = Self::_resolve_expression(left, booleans);
                 let right_map = Self::_resolve_expression(right, booleans);
                 let mut map = left_map;
                 map.extend(right_map);
-                if let (Some(left_value), Some(right_value)) = (map.get(left.as_ref()), map.get(right.as_ref())) {
+                if let (Some(left_value), Some(right_value)) =
+                    (map.get(left.as_ref()), map.get(right.as_ref()))
+                {
                     map.insert(expression, operator.eval(*left_value, *right_value));
                 }
                 map
@@ -209,18 +260,24 @@ mod tests {
         let expression = and(atomic("A"), atomic("B"));
         let truth_table = TruthTable::new(&expression, Default::default());
         assert_eq!(truth_table.header, vec!["A", "B", "A ⋀ B"]);
-        assert_ne!(truth_table.truth_matrix, matrix![
+        assert_ne!(
-            true, true, true;
+            truth_table.truth_matrix,
-            false, true, false;
+            matrix![
-            true, false, false;
+                true, true, true;
-            false, false, false
+                false, true, false;
-        ]);
+                true, false, false;
-        assert_eq!(truth_table.truth_matrix, matrix![
+                false, false, false
-            true, true, true;
+            ]
-            true, false, false;
+        );
-            false, true, false;
+        assert_eq!(
-            false, false, false
+            truth_table.truth_matrix,
-        ]);
+            matrix![
+                true, true, true;
+                true, false, false;
+                false, true, false;
+                false, false, false
+            ]
+        );
     }
 
     #[test]
@@ -229,26 +286,56 @@ mod tests {
         let truth_table = TruthTable::new(&expression, Default::default());
         let atomics = 3;
 
-        assert_eq!(truth_table.header, vec!["A", "C", "A ⋁ C", "B", "B ⋁ C", "(A ⋁ C) ⋀ (B ⋁ C)"]);
+        assert_eq!(
+            truth_table.header,
+            vec!["A", "C", "A ⋁ C", "B", "B ⋁ C", "(A ⋁ C) ⋀ (B ⋁ C)"]
+        );
         assert_eq!(truth_table.truth_matrix.len(), 2usize.pow(atomics as u32));
         assert_eq!(truth_table.truth_matrix[0].len(), 6);
-        assert_eq!(truth_table.truth_matrix[0], vec![true, true, true, true, true, true]);
+        assert_eq!(
-        assert_eq!(truth_table.truth_matrix[1], vec![true, false, true, true, true, true]);
+            truth_table.truth_matrix[0],
-        assert_eq!(truth_table.truth_matrix[2], vec![true, true, true, false, true, true]);
+            vec![true, true, true, true, true, true]
-        assert_eq!(truth_table.truth_matrix[3], vec![true, false, true, false, false, false]);
+        );
-        assert_eq!(truth_table.truth_matrix[4], vec![false, true, true, true, true, true]);
+        assert_eq!(
-        assert_eq!(truth_table.truth_matrix[5], vec![false, false, false, true, true, false]);
+            truth_table.truth_matrix[1],
-        assert_eq!(truth_table.truth_matrix[6], vec![false, true, true, false, true, true]);
+            vec![true, false, true, true, true, true]
-        assert_eq!(truth_table.truth_matrix[7], vec![false, false, false, false, false, false]);
+        );
+        assert_eq!(
+            truth_table.truth_matrix[2],
+            vec![true, true, true, false, true, true]
+        );
+        assert_eq!(
+            truth_table.truth_matrix[3],
+            vec![true, false, true, false, false, false]
+        );
+        assert_eq!(
+            truth_table.truth_matrix[4],
+            vec![false, true, true, true, true, true]
+        );
+        assert_eq!(
+            truth_table.truth_matrix[5],
+            vec![false, false, false, true, true, false]
+        );
+        assert_eq!(
+            truth_table.truth_matrix[6],
+            vec![false, true, true, false, true, true]
+        );
+        assert_eq!(
+            truth_table.truth_matrix[7],
+            vec![false, false, false, false, false, false]
+        );
     }
 
     #[test]
     fn test_new_truth_table_and_hide_intermediate_steps() {
         let expression = and(atomic("A"), or(atomic("B"), atomic("C")));
-        let truth_table = TruthTable::new(&expression, TruthTableOptions {
+        let truth_table = TruthTable::new(
-            hide_intermediate_steps: true,
+            &expression,
-            ..Default::default()
+            TruthTableOptions {
-        });
+                hide_intermediate_steps: true,
+                ..Default::default()
+            },
+        );
         assert_eq!(truth_table.header, vec!["A", "B", "C", "A ⋀ (B ⋁ C)"]);
         for (index, row) in truth_table.truth_matrix.iter().enumerate() {
             assert_eq!(row.len(), 4, "Row at {index}: {:?}", row);
@@ -264,12 +351,15 @@ mod tests {
             false, false, false
         ];
         TruthTable::sort_matrix(&mut matrix, Sort::TrueFirst);
-        assert_eq!(matrix, matrix![
+        assert_eq!(
-            true, true, true;
+            matrix,
-            false, true, true;
+            matrix![
-            true, false, false;
+                true, true, true;
-            false, false, false
+                false, true, true;
-        ]);
+                true, false, false;
+                false, false, false
+            ]
+        );
     }
 
     #[test]
@@ -281,12 +371,15 @@ mod tests {
             true, false, false
         ];
         TruthTable::sort_matrix(&mut matrix, Sort::TrueFirst);
-        assert_eq!(matrix, matrix![
+        assert_eq!(
-            false, true, false;
+            matrix,
-            false, true, false;
+            matrix![
-            true, false, false;
+                false, true, false;
-            true, false, false
+                false, true, false;
-        ]);
+                true, false, false;
+                true, false, false
+            ]
+        );
     }
 
     #[test]
@@ -298,12 +391,15 @@ mod tests {
             false, false, false
         ];
         TruthTable::sort_matrix(&mut matrix, Sort::Default);
-        assert_eq!(matrix, matrix![
+        assert_eq!(
-            true, true, true;
+            matrix,
-            true, false, false;
+            matrix![
-            false, true, true;
+                true, true, true;
-            false, false, false
+                true, false, false;
-        ]);
+                false, true, true;
+                false, false, false
+            ]
+        );
     }
 
     #[test]
@@ -315,12 +411,15 @@ mod tests {
             false, false, false
         ];
         TruthTable::sort_matrix(&mut matrix, Sort::FalseFirst);
-        assert_eq!(matrix, matrix![
+        assert_eq!(
-            true, false, false;
+            matrix,
-            false, false, false;
+            matrix![
-            true, true, true;
+                true, false, false;
-            false, true, true
+                false, false, false;
-        ]);
+                true, true, true;
+                false, true, true
+            ]
+        );
     }
 
     #[test]
@@ -333,20 +432,20 @@ mod tests {
         let matrix = TruthTable::generate_truth_matrix(
             &and(atomic("A"), atomic("B")),
             &["A".into(), "B".into(), "A ⋀ B".into()],
-            Hide::True, false,
+            Hide::True,
+            false,
         );
         assert_eq!(expected, matrix);
     }
 
     #[test]
     fn test_hide_false_values() {
-        let expected = matrix![
+        let expected = matrix![true, true, true];
-            true, true, true
-        ];
         let matrix = TruthTable::generate_truth_matrix(
             &and(atomic("A"), atomic("B")),
             &["A".into(), "B".into(), "A ⋀ B".into()],
-            Hide::False, false,
+            Hide::False,
+            false,
         );
         assert_eq!(expected, matrix);
     }
@@ -362,7 +461,8 @@ mod tests {
         let matrix = TruthTable::generate_truth_matrix(
             &and(atomic("A"), atomic("B")),
             &["A".into(), "B".into(), "A ⋀ B".into()],
-            Hide::None, false,
+            Hide::None,
+            false,
         );
         assert_eq!(expected, matrix);
     }
@@ -370,34 +470,46 @@ mod tests {
     #[test]
     fn test_truth_combinations_2() {
         let combinations = TruthTable::truth_combinations(2);
-        assert_eq!(combinations, matrix![
+        assert_eq!(
-            true, true;
+            combinations,
-            true, false;
+            matrix![
-            false, true;
+                true, true;
-            false, false
+                true, false;
-        ]);
+                false, true;
+                false, false
+            ]
+        );
     }
 
     #[test]
     fn test_truth_combinations_3() {
         let combinations = TruthTable::truth_combinations(3);
-        assert_eq!(combinations, matrix![
+        assert_eq!(
-            true, true, true;
+            combinations,
-            true, true, false;
+            matrix![
-            true, false, true;
+                true, true, true;
-            true, false, false;
+                true, true, false;
-            false, true, true;
+                true, false, true;
-            false, true, false;
+                true, false, false;
-            false, false, true;
+                false, true, true;
-            false, false, false
+                false, true, false;
-        ]);
+                false, false, true;
+                false, false, false
+            ]
+        );
     }
 
     #[test]
     fn test_resolve_expression_hide_intermediate_steps() {
         let expression = and(atomic("A"), or(atomic("B"), atomic("C")));
         let booleans = map!["A".into() => true, "B".into() => false, "C".into() => true];
-        let header = vec!["A".into(), "B".into(), "C".into(), "B ⋁ C".into(), "A ⋀ (B ⋁ C)".into()];
+        let header = vec![
+            "A".into(),
+            "B".into(),
+            "C".into(),
+            "B ⋁ C".into(),
+            "A ⋀ (B ⋁ C)".into(),
+        ];
         let values = TruthTable::resolve_expression(&expression, &booleans, &header, true);
         assert_eq!(values.len(), 4);
         assert_eq!(values, vec![true, false, true, true]);
@@ -443,7 +555,12 @@ mod tests {
     fn test_resolve_expression_even_more_duplicates() {
         let expression = and(atomic("A"), and(atomic("A"), and(atomic("A"), atomic("A"))));
         let booleans = HashMap::from([("A".into(), true)]);
-        let header = vec!["A".into(), "A ⋀ A".into(), "A ⋀ A ⋀ A".into(), "A ⋀ A ⋀ A ⋀ A".into()];
+        let header = vec![
+            "A".into(),
+            "A ⋀ A".into(),
+            "A ⋀ A ⋀ A".into(),
+            "A ⋀ A ⋀ A ⋀ A".into(),
+        ];
         let values = TruthTable::resolve_expression(&expression, &booleans, &header, false);
         assert_eq!(values, vec![true, true, true, true]);
     }
@@ -453,15 +570,20 @@ mod tests {
         let expression = and(atomic("A"), and(atomic("A"), and(atomic("A"), atomic("A"))));
         let booleans = HashMap::from([("A".into(), true)]);
         let values = TruthTable::_resolve_expression(&expression, &booleans);
-        assert_eq!(values, HashMap::from([
+        assert_eq!(
-            (&atomic("A"), true),
+            values,
-            (&and(atomic("A"), atomic("A")), true),
+            HashMap::from([
-            (&and(atomic("A"), and(atomic("A"), atomic("A"))), true),
+                (&atomic("A"), true),
-            (&and(atomic("A"), and(atomic("A"), and(atomic("A"), atomic("A")))), true),
+                (&and(atomic("A"), atomic("A")), true),
-        ]));
+                (&and(atomic("A"), and(atomic("A"), atomic("A"))), true),
+                (
+                    &and(atomic("A"), and(atomic("A"), and(atomic("A"), atomic("A")))),
+                    true
+                ),
+            ])
+        );
     }
 
-
     #[test]
     fn test_atomic_expression() {
         let expression = atomic("A");
@@ -501,7 +623,10 @@ mod tests {
     fn test_complex_expression() {
         let expression = implies(and(atomic("A"), atomic("B")), or(atomic("C"), atomic("D")));
         let header = TruthTable::extract_header(&expression);
-        assert_eq!(header, vec!["A", "B", "A ⋀ B", "C", "D", "C ⋁ D", "A ⋀ B ➔ C ⋁ D"]);
+        assert_eq!(
+            header,
+            vec!["A", "B", "A ⋀ B", "C", "D", "C ⋁ D", "A ⋀ B ➔ C ⋁ D"]
+        );
     }
 
     #[test]
@@ -513,8 +638,14 @@ mod tests {
 
     #[test]
     fn test_somewhat_equal() {
-        let expression = and(atomic("A"), and(or(not(atomic("A")), atomic("B")), atomic("A")));
+        let expression = and(
+            atomic("A"),
+            and(or(not(atomic("A")), atomic("B")), atomic("A")),
+        );
         let header = TruthTable::extract_header(&expression);
-        assert_eq!(header, vec!["A", "¬A", "B", "¬A ⋁ B", "(¬A ⋁ B) ⋀ A", "A ⋀ (¬A ⋁ B) ⋀ A"]);
+        assert_eq!(
+            header,
+            vec!["A", "¬A", "B", "¬A ⋁ B", "(¬A ⋁ B) ⋀ A", "A ⋀ (¬A ⋁ B) ⋀ A"]
+        );
     }
 }

src/main.rs

@@ -1,8 +1,8 @@
 use lib::axum::app::AppBuilder;
 use tower_http::cors::CorsLayer;
 
-use crate::routing::routes::*;
 use crate::routing::routes::index::not_found;
+use crate::routing::routes::*;
 
 mod config;
 mod expressions;

src/parsing/expression_parser.rs

@@ -100,7 +100,7 @@ fn implication_expression<'a>(
 }
 
 fn not_expression(input: &str) -> IResult<&str, Expression> {
-    preceded(char('!'), left_hand_side)(input).map(|(remaining, right)| (remaining, right.not()))
+    map(preceded(char('!'), left_hand_side), Expression::not)(input)
 }
 
 fn value(input: &str) -> IResult<&str, Expression> {

src/parsing/mod.rs

@@ -1 +1 @@
-pub(crate) mod expression_parser;
+pub(crate) mod expression_parser;

src/routing/error.rs

@@ -1,5 +1,5 @@
-use axum::Json;
 use axum::response::{IntoResponse, Response};
+use axum::Json;
 use serde::Serialize;
 
 #[derive(Serialize, Default)]

src/routing/mod.rs

@@ -1,4 +1,4 @@
-pub(crate) mod response;
 pub(crate) mod error;
+pub(crate) mod options;
+pub(crate) mod response;
 pub(crate) mod routes;
-pub(crate) mod options;

src/routing/options.rs

@@ -1,15 +1,12 @@
-use serde::Deserialize;
 use crate::expressions::truth_table::{Hide, Sort};
-use crate::utils::serialize::{ret_true, deserialize_bool};
+use crate::utils::serialize::{deserialize_bool, ret_true};
+use serde::Deserialize;
 
 // TODO deserialize_bool should not be necessary
 #[derive(Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct SimplifyOptions {
-    #[serde(
+    #[serde(default = "ret_true", deserialize_with = "deserialize_bool")]
-        default = "ret_true",
-        deserialize_with = "deserialize_bool"
-    )]
     pub simplify: bool,
     #[serde(default, deserialize_with = "deserialize_bool")]
     pub ignore_case: bool,

src/routing/routes/index.rs

@@ -1,7 +1,7 @@
 use axum::extract::Path;
 use axum::http::StatusCode;
-use axum::Json;
 use axum::response::{IntoResponse, Response};
+use axum::Json;
 use lib::router;
 use serde::Serialize;
 
@@ -40,7 +40,7 @@ async fn open_api() -> impl IntoResponse {
 async fn is_valid(Path(path): Path<String>) -> Response {
     match Expression::try_from(path.as_str()) {
         Ok(_) => IsValidResponse::valid().into_response(),
-        Err(error) => Error::new(error.to_string(), ErrorKind::InvalidExpression).into_response()
+        Err(error) => Error::new(error.to_string(), ErrorKind::InvalidExpression).into_response(),
     }
 }
 

src/routing/routes/mod.rs

@@ -1,5 +1,3 @@
 pub(crate) mod index;
-
 pub(crate) mod simplify;
-
 pub(crate) mod table;

src/routing/routes/simplify.rs

@@ -9,10 +9,13 @@ use crate::routing::error::{Error, ErrorKind};
 use crate::routing::options::{SimplifyAndTableOptions, SimplifyOptions};
 use crate::routing::response::SimplifyResponse;
 
-router!("/simplify", routes!(
+router!(
-    get "/:exp" => simplify,
+    "/simplify",
-    get "/table/:exp" => simplify_and_table
+    routes!(
-));
+        get "/:exp" => simplify,
+        get "/table/:exp" => simplify_and_table
+    )
+);
 
 async fn simplify(Path(path): Path<String>, Query(query): Query<SimplifyOptions>) -> Response {
     match Expression::try_from(path.as_str()) {
@@ -28,15 +31,21 @@ async fn simplify(Path(path): Path<String>, Query(query): Query<SimplifyOptions>
                 operations,
                 expression,
                 truth_table: None,
-            }.into_response()
+            }
-        }
+            .into_response()
-        Err(error) => {
-            (StatusCode::BAD_REQUEST, Error::new(error.to_string(), ErrorKind::InvalidExpression)).into_response()
         }
+        Err(error) => (
+            StatusCode::BAD_REQUEST,
+            Error::new(error.to_string(), ErrorKind::InvalidExpression),
+        )
+            .into_response(),
     }
 }
 
-async fn simplify_and_table(Path(path): Path<String>, Query(query): Query<SimplifyAndTableOptions>) -> Response {
+async fn simplify_and_table(
+    Path(path): Path<String>,
+    Query(query): Query<SimplifyAndTableOptions>,
+) -> Response {
     match Expression::try_from(path.as_str()) {
         Ok(mut expression) => {
             let before = expression.to_string();
@@ -51,10 +60,13 @@ async fn simplify_and_table(Path(path): Path<String>, Query(query): Query<Simpli
                 operations,
                 expression,
                 truth_table: Some(truth_table),
-            }.into_response()
+            }
-        }
+            .into_response()
-        Err(error) => {
-            (StatusCode::BAD_REQUEST, Error::new(error.to_string(), ErrorKind::InvalidExpression)).into_response()
         }
+        Err(error) => (
+            StatusCode::BAD_REQUEST,
+            Error::new(error.to_string(), ErrorKind::InvalidExpression),
+        )
+            .into_response(),
     }
 }

src/routing/routes/table.rs

@@ -9,16 +9,24 @@ use crate::routing::error::{Error, ErrorKind};
 use crate::routing::options::TruthTableOptions;
 use crate::routing::response::TruthTableResponse;
 
-router!("/table", routes!(
+router!(
-    get "/:exp" => table
+    "/table",
-));
+    routes!(
+        get "/:exp" => table
+    )
+);
 
 // TODO Expression as input in body
 async fn table(Path(value): Path<String>, Query(query): Query<TruthTableOptions>) -> Response {
     match Expression::try_from(value) {
-        Ok(expression) => {
+        Ok(expression) => TruthTableResponse {
-            TruthTableResponse { truth_table: TruthTable::new(&expression, query) }.into_response()
+            truth_table: TruthTable::new(&expression, query),
         }
-        Err(e) => (StatusCode::BAD_REQUEST, Error::new(e.to_string(), ErrorKind::InvalidExpression)).into_response(),
+        .into_response(),
+        Err(e) => (
+            StatusCode::BAD_REQUEST,
+            Error::new(e.to_string(), ErrorKind::InvalidExpression),
+        )
+            .into_response(),
     }
 }

src/utils/axum.rs

@@ -19,7 +19,11 @@ macro_rules! load_html {
 #[cfg(debug_assertions)]
 macro_rules! absolute_path {
     ($filename:literal) => {
-        concat!(env!("CARGO_MANIFEST_DIR"), "/src/resources/static/", $filename)
+        concat!(
+            env!("CARGO_MANIFEST_DIR"),
+            "/src/resources/static/",
+            $filename
+        )
     };
 }
 

src/utils/mod.rs

@@ -1,2 +1,2 @@
+pub mod axum;
 pub mod serialize;
-pub mod axum;

src/utils/serialize.rs

@@ -4,8 +4,9 @@ pub(crate) const fn ret_true() -> bool {
     true
 }
 
-
+pub(crate) fn deserialize_bool<'de, D: Deserializer<'de>>(
-pub(crate) fn deserialize_bool<'de, D: Deserializer<'de>>(deserializer: D) -> Result<bool, D::Error> {
+    deserializer: D,
+) -> Result<bool, D::Error> {
     let s: &str = Deserialize::deserialize(deserializer)?;
 
     match s {
@@ -13,4 +14,4 @@ pub(crate) fn deserialize_bool<'de, D: Deserializer<'de>>(deserializer: D) -> Re
         "false" => Ok(false),
         _ => Err(de::Error::unknown_variant(s, &["true", "false"])),
     }
-}
+}