Fix a bunch of clippy errors.

brndnmtthws · brndnmtthws · commit c3a7ae7f097c · 2020-09-06T09:48:15.000-04:00
diff --git a/src/bin/c02p01.rs b/src/bin/c02p01.rs
@@ -69,9 +69,9 @@ where
     fn tail(&self) -> Option<NodeRef<T>> {
         if let Some(cur) = self.head.as_ref().cloned() {
             if cur.borrow().next.is_none() {
-                return Some(cur.clone());
+                return Some(cur);
             } else {
-                return Node::tail(&cur.clone());
+                return Node::tail(&cur);
             }
         }
         None
@@ -121,7 +121,7 @@ impl<'a, T> Iterator for Iter<T> {
     fn next(&mut self) -> Option<Self::Item> {
         if let Some(cur) = self.next.as_ref().cloned() {
             self.next = cur.borrow().next.clone();
-            return Some(cur.clone());
+            return Some(cur);
         }
         None
     }
diff --git a/src/bin/c02p02.rs b/src/bin/c02p02.rs
@@ -66,12 +66,16 @@ where
     }
 
     fn kth_to_last(&self, k: usize) -> Option<NodeRef<T>> {
+        use std::cmp::Ordering;
+
         let mut kth_to_last_node: Option<NodeRef<T>> = None;
         for (c, _) in self.iter().enumerate() {
-            if c == k {
-                kth_to_last_node = self.head.as_ref().cloned();
-            } else if c > k {
-                kth_to_last_node = kth_to_last_node.unwrap().borrow().next.as_ref().cloned();
+            match k.cmp(&c) {
+                Ordering::Equal => kth_to_last_node = self.head.as_ref().cloned(),
+                Ordering::Less => {
+                    kth_to_last_node = kth_to_last_node.unwrap().borrow().next.as_ref().cloned()
+                }
+                _ => (),
             }
         }
         kth_to_last_node
diff --git a/src/bin/c02p04.rs b/src/bin/c02p04.rs
@@ -20,7 +20,7 @@ struct Iter<T> {
 impl<T> Node<T> {
     fn tail(node: &NodeRef<T>) -> Option<NodeRef<T>> {
         if let Some(cur) = node.borrow().next.as_ref().cloned() {
-            return Node::tail(&cur.clone());
+            return Node::tail(&cur);
         }
         Some(node.clone())
     }
@@ -67,9 +67,9 @@ where
     fn tail(&self) -> Option<NodeRef<T>> {
         if let Some(cur) = self.head.as_ref().cloned() {
             if cur.borrow().next.is_none() {
-                return Some(cur.clone());
+                return Some(cur);
             } else {
-                return Node::tail(&cur.clone());
+                return Node::tail(&cur);
             }
         }
         None
@@ -88,7 +88,7 @@ impl<'a, T> Iterator for Iter<T> {
     fn next(&mut self) -> Option<Self::Item> {
         if let Some(cur) = self.next.as_ref().cloned() {
             self.next = cur.borrow().next.clone();
-            return Some(cur.clone());
+            return Some(cur);
         }
         None
     }
diff --git a/src/bin/c02p05.rs b/src/bin/c02p05.rs
@@ -51,7 +51,7 @@ where
     fn tail(&self) -> Option<NodeRef<T>> {
         if let Some(cur) = self.head.as_ref().cloned() {
             if cur.borrow().next.is_none() {
-                return Some(cur.clone());
+                return Some(cur);
             } else {
                 return Node::tail(&cur.clone());
             }
@@ -72,7 +72,7 @@ impl<'a, T> Iterator for Iter<T> {
     fn next(&mut self) -> Option<Self::Item> {
         if let Some(cur) = self.next.as_ref().cloned() {
             self.next = cur.borrow().next.clone();
-            return Some(cur.clone());
+            return Some(cur);
         }
         None
     }
diff --git a/src/bin/c02p06.rs b/src/bin/c02p06.rs
@@ -81,7 +81,7 @@ impl<'a, T> Iterator for Iter<T> {
             if Rc::ptr_eq(&cur, self.prev.as_ref().unwrap()) {
                 return None;
             }
-            return Some(cur.clone());
+            return Some(cur);
         }
         None
     }
@@ -94,7 +94,7 @@ impl<'a, T> DoubleEndedIterator for Iter<T> {
             if Rc::ptr_eq(self.next.as_ref().unwrap(), &cur) {
                 return None;
             }
-            return Some(cur.clone());
+            return Some(cur);
         }
         None
     }
diff --git a/src/bin/c02p08.rs b/src/bin/c02p08.rs
@@ -55,7 +55,7 @@ where
     fn tail(&self) -> Option<NodeRef<T>> {
         if let Some(cur) = self.head.as_ref().cloned() {
             if cur.borrow().next.is_none() {
-                return Some(cur.clone());
+                return Some(cur);
             } else {
                 return Node::tail(&cur.clone());
             }
@@ -80,7 +80,7 @@ where
         while hare.is_some() && tortoise.is_some() {
             if Rc::ptr_eq(hare.as_ref().unwrap(), tortoise.as_ref().unwrap()) {
                 if Rc::ptr_eq(&prev_tortoise, &prev_hare) {
-                    return Some(prev_tortoise.clone());
+                    return Some(prev_tortoise);
                 } else {
                     return Some(hare.as_ref().unwrap().clone());
                 }
@@ -104,7 +104,7 @@ impl<'a, T> Iterator for Iter<T> {
         self.next.as_ref()?;
         if let Some(cur) = self.next.as_ref().cloned() {
             self.next = cur.borrow().next.clone();
-            return Some(cur.clone());
+            return Some(cur);
         }
         None
     }
@@ -142,7 +142,7 @@ mod tests {
         list_iter.next();
         list_iter.next();
         let third_node = list_iter.next();
-        cycle_list.tail().unwrap().borrow_mut().next = Some(third_node.unwrap().clone());
+        cycle_list.tail().unwrap().borrow_mut().next = Some(third_node.unwrap());
 
         let cycle_result = cycle_list.has_cycle();
         assert_eq!(cycle_result.is_some(), true);
@@ -168,7 +168,7 @@ mod tests {
         list_iter2.next();
         list_iter2.next();
         let third_node2 = list_iter2.next();
-        cycle_list2.tail().unwrap().borrow_mut().next = Some(third_node2.unwrap().clone());
+        cycle_list2.tail().unwrap().borrow_mut().next = Some(third_node2.unwrap());
 
         let cycle_result2 = cycle_list2.has_cycle();
         assert_eq!(cycle_result2.is_some(), true);
diff --git a/src/bin/c03p04.rs b/src/bin/c03p04.rs
@@ -14,7 +14,7 @@ where
     }
 
     fn add(&mut self, value: T) {
-        self.arr.push(value.clone());
+        self.arr.push(value);
     }
 
     fn remove(&mut self) -> Option<T> {
diff --git a/src/bin/c04p01.rs b/src/bin/c04p01.rs
@@ -95,13 +95,13 @@ mod tests {
         let third = graph.add_vertex(3, &[first.clone(), second.clone()]);
 
         assert_eq!(graph.has_path(first.clone(), third.clone()), true);
-        assert_eq!(graph.has_path(third.clone(), first.clone()), false);
+        assert_eq!(graph.has_path(third, first), false);
     }
 }
 
 fn main() {
     let mut graph = Graph::<i32>::new();
     let first = graph.add_vertex(1, &[]);
     let second = graph.add_vertex(2, &[]);
-    graph.has_path(first.clone(), second.clone());
+    graph.has_path(first, second);
 }
diff --git a/src/bin/c04p02.rs b/src/bin/c04p02.rs
@@ -33,7 +33,7 @@ where
             ret
         } else {
             let mut head = self.head.as_mut().unwrap().clone();
-            self.insert_at(&mut head, ret.clone())
+            self.insert_at(&mut head, ret)
         }
     }
 
diff --git a/src/bin/c04p04.rs b/src/bin/c04p04.rs
@@ -34,7 +34,7 @@ where
             ret
         } else {
             let mut head = self.head.as_mut().unwrap().clone();
-            self.insert_at(&mut head, ret.clone())
+            self.insert_at(&mut head, ret)
         }
     }
 
diff --git a/src/bin/c04p06.rs b/src/bin/c04p06.rs
@@ -34,7 +34,7 @@ where
             ret
         } else {
             let mut head = self.head.as_mut().unwrap().clone();
-            self.insert_at(&mut head, ret.clone())
+            self.insert_at(&mut head, ret)
         }
     }
 
@@ -98,7 +98,7 @@ where
         if let Some(left) = node.borrow().left.as_ref() {
             self.dfs_from(f, left.clone());
         }
-        f(&node.clone());
+        f(&node);
         if let Some(right) = node.borrow().right.as_ref() {
             self.dfs_from(f, right.clone());
         }
diff --git a/src/bin/c04p07.rs b/src/bin/c04p07.rs
@@ -93,10 +93,10 @@ mod tests {
 fn main() {
     let mut graph = Graph::<char>::new();
     let c_vertex = graph.add_vertex('c', &[]);
-    let d_vertex = graph.add_vertex('d', &[c_vertex.clone()]);
+    let d_vertex = graph.add_vertex('d', &[c_vertex]);
     let a_vertex = graph.add_vertex('a', &[d_vertex.clone()]);
-    let b_vertex = graph.add_vertex('b', &[d_vertex.clone()]);
-    let _f_vertex = graph.add_vertex('f', &[a_vertex.clone(), b_vertex.clone()]);
+    let b_vertex = graph.add_vertex('b', &[d_vertex]);
+    let _f_vertex = graph.add_vertex('f', &[a_vertex, b_vertex]);
     let _e_vertex = graph.add_vertex('e', &[]);
 
     let mut graph_order = Vec::<char>::new();
diff --git a/src/bin/c04p08.rs b/src/bin/c04p08.rs
@@ -120,7 +120,7 @@ mod tests {
         let _e_vertex = graph.add_vertex('e', &[]);
 
         let mut was_called = false;
-        graph.common_ancestor(a_vertex.clone(), b_vertex.clone(), |vertex| {
+        graph.common_ancestor(a_vertex, b_vertex, |vertex| {
             was_called = true;
             assert_eq!(Rc::ptr_eq(vertex, &d_vertex), true)
         });
@@ -131,14 +131,14 @@ mod tests {
 fn main() {
     let mut graph = Graph::<char>::new();
     let c_vertex = graph.add_vertex('c', &[]);
-    let d_vertex = graph.add_vertex('d', &[c_vertex.clone()]);
+    let d_vertex = graph.add_vertex('d', &[c_vertex]);
     let a_vertex = graph.add_vertex('a', &[d_vertex.clone()]);
     let b_vertex = graph.add_vertex('b', &[d_vertex.clone()]);
     let _f_vertex = graph.add_vertex('f', &[a_vertex.clone(), b_vertex.clone()]);
     let _e_vertex = graph.add_vertex('e', &[]);
 
     let mut was_called = false;
-    graph.common_ancestor(a_vertex.clone(), b_vertex.clone(), |vertex| {
+    graph.common_ancestor(a_vertex, b_vertex, |vertex| {
         was_called = true;
         assert_eq!(Rc::ptr_eq(vertex, &d_vertex), true)
     });
diff --git a/src/bin/c04p09.rs b/src/bin/c04p09.rs
@@ -34,7 +34,7 @@ where
             ret
         } else {
             let mut head = self.head.as_mut().unwrap().clone();
-            self.insert_at(&mut head, ret.clone())
+            self.insert_at(&mut head, ret)
         }
     }
 

Original file line number	Diff line number	Diff line change
`@@ -69,9 +69,9 @@ where`
`69`	`69`	`fn tail(&self) -> Option<NodeRef<T>> {`
`70`	`70`	`if let Some(cur) = self.head.as_ref().cloned() {`
`71`	`71`	`if cur.borrow().next.is_none() {`
`72`		`- return Some(cur.clone());`
	`72`	`+ return Some(cur);`
`73`	`73`	`} else {`
`74`		`- return Node::tail(&cur.clone());`
	`74`	`+ return Node::tail(&cur);`
`75`	`75`	`}`
`76`	`76`	`}`
`77`	`77`	`None`
`@@ -121,7 +121,7 @@ impl<'a, T> Iterator for Iter<T> {`
`121`	`121`	`fn next(&mut self) -> Option<Self::Item> {`
`122`	`122`	`if let Some(cur) = self.next.as_ref().cloned() {`
`123`	`123`	`self.next = cur.borrow().next.clone();`
`124`		`- return Some(cur.clone());`
	`124`	`+ return Some(cur);`
`125`	`125`	`}`
`126`	`126`	`None`
`127`	`127`	`}`
Original file line number	Diff line number	Diff line change
`@@ -20,7 +20,7 @@ struct Iter<T> {`
`20`	`20`	`impl<T> Node<T> {`
`21`	`21`	`fn tail(node: &NodeRef<T>) -> Option<NodeRef<T>> {`
`22`	`22`	`if let Some(cur) = node.borrow().next.as_ref().cloned() {`
`23`		`- return Node::tail(&cur.clone());`
	`23`	`+ return Node::tail(&cur);`
`24`	`24`	`}`
`25`	`25`	`Some(node.clone())`
`26`	`26`	`}`
`@@ -67,9 +67,9 @@ where`
`67`	`67`	`fn tail(&self) -> Option<NodeRef<T>> {`
`68`	`68`	`if let Some(cur) = self.head.as_ref().cloned() {`
`69`	`69`	`if cur.borrow().next.is_none() {`
`70`		`- return Some(cur.clone());`
	`70`	`+ return Some(cur);`
`71`	`71`	`} else {`
`72`		`- return Node::tail(&cur.clone());`
	`72`	`+ return Node::tail(&cur);`
`73`	`73`	`}`
`74`	`74`	`}`
`75`	`75`	`None`
`@@ -88,7 +88,7 @@ impl<'a, T> Iterator for Iter<T> {`
`88`	`88`	`fn next(&mut self) -> Option<Self::Item> {`
`89`	`89`	`if let Some(cur) = self.next.as_ref().cloned() {`
`90`	`90`	`self.next = cur.borrow().next.clone();`
`91`		`- return Some(cur.clone());`
	`91`	`+ return Some(cur);`
`92`	`92`	`}`
`93`	`93`	`None`
`94`	`94`	`}`
Original file line number	Diff line number	Diff line change
`@@ -51,7 +51,7 @@ where`
`51`	`51`	`fn tail(&self) -> Option<NodeRef<T>> {`
`52`	`52`	`if let Some(cur) = self.head.as_ref().cloned() {`
`53`	`53`	`if cur.borrow().next.is_none() {`
`54`		`- return Some(cur.clone());`
	`54`	`+ return Some(cur);`
`55`	`55`	`} else {`
`56`	`56`	`return Node::tail(&cur.clone());`
`57`	`57`	`}`
`@@ -72,7 +72,7 @@ impl<'a, T> Iterator for Iter<T> {`
`72`	`72`	`fn next(&mut self) -> Option<Self::Item> {`
`73`	`73`	`if let Some(cur) = self.next.as_ref().cloned() {`
`74`	`74`	`self.next = cur.borrow().next.clone();`
`75`		`- return Some(cur.clone());`
	`75`	`+ return Some(cur);`
`76`	`76`	`}`
`77`	`77`	`None`
`78`	`78`	`}`
Original file line number	Diff line number	Diff line change
`@@ -81,7 +81,7 @@ impl<'a, T> Iterator for Iter<T> {`
`81`	`81`	`if Rc::ptr_eq(&cur, self.prev.as_ref().unwrap()) {`
`82`	`82`	`return None;`
`83`	`83`	`}`
`84`		`- return Some(cur.clone());`
	`84`	`+ return Some(cur);`
`85`	`85`	`}`
`86`	`86`	`None`
`87`	`87`	`}`
`@@ -94,7 +94,7 @@ impl<'a, T> DoubleEndedIterator for Iter<T> {`
`94`	`94`	`if Rc::ptr_eq(self.next.as_ref().unwrap(), &cur) {`
`95`	`95`	`return None;`
`96`	`96`	`}`
`97`		`- return Some(cur.clone());`
	`97`	`+ return Some(cur);`
`98`	`98`	`}`
`99`	`99`	`None`
`100`	`100`	`}`
Original file line number	Diff line number	Diff line change
`@@ -14,7 +14,7 @@ where`
`14`	`14`	`}`
`15`	`15`
`16`	`16`	`fn add(&mut self, value: T) {`
`17`		`- self.arr.push(value.clone());`
	`17`	`+ self.arr.push(value);`
`18`	`18`	`}`
`19`	`19`
`20`	`20`	`fn remove(&mut self) -> Option<T> {`
Original file line number	Diff line number	Diff line change
`@@ -95,13 +95,13 @@ mod tests {`
`95`	`95`	`let third = graph.add_vertex(3, &[first.clone(), second.clone()]);`
`96`	`96`
`97`	`97`	`assert_eq!(graph.has_path(first.clone(), third.clone()), true);`
`98`		`- assert_eq!(graph.has_path(third.clone(), first.clone()), false);`
	`98`	`+ assert_eq!(graph.has_path(third, first), false);`
`99`	`99`	`}`
`100`	`100`	`}`
`101`	`101`
`102`	`102`	`fn main() {`
`103`	`103`	`let mut graph = Graph::<i32>::new();`
`104`	`104`	`let first = graph.add_vertex(1, &[]);`
`105`	`105`	`let second = graph.add_vertex(2, &[]);`
`106`		`- graph.has_path(first.clone(), second.clone());`
	`106`	`+ graph.has_path(first, second);`
`107`	`107`	`}`
Original file line number	Diff line number	Diff line change
`@@ -33,7 +33,7 @@ where`
`33`	`33`	`ret`
`34`	`34`	`} else {`
`35`	`35`	`let mut head = self.head.as_mut().unwrap().clone();`
`36`		`- self.insert_at(&mut head, ret.clone())`
	`36`	`+ self.insert_at(&mut head, ret)`
`37`	`37`	`}`
`38`	`38`	`}`
`39`	`39`
Original file line number	Diff line number	Diff line change
`@@ -34,7 +34,7 @@ where`
`34`	`34`	`ret`
`35`	`35`	`} else {`
`36`	`36`	`let mut head = self.head.as_mut().unwrap().clone();`
`37`		`- self.insert_at(&mut head, ret.clone())`
	`37`	`+ self.insert_at(&mut head, ret)`
`38`	`38`	`}`
`39`	`39`	`}`
`40`	`40`