style: include unnecessary_wraps (#762)

Author: vil02

Cargo.toml

@@ -74,7 +74,6 @@ stable_sort_primitive = { level = "allow", priority = 1 }
 too_many_lines = { level = "allow", priority = 1 }
 trivially_copy_pass_by_ref = { level = "allow", priority = 1 }
 unnecessary_box_returns = { level = "allow", priority = 1 }
-unnecessary_wraps = { level = "allow", priority = 1 }
 unnested_or_patterns = { level = "allow", priority = 1 }
 unreadable_literal = { level = "allow", priority = 1 }
 unused_self = { level = "allow", priority = 1 }

src/backtracking/graph_coloring.rs

@@ -26,7 +26,7 @@ pub fn generate_colorings(
     adjacency_matrix: Vec<Vec<bool>>,
     num_colors: usize,
 ) -> Result<Option<Vec<Vec<usize>>>, GraphColoringError> {
-    GraphColoring::new(adjacency_matrix)?.find_solutions(num_colors)
+    Ok(GraphColoring::new(adjacency_matrix)?.find_solutions(num_colors))
 }
 
 /// A struct representing a graph coloring problem.
@@ -126,15 +126,12 @@ impl GraphColoring {
     /// # Returns
     ///
     /// * A `Result` containing an `Option` with a vector of solutions or a `GraphColoringError`.
-    fn find_solutions(
-        &mut self,
-        num_colors: usize,
-    ) -> Result<Option<Vec<Vec<usize>>>, GraphColoringError> {
+    fn find_solutions(&mut self, num_colors: usize) -> Option<Vec<Vec<usize>>> {
         self.find_colorings(0, num_colors);
         if self.solutions.is_empty() {
-            Ok(None)
+            None
         } else {
-            Ok(Some(std::mem::take(&mut self.solutions)))
+            Some(std::mem::take(&mut self.solutions))
         }
     }
 }

src/sorting/tree_sort.rs

@@ -30,19 +30,19 @@ impl<T: Ord + Clone> BinarySearchTree<T> {
     }
 
     fn insert(&mut self, value: T) {
-        self.root = Self::insert_recursive(self.root.take(), value);
+        self.root = Some(Self::insert_recursive(self.root.take(), value));
     }
 
-    fn insert_recursive(root: Option<Box<TreeNode<T>>>, value: T) -> Option<Box<TreeNode<T>>> {
+    fn insert_recursive(root: Option<Box<TreeNode<T>>>, value: T) -> Box<TreeNode<T>> {
         match root {
-            None => Some(Box::new(TreeNode::new(value))),
+            None => Box::new(TreeNode::new(value)),
             Some(mut node) => {
                 if value <= node.value {
-                    node.left = Self::insert_recursive(node.left.take(), value);
+                    node.left = Some(Self::insert_recursive(node.left.take(), value));
                 } else {
-                    node.right = Self::insert_recursive(node.right.take(), value);
+                    node.right = Some(Self::insert_recursive(node.right.take(), value));
                 }
-                Some(node)
+                node
             }
         }
     }