Return an Option, not a Result.

Author: gabi-250

src/lib.rs

@@ -64,7 +64,10 @@ impl<'a, T> SearchTree<T>
     /// assert!(!tree.contains(&String::from("cruel")));
     /// ```
     pub fn contains(&self, value: &T) -> bool {
-        self.get_node(value).is_ok()
+        match self.get_node(value) {
+            None => false,
+            Some(index) => self.nodes[index].value == *value
+        }
     }
 
     /// Add the specified value to this tree.
@@ -97,11 +100,9 @@ impl<'a, T> SearchTree<T>
         }
     }
 
-    /// Return a `Result` containing the index of the node that has the
-    /// specified value. If no such node exists, the `Result` contains
-    /// the index of the node that would be the parent of the node containing
-    /// `value`, if `value` were inserted into the tree.
-    fn get_node(&self, value: &T) -> Result<usize, Option<usize>> {
+    /// Return an `Option` containing the index of the node that has the
+    /// lowest value that is greater or equal to `value`.
+    fn get_node(&self, value: &T) -> Option<usize> {
         let mut current_index = self.root;
         let mut previous_index = None;
         while let Some(index) = current_index {
@@ -113,35 +114,36 @@ impl<'a, T> SearchTree<T>
             } else {
                 // the value already exists in the tree - return the index of
                 // the corresponding node
-                return Ok(index);
+                return current_index;
             }
         }
         // return the index of the node containing the smallest value
         // greater than `value`
-        Err(previous_index)
+        previous_index
     }
 
+    /// Return a new node containing `value`, or None if `value` is already in
+    /// the tree.
     fn create_node(&mut self, value: T) -> Option<Node<T>> {
-        match self.get_node(&value) {
-            Ok(_) => None, // a node containing `value` already exists
-            Err(parent) => {
-                if let Some(parent_index) = parent {
-                    if self.nodes[parent_index].value < value {
-                        self.nodes[parent_index].right_child =
-                            Some(self.nodes.len());
-                    } else {
-                        self.nodes[parent_index].left_child = Some(self.nodes.len());
-                    }
+        let parent = self.get_node(&value);
+        if let Some(index) = parent {
+            if self.nodes[index].value == value {
+                return None; // no need to create the node
+            } else {
+                if self.nodes[index].value < value {
+                    self.nodes[index].right_child = Some(self.nodes.len());
+                } else {
+                    self.nodes[index].left_child = Some(self.nodes.len());
                 }
-                Some(Node {
-                    value: value,
-                    parent: parent,
-                    left_child: None,
-                    right_child: None,
-                    height: 0
-                })
             }
         }
+        Some(Node {
+            value: value,
+            parent: parent,
+            left_child: None,
+            right_child: None,
+            height: 0
+        })
     }
 
     fn update_heights(&mut self, start_index: usize) {