diff --git a/.github/dependabot.yml b/.github/dependabot.yml
index dedb149..2e37dd8 100644
--- a/.github/dependabot.yml
+++ b/.github/dependabot.yml
@@ -1,12 +1,12 @@
 version: 2
 updates:
-- package-ecosystem: cargo
-  directory: "/"
-  schedule:
-    interval: daily
-    time: "10:00"
-  open-pull-requests-limit: 10
-  reviewers:
-  - brndnmtthws
-  assignees:
-  - brndnmtthws
+  - package-ecosystem: cargo
+    directory: "/"
+    schedule:
+      interval: weekly
+      time: "10:00"
+    open-pull-requests-limit: 10
+    reviewers:
+      - brndnmtthws
+    assignees:
+      - brndnmtthws
diff --git a/.github/workflows/build-and-test.yml b/.github/workflows/build-and-test.yml
index aa57428..916970d 100644
--- a/.github/workflows/build-and-test.yml
+++ b/.github/workflows/build-and-test.yml
@@ -11,7 +11,8 @@ jobs:
       - uses: actions/checkout@v3
       - name: Setup Rust toolchain with caching
         uses: brndnmtthws/rust-action@v1
+        with:
+          cargo-packages: cargo-nextest
       - run: cargo build
-      - run: cargo test
-        env:
-          RUST_BACKTRACE: 1
+      - run: cargo clippy
+      - run: cargo nextest run
diff --git a/.rustfmt.toml b/.rustfmt.toml
new file mode 100644
index 0000000..68f6928
--- /dev/null
+++ b/.rustfmt.toml
@@ -0,0 +1,12 @@
+enum_discrim_align_threshold = 60
+format_code_in_doc_comments = true
+format_macro_matchers = true
+format_strings = true
+group_imports = "StdExternalCrate"
+imports_granularity = "Module"
+# normalize_comments = true
+reorder_impl_items = true
+unstable_features = true
+use_field_init_shorthand = true
+style_edition = "2024"
+wrap_comments = true
diff --git a/Cargo.toml b/Cargo.toml
index 9b04cc1..5fc8e0a 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,9 +1,9 @@
 [package]
 name = "cracking-the-coding-interview"
 version = "0.1.0"
-authors = ["Brenden Matthews <brenden@diddyinc.com>"]
+authors = ["Brenden Matthews <brenden@brndn.io>"]
 edition = "2018"
 
 [dependencies]
-rand = "0.8"
+rand = "0.9"
 num = "0.4"
diff --git a/src/bin/c01p01.rs b/src/bin/c01p01.rs
index 19f0673..8b67c73 100644
--- a/src/bin/c01p01.rs
+++ b/src/bin/c01p01.rs
@@ -30,24 +30,23 @@ fn all_chars_unique_part_b(s: &str) -> bool {
     true
 }
 
+fn main() {
+    all_chars_unique_part_a(&String::from("helloworld"));
+    all_chars_unique_part_b(&String::from("helloworld"));
+}
 #[cfg(test)]
 mod tests {
     use super::*;
 
     #[test]
     fn test_part_a() {
-        assert_eq!(all_chars_unique_part_a(&String::from("abcdefg")), true);
-        assert_eq!(all_chars_unique_part_a(&String::from("abcdefga")), false);
+        assert!(all_chars_unique_part_a(&String::from("abcdefg")));
+        assert!(!all_chars_unique_part_a(&String::from("abcdefga")));
     }
 
     #[test]
     fn test_part_b() {
-        assert_eq!(all_chars_unique_part_b(&String::from("abcdefg")), true);
-        assert_eq!(all_chars_unique_part_b(&String::from("abcdefga")), false);
+        assert!(all_chars_unique_part_b(&String::from("abcdefg")));
+        assert!(!all_chars_unique_part_b(&String::from("abcdefga")));
     }
 }
-
-fn main() {
-    all_chars_unique_part_a(&String::from("helloworld"));
-    all_chars_unique_part_b(&String::from("helloworld"));
-}
diff --git a/src/bin/c01p02.rs b/src/bin/c01p02.rs
index 2aa5128..22b15f6 100644
--- a/src/bin/c01p02.rs
+++ b/src/bin/c01p02.rs
@@ -28,23 +28,17 @@ fn is_permutation(s1: &str, s2: &str) -> bool {
     true
 }
 
+fn main() {
+    is_permutation(&String::from("cat"), &String::from("dog"));
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
 
     #[test]
     fn test_is_permutation() {
-        assert_eq!(
-            is_permutation(&String::from("cat"), &String::from("tac")),
-            true
-        );
-        assert_eq!(
-            is_permutation(&String::from("cat"), &String::from("dog")),
-            false
-        );
+        assert!(is_permutation(&String::from("cat"), &String::from("tac")));
+        assert!(!is_permutation(&String::from("cat"), &String::from("dog")));
     }
 }
-
-fn main() {
-    is_permutation(&String::from("cat"), &String::from("dog"));
-}
diff --git a/src/bin/c01p03.rs b/src/bin/c01p03.rs
index 2eae6fd..1feb6f6 100644
--- a/src/bin/c01p03.rs
+++ b/src/bin/c01p03.rs
@@ -15,6 +15,11 @@ fn urlify_2(url: &str) -> String {
     url.trim().replace(' ', "%20")
 }
 
+fn main() {
+    urlify("Mr John Smith    ");
+    urlify_2("Mr John Smith    ");
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -28,8 +33,3 @@ mod tests {
         assert_eq!(urlify_2("Mr John Smith    "), "Mr%20John%20Smith");
     }
 }
-
-fn main() {
-    urlify("Mr John Smith    ");
-    urlify_2("Mr John Smith    ");
-}
diff --git a/src/bin/c01p04.rs b/src/bin/c01p04.rs
index 43abf14..c1b426e 100644
--- a/src/bin/c01p04.rs
+++ b/src/bin/c01p04.rs
@@ -8,7 +8,7 @@ fn count_chars(s: &str) -> HashMap<char, i32> {
     characters
 }
 
-fn palidrome_permutations(s: &str) -> bool {
+fn palindrome_permutations(s: &str) -> bool {
     let normalized_s = s
         .to_lowercase()
         .split_whitespace()
@@ -33,16 +33,16 @@ fn palidrome_permutations(s: &str) -> bool {
     true
 }
 
+fn main() {
+    palindrome_permutations("Tact Coa");
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
 
     #[test]
     fn test_palindrome_permutation() {
-        assert_eq!(palidrome_permutations("Tact Coa"), true);
+        assert!(palindrome_permutations("Tact Coa"));
     }
 }
-
-fn main() {
-    palidrome_permutations("Tact Coa");
-}
diff --git a/src/bin/c01p05.rs b/src/bin/c01p05.rs
index 7834809..aa169a2 100644
--- a/src/bin/c01p05.rs
+++ b/src/bin/c01p05.rs
@@ -41,24 +41,24 @@ fn is_one_edit_away(s1: &str, s2: &str) -> bool {
     one_char_inserted(s1, s2)
 }
 
+fn main() {
+    is_one_edit_away("pale", "ple");
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
 
     #[test]
     fn test_is_one_edit_away() {
-        assert_eq!(is_one_edit_away("pale", "pale"), true);
-        assert_eq!(is_one_edit_away("pale", "ple"), true);
-        assert_eq!(is_one_edit_away("pales", "pale"), true);
-        assert_eq!(is_one_edit_away("pale", "bale"), true);
-        assert_eq!(is_one_edit_away("pale", "bake"), false);
+        assert!(is_one_edit_away("pale", "pale"));
+        assert!(is_one_edit_away("pale", "ple"));
+        assert!(is_one_edit_away("pales", "pale"));
+        assert!(is_one_edit_away("pale", "bale"));
+        assert!(!is_one_edit_away("pale", "bake"));
 
-        assert_eq!(is_one_edit_away("pale", "8e9auh"), false);
-        assert_eq!(is_one_edit_away("pale", ""), false);
-        assert_eq!(is_one_edit_away("pale", "pale "), true);
+        assert!(!is_one_edit_away("pale", "8e9auh"));
+        assert!(!is_one_edit_away("pale", ""));
+        assert!(is_one_edit_away("pale", "pale "));
     }
 }
-
-fn main() {
-    is_one_edit_away("pale", "ple");
-}
diff --git a/src/bin/c01p06.rs b/src/bin/c01p06.rs
index dd7d7f8..d2c14d0 100644
--- a/src/bin/c01p06.rs
+++ b/src/bin/c01p06.rs
@@ -22,6 +22,10 @@ fn compress_string(s: &str) -> String {
     result
 }
 
+fn main() {
+    compress_string("aabcccccaaa");
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -35,7 +39,3 @@ mod tests {
         );
     }
 }
-
-fn main() {
-    compress_string("aabcccccaaa");
-}
diff --git a/src/bin/c01p07.rs b/src/bin/c01p07.rs
index 35ebfae..566a656 100644
--- a/src/bin/c01p07.rs
+++ b/src/bin/c01p07.rs
@@ -28,6 +28,10 @@ fn rotate_image_90_degrees(image: &[Vec<u32>]) -> Image {
     rotated_image
 }
 
+fn main() {
+    rotate_image_90_degrees(&[vec![1]]);
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -52,7 +56,3 @@ mod tests {
         assert_eq!(rotated_image, expected_rotated_image);
     }
 }
-
-fn main() {
-    rotate_image_90_degrees(&[vec![1]]);
-}
diff --git a/src/bin/c01p08.rs b/src/bin/c01p08.rs
index ec1948d..28b0f44 100644
--- a/src/bin/c01p08.rs
+++ b/src/bin/c01p08.rs
@@ -26,47 +26,39 @@ fn zero_matrix_where_zero(mat: &[Vec<u32>]) -> Mat {
     result
 }
 
+fn main() {
+    zero_matrix_where_zero(&[vec![0]]);
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
 
     #[test]
     fn test_zero_matrix_where_zeros() {
+        assert_eq!(zero_matrix_where_zero(&[vec![0, 1], vec![1, 1]]), [
+            vec![0, 0],
+            vec![0, 1]
+        ]);
         assert_eq!(
-            zero_matrix_where_zero(&[vec![0, 1], vec![1, 1]]),
-            [vec![0, 0], vec![0, 1]]
-        );
-        assert_eq!(
-            zero_matrix_where_zero(&[
-                vec![0, 1, 1, 1],
-                vec![1, 1, 1, 1],
-                vec![1, 1, 1, 1],
-                vec![1, 1, 1, 1],
-            ]),
-            [
-                vec![0, 0, 0, 0],
-                vec![0, 1, 1, 1],
-                vec![0, 1, 1, 1],
-                vec![0, 1, 1, 1],
-            ]
+            zero_matrix_where_zero(
+                &[vec![0, 1, 1, 1], vec![1, 1, 1, 1], vec![1, 1, 1, 1], vec![
+                    1, 1, 1, 1
+                ],]
+            ),
+            [vec![0, 0, 0, 0], vec![0, 1, 1, 1], vec![0, 1, 1, 1], vec![
+                0, 1, 1, 1
+            ],]
         );
         assert_eq!(
-            zero_matrix_where_zero(&[
-                vec![1, 1, 1, 1],
-                vec![1, 1, 1, 1],
-                vec![1, 1, 0, 1],
-                vec![1, 1, 1, 1],
-            ]),
-            [
-                vec![1, 1, 0, 1],
-                vec![1, 1, 0, 1],
-                vec![0, 0, 0, 0],
-                vec![1, 1, 0, 1],
-            ]
+            zero_matrix_where_zero(
+                &[vec![1, 1, 1, 1], vec![1, 1, 1, 1], vec![1, 1, 0, 1], vec![
+                    1, 1, 1, 1
+                ],]
+            ),
+            [vec![1, 1, 0, 1], vec![1, 1, 0, 1], vec![0, 0, 0, 0], vec![
+                1, 1, 0, 1
+            ],]
         );
     }
 }
-
-fn main() {
-    zero_matrix_where_zero(&[vec![0]]);
-}
diff --git a/src/bin/c01p09.rs b/src/bin/c01p09.rs
index 6d1ac67..3362da2 100644
--- a/src/bin/c01p09.rs
+++ b/src/bin/c01p09.rs
@@ -4,17 +4,17 @@ fn is_rotated_string(s1: &str, s2: &str) -> bool {
     triplet.contains(s2)
 }
 
+fn main() {
+    is_rotated_string("waterbottle", "erbottlewat");
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
 
     #[test]
     fn test_string_rotation() {
-        assert_eq!(is_rotated_string("waterbottle", "erbottlewat"), true);
-        assert_eq!(is_rotated_string("herpderp", "lolbob"), false);
+        assert!(is_rotated_string("waterbottle", "erbottlewat"));
+        assert!(!is_rotated_string("herpderp", "lolbob"));
     }
 }
-
-fn main() {
-    is_rotated_string("waterbottle", "erbottlewat");
-}
diff --git a/src/bin/c02p01.rs b/src/bin/c02p01.rs
index 8cfc7dc..353829e 100644
--- a/src/bin/c02p01.rs
+++ b/src/bin/c02p01.rs
@@ -1,6 +1,6 @@
 use std::cell::RefCell;
-use std::collections::hash_map::DefaultHasher;
 use std::collections::HashSet;
+use std::collections::hash_map::DefaultHasher;
 use std::fmt::Display;
 use std::hash::Hasher;
 use std::rc::Rc;
@@ -115,7 +115,7 @@ where
     }
 }
 
-impl<'a, T> Iterator for Iter<T> {
+impl<T> Iterator for Iter<T> {
     type Item = NodeRef<T>;
 
     fn next(&mut self) -> Option<Self::Item> {
@@ -142,6 +142,14 @@ impl<T: Display> Display for LinkedList<T> {
     }
 }
 
+fn main() {
+    let mut list = LinkedList::<String>::new();
+    list.append(String::from("item1"));
+    list.append(String::from("item2"));
+    list.list_has_duplicates();
+    list.remove_duplicates();
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -152,13 +160,13 @@ mod tests {
         list1.append(String::from("item1"));
         list1.append(String::from("item2"));
 
-        assert_eq!(list1.list_has_duplicates(), false);
+        assert!(!list1.list_has_duplicates());
 
         let mut list2 = LinkedList::<String>::new();
         list2.append(String::from("item"));
         list2.append(String::from("item"));
 
-        assert_eq!(list2.list_has_duplicates(), true);
+        assert!(list2.list_has_duplicates());
     }
 
     #[test]
@@ -168,24 +176,16 @@ mod tests {
         list1.append(String::from("item2"));
 
         list1.remove_duplicates();
-        assert_eq!(list1.list_has_duplicates(), false);
+        assert!(!list1.list_has_duplicates());
 
         let mut list2 = LinkedList::<String>::new();
         list2.append(String::from("item"));
         list2.append(String::from("item"));
 
-        assert_eq!(list2.list_has_duplicates(), true);
+        assert!(list2.list_has_duplicates());
 
         list2.remove_duplicates();
 
-        assert_eq!(list2.list_has_duplicates(), false);
+        assert!(!list2.list_has_duplicates());
     }
 }
-
-fn main() {
-    let mut list = LinkedList::<String>::new();
-    list.append(String::from("item1"));
-    list.append(String::from("item2"));
-    list.list_has_duplicates();
-    list.remove_duplicates();
-}
diff --git a/src/bin/c02p02.rs b/src/bin/c02p02.rs
index 9fba663..c1960a1 100644
--- a/src/bin/c02p02.rs
+++ b/src/bin/c02p02.rs
@@ -82,7 +82,7 @@ where
     }
 }
 
-impl<'a, T> Iterator for Iter<T> {
+impl<T> Iterator for Iter<T> {
     type Item = NodeRef<T>;
 
     fn next(&mut self) -> Option<Self::Item> {
@@ -109,6 +109,13 @@ impl<T: Display> Display for LinkedList<T> {
     }
 }
 
+fn main() {
+    let mut list = LinkedList::<String>::new();
+    list.append(String::from("item1"));
+    list.append(String::from("item2"));
+    list.kth_to_last(1);
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -132,10 +139,3 @@ mod tests {
         );
     }
 }
-
-fn main() {
-    let mut list = LinkedList::<String>::new();
-    list.append(String::from("item1"));
-    list.append(String::from("item2"));
-    list.kth_to_last(1);
-}
diff --git a/src/bin/c02p03.rs b/src/bin/c02p03.rs
index 3cb321a..a01465f 100644
--- a/src/bin/c02p03.rs
+++ b/src/bin/c02p03.rs
@@ -77,7 +77,7 @@ where
     }
 }
 
-impl<'a, T> Iterator for Iter<T> {
+impl<T> Iterator for Iter<T> {
     type Item = NodeRef<T>;
 
     fn next(&mut self) -> Option<Self::Item> {
@@ -104,6 +104,15 @@ impl<T: Display> Display for LinkedList<T> {
     }
 }
 
+fn main() {
+    let mut list = LinkedList::<String>::new();
+    list.append(String::from("item1"));
+    list.append(String::from("item2"));
+    for node in list.iter() {
+        list.remove(&node.clone());
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -120,7 +129,7 @@ mod tests {
         for (n, node) in list1.iter().enumerate() {
             if n == 3 {
                 let to_remove = Some(node.clone());
-                list1.remove(&to_remove.unwrap());
+                list1.remove(to_remove.as_ref().unwrap());
             }
         }
 
@@ -129,12 +138,3 @@ mod tests {
         }
     }
 }
-
-fn main() {
-    let mut list = LinkedList::<String>::new();
-    list.append(String::from("item1"));
-    list.append(String::from("item2"));
-    for node in list.iter() {
-        list.remove(&node.clone());
-    }
-}
diff --git a/src/bin/c02p04.rs b/src/bin/c02p04.rs
index 91b3d04..e269404 100644
--- a/src/bin/c02p04.rs
+++ b/src/bin/c02p04.rs
@@ -82,7 +82,7 @@ where
     }
 }
 
-impl<'a, T> Iterator for Iter<T> {
+impl<T> Iterator for Iter<T> {
     type Item = NodeRef<T>;
 
     fn next(&mut self) -> Option<Self::Item> {
@@ -109,6 +109,13 @@ impl<T: Display> Display for LinkedList<T> {
     }
 }
 
+fn main() {
+    let mut list = LinkedList::<String>::new();
+    list.append(String::from("item1"));
+    list.append(String::from("item2"));
+    let _list_partitioned = list.partition("hi".to_string());
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -135,10 +142,3 @@ mod tests {
         assert_eq!(iter.next().unwrap().borrow().data, 10);
     }
 }
-
-fn main() {
-    let mut list = LinkedList::<String>::new();
-    list.append(String::from("item1"));
-    list.append(String::from("item2"));
-    let _list_partitioned = list.partition("hi".to_string());
-}
diff --git a/src/bin/c02p05.rs b/src/bin/c02p05.rs
index 44b6184..a1e0215 100644
--- a/src/bin/c02p05.rs
+++ b/src/bin/c02p05.rs
@@ -66,7 +66,7 @@ where
     }
 }
 
-impl<'a, T> Iterator for Iter<T> {
+impl<T> Iterator for Iter<T> {
     type Item = NodeRef<T>;
 
     fn next(&mut self) -> Option<Self::Item> {
@@ -151,6 +151,16 @@ fn sum_forward(left: &LinkedList<i32>, right: &LinkedList<i32>) -> LinkedList<i3
     new_list
 }
 
+fn main() {
+    let mut left = LinkedList::<i32>::new();
+    left.append(6);
+
+    let mut right = LinkedList::<i32>::new();
+    right.append(2);
+    sum_backward(&left, &right);
+    sum_forward(&left, &right);
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -193,13 +203,3 @@ mod tests {
         assert_eq!(iter.next().unwrap().borrow().data, 2);
     }
 }
-
-fn main() {
-    let mut left = LinkedList::<i32>::new();
-    left.append(6);
-
-    let mut right = LinkedList::<i32>::new();
-    right.append(2);
-    sum_backward(&left, &right);
-    sum_forward(&left, &right);
-}
diff --git a/src/bin/c02p06.rs b/src/bin/c02p06.rs
index 6fa48e0..5c95ab1 100644
--- a/src/bin/c02p06.rs
+++ b/src/bin/c02p06.rs
@@ -72,7 +72,7 @@ where
     }
 }
 
-impl<'a, T> Iterator for Iter<T> {
+impl<T> Iterator for Iter<T> {
     type Item = NodeRef<T>;
 
     fn next(&mut self) -> Option<Self::Item> {
@@ -87,7 +87,7 @@ impl<'a, T> Iterator for Iter<T> {
     }
 }
 
-impl<'a, T> DoubleEndedIterator for Iter<T> {
+impl<T> DoubleEndedIterator for Iter<T> {
     fn next_back(&mut self) -> Option<Self::Item> {
         if let Some(cur) = self.prev.as_ref().cloned() {
             self.prev = cur.borrow().prev.clone();
@@ -115,6 +115,12 @@ impl<T: Display> Display for LinkedList<T> {
     }
 }
 
+fn main() {
+    let mut list = LinkedList::<i32>::new();
+    list.append(6);
+    list.is_palindrome();
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -156,7 +162,7 @@ mod tests {
         list1.append(3);
         list1.append(2);
         list1.append(1);
-        assert_eq!(list1.is_palindrome(), true);
+        assert!(list1.is_palindrome());
 
         let mut list2 = LinkedList::<i32>::new();
         list2.append(1);
@@ -165,26 +171,20 @@ mod tests {
         list2.append(2);
         list2.append(1);
         list2.append(1);
-        assert_eq!(list2.is_palindrome(), false);
+        assert!(!list2.is_palindrome());
 
         let mut list3 = LinkedList::<i32>::new();
         list3.append(1);
         list3.append(2);
         list3.append(2);
         list3.append(1);
-        assert_eq!(list3.is_palindrome(), true);
+        assert!(list3.is_palindrome());
 
         let mut list4 = LinkedList::<i32>::new();
         list4.append(1);
         list4.append(1);
         list4.append(2);
         list4.append(2);
-        assert_eq!(list4.is_palindrome(), false);
+        assert!(!list4.is_palindrome());
     }
 }
-
-fn main() {
-    let mut list = LinkedList::<i32>::new();
-    list.append(6);
-    list.is_palindrome();
-}
diff --git a/src/bin/c02p07.rs b/src/bin/c02p07.rs
index c6630e6..764c5b2 100644
--- a/src/bin/c02p07.rs
+++ b/src/bin/c02p07.rs
@@ -78,7 +78,7 @@ where
     }
 }
 
-impl<'a, T> Iterator for Iter<T> {
+impl<T> Iterator for Iter<T> {
     type Item = NodeRef<T>;
 
     fn next(&mut self) -> Option<Self::Item> {
@@ -105,13 +105,20 @@ impl<T: Display> Display for LinkedList<T> {
     }
 }
 
+fn main() {
+    let mut left = LinkedList::<i32>::new();
+    let right = LinkedList::<i32>::new();
+    left.append(Rc::new(RefCell::new(6)));
+    left.lists_intersect(&right);
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
 
     #[test]
     fn test_intersection() {
-        let datavec = vec![
+        let datavec = [
             Rc::new(RefCell::new(1)),
             Rc::new(RefCell::new(2)),
             Rc::new(RefCell::new(3)),
@@ -129,10 +136,7 @@ mod tests {
             intersecting_second.append(value.clone());
         }
 
-        assert_eq!(
-            intersecting_first.lists_intersect(&intersecting_second),
-            true
-        );
+        assert!(intersecting_first.lists_intersect(&intersecting_second));
 
         let mut nonintersecting_first = LinkedList::<i32>::new();
         for value in datavec.iter().take(3) {
@@ -144,16 +148,6 @@ mod tests {
             nonintersecting_second.append(value.clone());
         }
 
-        assert_eq!(
-            nonintersecting_first.lists_intersect(&nonintersecting_second),
-            false
-        );
+        assert!(!nonintersecting_first.lists_intersect(&nonintersecting_second));
     }
 }
-
-fn main() {
-    let mut left = LinkedList::<i32>::new();
-    let right = LinkedList::<i32>::new();
-    left.append(Rc::new(RefCell::new(6)));
-    left.lists_intersect(&right);
-}
diff --git a/src/bin/c02p08.rs b/src/bin/c02p08.rs
index 649bb4e..1b1f82f 100644
--- a/src/bin/c02p08.rs
+++ b/src/bin/c02p08.rs
@@ -97,7 +97,7 @@ where
     }
 }
 
-impl<'a, T> Iterator for Iter<T> {
+impl<T> Iterator for Iter<T> {
     type Item = NodeRef<T>;
 
     fn next(&mut self) -> Option<Self::Item> {
@@ -125,13 +125,19 @@ impl<T: Display> Display for LinkedList<T> {
     }
 }
 
+fn main() {
+    let mut left = LinkedList::<i32>::new();
+    left.append(6);
+    left.has_cycle();
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
 
     #[test]
     fn test_cycle() {
-        let datavec = vec!['A', 'B', 'C', 'D', 'E'];
+        let datavec = ['A', 'B', 'C', 'D', 'E'];
 
         let mut cycle_list = LinkedList::<char>::new();
         for value in datavec.iter() {
@@ -145,7 +151,7 @@ mod tests {
         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);
+        assert!(cycle_result.is_some());
         assert_eq!(cycle_result.as_ref().unwrap().borrow().data, 'C');
 
         let mut nocycle_list = LinkedList::<char>::new();
@@ -154,10 +160,10 @@ mod tests {
         }
 
         let nocycle_result = nocycle_list.has_cycle();
-        assert_eq!(nocycle_result.is_none(), true);
+        assert!(nocycle_result.is_none());
 
         // Second case
-        let datavec2 = vec!['A', 'B', 'C', 'D', 'E', 'F'];
+        let datavec2 = ['A', 'B', 'C', 'D', 'E', 'F'];
 
         let mut cycle_list2 = LinkedList::<char>::new();
         for value in datavec2.iter() {
@@ -171,13 +177,7 @@ mod tests {
         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);
+        assert!(cycle_result2.is_some());
         assert_eq!(cycle_result2.as_ref().unwrap().borrow().data, 'C');
     }
 }
-
-fn main() {
-    let mut left = LinkedList::<i32>::new();
-    left.append(6);
-    left.has_cycle();
-}
diff --git a/src/bin/c03p01.rs b/src/bin/c03p01.rs
index a24fcda..ca7f23b 100644
--- a/src/bin/c03p01.rs
+++ b/src/bin/c03p01.rs
@@ -54,6 +54,12 @@ impl<T> ThreeInOne<T> {
     }
 }
 
+fn main() {
+    let mut three_in_one: ThreeInOne<i32> = ThreeInOne::new();
+    three_in_one.push(0, 1);
+    three_in_one.pop(0);
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -79,9 +85,3 @@ mod tests {
         assert_eq!(three_in_one.pop(0).unwrap(), 7);
     }
 }
-
-fn main() {
-    let mut three_in_one: ThreeInOne<i32> = ThreeInOne::new();
-    three_in_one.push(0, 1);
-    three_in_one.pop(0);
-}
diff --git a/src/bin/c03p02.rs b/src/bin/c03p02.rs
index 33beb0f..a299adf 100644
--- a/src/bin/c03p02.rs
+++ b/src/bin/c03p02.rs
@@ -41,6 +41,13 @@ where
     }
 }
 
+fn main() {
+    let mut stack_with_min: Stack<i32> = Stack::new();
+    stack_with_min.push(1);
+    stack_with_min.min();
+    stack_with_min.pop();
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -59,13 +66,6 @@ mod tests {
         assert_eq!(stack_with_min.pop().unwrap(), 2);
         assert_eq!(*stack_with_min.min().unwrap(), 3);
         assert_eq!(stack_with_min.pop().unwrap(), 3);
-        assert_eq!(stack_with_min.min().is_none(), true);
+        assert!(stack_with_min.min().is_none());
     }
 }
-
-fn main() {
-    let mut stack_with_min: Stack<i32> = Stack::new();
-    stack_with_min.push(1);
-    stack_with_min.min();
-    stack_with_min.pop();
-}
diff --git a/src/bin/c03p03.rs b/src/bin/c03p03.rs
index 9b07726..c3afad3 100644
--- a/src/bin/c03p03.rs
+++ b/src/bin/c03p03.rs
@@ -53,6 +53,16 @@ where
     }
 }
 
+fn main() {
+    let mut set_of_stacks: StackSet<i32> = StackSet::new(10);
+    set_of_stacks.push(1);
+    set_of_stacks.push(1);
+    set_of_stacks.push(1);
+    set_of_stacks.pop_at(0);
+    set_of_stacks.push(1);
+    set_of_stacks.pop();
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -81,13 +91,3 @@ mod tests {
         }
     }
 }
-
-fn main() {
-    let mut set_of_stacks: StackSet<i32> = StackSet::new(10);
-    set_of_stacks.push(1);
-    set_of_stacks.push(1);
-    set_of_stacks.push(1);
-    set_of_stacks.pop_at(0);
-    set_of_stacks.push(1);
-    set_of_stacks.pop();
-}
diff --git a/src/bin/c03p04.rs b/src/bin/c03p04.rs
index 74feb57..24ce7a1 100644
--- a/src/bin/c03p04.rs
+++ b/src/bin/c03p04.rs
@@ -19,17 +19,23 @@ where
 
     fn remove(&mut self) -> Option<T> {
         let mut rev = Vec::<T>::new();
-        while !self.arr.is_empty() {
-            rev.push(self.arr.pop().unwrap());
+        while let Some(element) = self.arr.pop() {
+            rev.push(element);
         }
         let ret = rev.pop();
-        while !rev.is_empty() {
-            self.arr.push(rev.pop().unwrap());
+        while let Some(element) = rev.pop() {
+            self.arr.push(element);
         }
         ret
     }
 }
 
+fn main() {
+    let mut my_queue: MyQueue<i32> = MyQueue::new();
+    my_queue.add(1);
+    my_queue.remove();
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -45,9 +51,3 @@ mod tests {
         }
     }
 }
-
-fn main() {
-    let mut my_queue: MyQueue<i32> = MyQueue::new();
-    my_queue.add(1);
-    my_queue.remove();
-}
diff --git a/src/bin/c03p05.rs b/src/bin/c03p05.rs
index 6f61f02..5658999 100644
--- a/src/bin/c03p05.rs
+++ b/src/bin/c03p05.rs
@@ -22,8 +22,8 @@ where
                 tmp.push(self.arr.pop().unwrap());
             }
             self.arr.push(value);
-            while !tmp.is_empty() {
-                self.arr.push(tmp.pop().unwrap());
+            while let Some(element) = tmp.pop() {
+                self.arr.push(element);
             }
         }
     }
@@ -33,6 +33,12 @@ where
     }
 }
 
+fn main() {
+    let mut sort_stack: SortStack<i32> = SortStack::new();
+    sort_stack.push(1);
+    sort_stack.pop();
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -48,9 +54,3 @@ mod tests {
         }
     }
 }
-
-fn main() {
-    let mut sort_stack: SortStack<i32> = SortStack::new();
-    sort_stack.push(1);
-    sort_stack.pop();
-}
diff --git a/src/bin/c03p06.rs b/src/bin/c03p06.rs
index 52c7ba7..abb8afb 100644
--- a/src/bin/c03p06.rs
+++ b/src/bin/c03p06.rs
@@ -52,6 +52,25 @@ impl AnimalShelter {
     }
 }
 
+fn main() {
+    let mut animal_shelter = AnimalShelter::new();
+    animal_shelter.enqueue(Animal {
+        name: "Harry Potter".to_string(),
+        species: AnimalSpecies::Dog,
+    });
+    animal_shelter.enqueue(Animal {
+        name: "Hermione Granger".to_string(),
+        species: AnimalSpecies::Cat,
+    });
+    animal_shelter.enqueue(Animal {
+        name: "Ronald Weasly".to_string(),
+        species: AnimalSpecies::Cat,
+    });
+    animal_shelter.dequeue_any();
+    animal_shelter.dequeue_dog();
+    animal_shelter.dequeue_cat();
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -93,22 +112,3 @@ mod tests {
         assert_eq!(next.name, "Helen");
     }
 }
-
-fn main() {
-    let mut animal_shelter = AnimalShelter::new();
-    animal_shelter.enqueue(Animal {
-        name: "Harry Potter".to_string(),
-        species: AnimalSpecies::Dog,
-    });
-    animal_shelter.enqueue(Animal {
-        name: "Hermione Granger".to_string(),
-        species: AnimalSpecies::Cat,
-    });
-    animal_shelter.enqueue(Animal {
-        name: "Ronald Weasly".to_string(),
-        species: AnimalSpecies::Cat,
-    });
-    animal_shelter.dequeue_any();
-    animal_shelter.dequeue_dog();
-    animal_shelter.dequeue_cat();
-}
diff --git a/src/bin/c04p01.rs b/src/bin/c04p01.rs
index fd691ec..4f50f60 100644
--- a/src/bin/c04p01.rs
+++ b/src/bin/c04p01.rs
@@ -33,12 +33,12 @@ impl<T> Graph<T> {
         ret
     }
 
-    fn dfs_from<F>(&self, f: &mut F, vertex: VertexRef<T>) -> bool
+    fn dfs_from<F>(f: &mut F, vertex: VertexRef<T>) -> bool
     where
         F: FnMut(&VertexRef<T>) -> bool,
     {
         for v in vertex.borrow().edges.iter() {
-            if !self.dfs_from(f, v.clone()) {
+            if !Self::dfs_from(f, v.clone()) {
                 return false;
             }
         }
@@ -50,13 +50,13 @@ impl<T> Graph<T> {
         F: FnMut(&VertexRef<T>) -> bool,
     {
         if let Some(head) = &self.head {
-            self.dfs_from(&mut f, head.clone());
+            Self::dfs_from(&mut f, head.clone());
         }
     }
 
     fn has_path(&self, from: VertexRef<T>, to: VertexRef<T>) -> bool {
         let mut found_path = false;
-        self.dfs_from(
+        Self::dfs_from(
             &mut |v| {
                 if Rc::ptr_eq(v, &to) {
                     // a path has been found
@@ -83,6 +83,13 @@ impl<T: Display> Display for Graph<T> {
     }
 }
 
+fn main() {
+    let mut graph = Graph::<i32>::new();
+    let first = graph.add_vertex(1, &[]);
+    let second = graph.add_vertex(2, &[]);
+    graph.has_path(first, second);
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -94,14 +101,7 @@ mod tests {
         let second = graph.add_vertex(2, &[first.clone()]);
         let third = graph.add_vertex(3, &[first.clone(), second]);
 
-        assert_eq!(graph.has_path(first.clone(), third.clone()), true);
-        assert_eq!(graph.has_path(third, first), false);
+        assert!(graph.has_path(first.clone(), third.clone()));
+        assert!(!graph.has_path(third, first));
     }
 }
-
-fn main() {
-    let mut graph = Graph::<i32>::new();
-    let first = graph.add_vertex(1, &[]);
-    let second = graph.add_vertex(2, &[]);
-    graph.has_path(first, second);
-}
diff --git a/src/bin/c04p02.rs b/src/bin/c04p02.rs
index d0f061f..3d97c34 100644
--- a/src/bin/c04p02.rs
+++ b/src/bin/c04p02.rs
@@ -33,38 +33,38 @@ where
             ret
         } else {
             let mut head = self.head.as_mut().unwrap().clone();
-            self.insert_at(&mut head, ret)
+            Self::insert_at(&mut head, ret)
         }
     }
 
-    fn insert_at(&mut self, parent_node: &mut NodeRef<T>, new_node: NodeRef<T>) -> NodeRef<T> {
+    fn insert_at(parent_node: &mut NodeRef<T>, new_node: NodeRef<T>) -> NodeRef<T> {
         if new_node.borrow().data < parent_node.borrow().data {
             if parent_node.borrow().left.is_some() {
                 let mut new_parent = parent_node.borrow_mut().left.as_mut().unwrap().clone();
-                self.insert_at(&mut new_parent, new_node)
+                Self::insert_at(&mut new_parent, new_node)
             } else {
                 parent_node.borrow_mut().left = Some(new_node.clone());
                 new_node
             }
         } else if parent_node.borrow().right.is_some() {
             let mut new_parent = parent_node.borrow_mut().right.as_mut().unwrap().clone();
-            self.insert_at(&mut new_parent, new_node)
+            Self::insert_at(&mut new_parent, new_node)
         } else {
             parent_node.borrow_mut().right = Some(new_node.clone());
             new_node
         }
     }
 
-    fn visit_from<F>(&self, parent_node: &NodeRef<T>, f: &mut F)
+    fn visit_from<F>(parent_node: &NodeRef<T>, f: &mut F)
     where
         F: FnMut(&NodeRef<T>),
     {
         f(parent_node);
         if let Some(left) = parent_node.borrow().left.as_ref() {
-            self.visit_from(left, f);
+            Self::visit_from(left, f);
         }
         if let Some(right) = parent_node.borrow().right.as_ref() {
-            self.visit_from(right, f);
+            Self::visit_from(right, f);
         }
     }
 
@@ -73,7 +73,7 @@ where
         F: FnMut(&NodeRef<T>),
     {
         if self.head.is_some() {
-            self.visit_from(self.head.as_ref().unwrap(), &mut f)
+            Self::visit_from(self.head.as_ref().unwrap(), &mut f)
         }
     }
 
@@ -90,13 +90,13 @@ where
         }
     }
 
-    fn height_inner(&self, node: &NodeRef<T>, height: usize) -> usize {
+    fn height_inner(node: &NodeRef<T>, height: usize) -> usize {
         let mut max_height = height;
         if let Some(left) = node.borrow().left.as_ref() {
-            max_height = std::cmp::max(self.height_inner(left, height + 1), max_height);
+            max_height = std::cmp::max(Self::height_inner(left, height + 1), max_height);
         }
         if let Some(right) = node.borrow().right.as_ref() {
-            max_height = std::cmp::max(self.height_inner(right, height + 1), max_height);
+            max_height = std::cmp::max(Self::height_inner(right, height + 1), max_height);
         }
         max_height
     }
@@ -104,7 +104,7 @@ where
     fn height(&self) -> usize {
         let mut height = 0;
         if let Some(head) = self.head.as_ref() {
-            height = self.height_inner(head, height + 1);
+            height = Self::height_inner(head, height + 1);
         }
         height
     }
@@ -123,6 +123,13 @@ where
     }
 }
 
+fn main() {
+    let mut binary_tree = BinaryTree::<i32>::new();
+    let arr: Vec<i32> = (0..10).collect();
+    binary_tree.add_vector(&arr);
+    binary_tree.height();
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -135,10 +142,3 @@ mod tests {
         assert_eq!(binary_tree.height(), 4);
     }
 }
-
-fn main() {
-    let mut binary_tree = BinaryTree::<i32>::new();
-    let arr: Vec<i32> = (0..10).collect();
-    binary_tree.add_vector(&arr);
-    binary_tree.height();
-}
diff --git a/src/bin/c04p03.rs b/src/bin/c04p03.rs
index 2644d29..c3ff670 100644
--- a/src/bin/c04p03.rs
+++ b/src/bin/c04p03.rs
@@ -34,38 +34,38 @@ where
             ret
         } else {
             let mut head = self.head.as_mut().unwrap().clone();
-            self.insert_at(&mut head, ret)
+            Self::insert_at(&mut head, ret)
         }
     }
 
-    fn insert_at(&mut self, parent_node: &mut NodeRef<T>, new_node: NodeRef<T>) -> NodeRef<T> {
+    fn insert_at(parent_node: &mut NodeRef<T>, new_node: NodeRef<T>) -> NodeRef<T> {
         if new_node.borrow().data < parent_node.borrow().data {
             if parent_node.borrow().left.is_some() {
                 let mut new_parent = parent_node.borrow_mut().left.as_mut().unwrap().clone();
-                self.insert_at(&mut new_parent, new_node)
+                Self::insert_at(&mut new_parent, new_node)
             } else {
                 parent_node.borrow_mut().left = Some(new_node.clone());
                 new_node
             }
         } else if parent_node.borrow().right.is_some() {
             let mut new_parent = parent_node.borrow_mut().right.as_mut().unwrap().clone();
-            self.insert_at(&mut new_parent, new_node)
+            Self::insert_at(&mut new_parent, new_node)
         } else {
             parent_node.borrow_mut().right = Some(new_node.clone());
             new_node
         }
     }
 
-    fn visit_from<F>(&self, parent_node: &NodeRef<T>, f: &mut F)
+    fn visit_from<F>(parent_node: &NodeRef<T>, f: &mut F)
     where
         F: FnMut(&NodeRef<T>),
     {
         f(parent_node);
         if let Some(left) = parent_node.borrow().left.as_ref() {
-            self.visit_from(left, f);
+            Self::visit_from(left, f);
         }
         if let Some(right) = parent_node.borrow().right.as_ref() {
-            self.visit_from(right, f);
+            Self::visit_from(right, f);
         }
     }
 
@@ -74,7 +74,7 @@ where
         F: FnMut(&NodeRef<T>),
     {
         if self.head.is_some() {
-            self.visit_from(self.head.as_ref().unwrap(), &mut f)
+            Self::visit_from(self.head.as_ref().unwrap(), &mut f)
         }
     }
 
@@ -91,13 +91,13 @@ where
         }
     }
 
-    fn height_inner(&self, node: &NodeRef<T>, height: usize) -> usize {
+    fn height_inner(node: &NodeRef<T>, height: usize) -> usize {
         let mut max_height = height;
         if let Some(left) = node.borrow().left.as_ref() {
-            max_height = std::cmp::max(self.height_inner(left, height + 1), max_height);
+            max_height = std::cmp::max(Self::height_inner(left, height + 1), max_height);
         }
         if let Some(right) = node.borrow().right.as_ref() {
-            max_height = std::cmp::max(self.height_inner(right, height + 1), max_height);
+            max_height = std::cmp::max(Self::height_inner(right, height + 1), max_height);
         }
         max_height
     }
@@ -105,24 +105,24 @@ where
     fn height(&self) -> usize {
         let mut height = 0;
         if let Some(head) = self.head.as_ref() {
-            height = self.height_inner(head, height + 1);
+            height = Self::height_inner(head, height + 1);
         }
         height
     }
 
-    fn list_of_depths_inner(&self, node: &NodeRef<T>) -> Vec<Vec<NodeRef<T>>> {
+    fn list_of_depths_inner(node: &NodeRef<T>) -> Vec<Vec<NodeRef<T>>> {
         let mut result: Vec<Vec<NodeRef<T>>> = vec![vec![node.clone()]];
         if let Some(left) = node.borrow().left.as_ref() {
-            let mut left_result = self.list_of_depths_inner(left);
+            let mut left_result = Self::list_of_depths_inner(left);
             if let Some(right) = node.borrow().right.as_ref() {
-                let mut right_result = self.list_of_depths_inner(right);
+                let mut right_result = Self::list_of_depths_inner(right);
                 for (lefta, righta) in left_result.iter_mut().zip(right_result.iter_mut()) {
                     lefta.append(righta);
                 }
             }
             result.append(&mut left_result);
         } else if let Some(right) = node.borrow().right.as_ref() {
-            let subresult = self.list_of_depths_inner(right);
+            let subresult = Self::list_of_depths_inner(right);
             result.extend_from_slice(&subresult);
         }
         result
@@ -130,7 +130,7 @@ where
 
     fn list_of_depths(&self) -> Vec<Vec<NodeRef<T>>> {
         if let Some(head) = self.head.as_ref() {
-            self.list_of_depths_inner(head)
+            Self::list_of_depths_inner(head)
         } else {
             vec![]
         }
@@ -150,6 +150,14 @@ where
     }
 }
 
+fn main() {
+    let mut binary_tree = BinaryTree::<i32>::new();
+    let arr: Vec<i32> = (0..10).collect();
+    binary_tree.add_vector(&arr);
+    binary_tree.height();
+    let _list_of_depths = binary_tree.list_of_depths();
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -165,11 +173,3 @@ mod tests {
         assert_eq!(len_sum, 10);
     }
 }
-
-fn main() {
-    let mut binary_tree = BinaryTree::<i32>::new();
-    let arr: Vec<i32> = (0..10).collect();
-    binary_tree.add_vector(&arr);
-    binary_tree.height();
-    let _list_of_depths = binary_tree.list_of_depths();
-}
diff --git a/src/bin/c04p04.rs b/src/bin/c04p04.rs
index f9b6a7b..ea9fa19 100644
--- a/src/bin/c04p04.rs
+++ b/src/bin/c04p04.rs
@@ -34,38 +34,38 @@ where
             ret
         } else {
             let mut head = self.head.as_mut().unwrap().clone();
-            self.insert_at(&mut head, ret)
+            Self::insert_at(&mut head, ret)
         }
     }
 
-    fn insert_at(&mut self, parent_node: &mut NodeRef<T>, new_node: NodeRef<T>) -> NodeRef<T> {
+    fn insert_at(parent_node: &mut NodeRef<T>, new_node: NodeRef<T>) -> NodeRef<T> {
         if new_node.borrow().data < parent_node.borrow().data {
             if parent_node.borrow().left.is_some() {
                 let mut new_parent = parent_node.borrow_mut().left.as_mut().unwrap().clone();
-                self.insert_at(&mut new_parent, new_node)
+                Self::insert_at(&mut new_parent, new_node)
             } else {
                 parent_node.borrow_mut().left = Some(new_node.clone());
                 new_node
             }
         } else if parent_node.borrow().right.is_some() {
             let mut new_parent = parent_node.borrow_mut().right.as_mut().unwrap().clone();
-            self.insert_at(&mut new_parent, new_node)
+            Self::insert_at(&mut new_parent, new_node)
         } else {
             parent_node.borrow_mut().right = Some(new_node.clone());
             new_node
         }
     }
 
-    fn visit_from<F>(&self, parent_node: &NodeRef<T>, f: &mut F)
+    fn visit_from<F>(parent_node: &NodeRef<T>, f: &mut F)
     where
         F: FnMut(&NodeRef<T>),
     {
         f(parent_node);
         if let Some(left) = parent_node.borrow().left.as_ref() {
-            self.visit_from(left, f);
+            Self::visit_from(left, f);
         }
         if let Some(right) = parent_node.borrow().right.as_ref() {
-            self.visit_from(right, f);
+            Self::visit_from(right, f);
         }
     }
 
@@ -74,7 +74,7 @@ where
         F: FnMut(&NodeRef<T>),
     {
         if self.head.is_some() {
-            self.visit_from(self.head.as_ref().unwrap(), &mut f)
+            Self::visit_from(self.head.as_ref().unwrap(), &mut f)
         }
     }
 
@@ -91,20 +91,20 @@ where
         }
     }
 
-    fn height_inner(&self, node: &NodeRef<T>, height: usize) -> usize {
+    fn height_inner(node: &NodeRef<T>, height: usize) -> usize {
         let mut max_height = height;
         if let Some(left) = node.borrow().left.as_ref() {
-            max_height = std::cmp::max(self.height_inner(left, height + 1), max_height);
+            max_height = std::cmp::max(Self::height_inner(left, height + 1), max_height);
         }
         if let Some(right) = node.borrow().right.as_ref() {
-            max_height = std::cmp::max(self.height_inner(right, height + 1), max_height);
+            max_height = std::cmp::max(Self::height_inner(right, height + 1), max_height);
         }
         max_height
     }
 
     fn height(&self) -> usize {
         if let Some(head) = self.head.as_ref() {
-            self.height_inner(head, 1)
+            Self::height_inner(head, 1)
         } else {
             0
         }
@@ -114,10 +114,10 @@ where
         let mut left_height = 0;
         let mut right_height = 0;
         if let Some(left) = node.borrow().left.as_ref() {
-            left_height = self.height_inner(left, 1);
+            left_height = Self::height_inner(left, 1);
         }
         if let Some(right) = node.borrow().right.as_ref() {
-            right_height = self.height_inner(right, 1);
+            right_height = Self::height_inner(right, 1);
         }
         (left_height as i64 - right_height as i64).abs() <= 1
     }
@@ -144,6 +144,14 @@ where
     }
 }
 
+fn main() {
+    let mut binary_tree = BinaryTree::<i32>::new();
+    let arr: Vec<i32> = (0..10).collect();
+    binary_tree.add_vector(&arr);
+    binary_tree.height();
+    binary_tree.check_balanced();
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -154,21 +162,13 @@ mod tests {
         let arr: Vec<i32> = (0..10).collect();
         balanced_binary_tree.add_vector(&arr);
         assert_eq!(balanced_binary_tree.height(), 4);
-        assert_eq!(balanced_binary_tree.check_balanced(), true);
+        assert!(balanced_binary_tree.check_balanced());
 
         let mut imbalanced_binary_tree = BinaryTree::<i32>::new();
         for i in arr {
             imbalanced_binary_tree.insert(i);
         }
         assert_eq!(imbalanced_binary_tree.height(), 10);
-        assert_eq!(imbalanced_binary_tree.check_balanced(), false);
+        assert!(!imbalanced_binary_tree.check_balanced());
     }
 }
-
-fn main() {
-    let mut binary_tree = BinaryTree::<i32>::new();
-    let arr: Vec<i32> = (0..10).collect();
-    binary_tree.add_vector(&arr);
-    binary_tree.height();
-    binary_tree.check_balanced();
-}
diff --git a/src/bin/c04p05.rs b/src/bin/c04p05.rs
index cc1458a..173f924 100644
--- a/src/bin/c04p05.rs
+++ b/src/bin/c04p05.rs
@@ -34,38 +34,38 @@ where
             ret
         } else {
             let mut head = self.head.as_mut().unwrap().clone();
-            self.insert_at(&mut head, ret)
+            Self::insert_at(&mut head, ret)
         }
     }
 
-    fn insert_at(&mut self, parent_node: &mut NodeRef<T>, new_node: NodeRef<T>) -> NodeRef<T> {
+    fn insert_at(parent_node: &mut NodeRef<T>, new_node: NodeRef<T>) -> NodeRef<T> {
         if new_node.borrow().data < parent_node.borrow().data {
             if parent_node.borrow().left.is_some() {
                 let mut new_parent = parent_node.borrow_mut().left.as_mut().unwrap().clone();
-                self.insert_at(&mut new_parent, new_node)
+                Self::insert_at(&mut new_parent, new_node)
             } else {
                 parent_node.borrow_mut().left = Some(new_node.clone());
                 new_node
             }
         } else if parent_node.borrow().right.is_some() {
             let mut new_parent = parent_node.borrow_mut().right.as_mut().unwrap().clone();
-            self.insert_at(&mut new_parent, new_node)
+            Self::insert_at(&mut new_parent, new_node)
         } else {
             parent_node.borrow_mut().right = Some(new_node.clone());
             new_node
         }
     }
 
-    fn visit_from<F>(&self, parent_node: &NodeRef<T>, f: &mut F)
+    fn visit_from<F>(parent_node: &NodeRef<T>, f: &mut F)
     where
         F: FnMut(&NodeRef<T>),
     {
         f(parent_node);
         if let Some(left) = parent_node.borrow().left.as_ref() {
-            self.visit_from(left, f);
+            Self::visit_from(left, f);
         }
         if let Some(right) = parent_node.borrow().right.as_ref() {
-            self.visit_from(right, f);
+            Self::visit_from(right, f);
         }
     }
 
@@ -74,7 +74,7 @@ where
         F: FnMut(&NodeRef<T>),
     {
         if self.head.is_some() {
-            self.visit_from(self.head.as_ref().unwrap(), &mut f)
+            Self::visit_from(self.head.as_ref().unwrap(), &mut f)
         }
     }
 
@@ -91,27 +91,27 @@ where
         }
     }
 
-    fn check_is_bst_inner(&self, node: &NodeRef<T>) -> bool {
+    fn check_is_bst_inner(node: &NodeRef<T>) -> bool {
         let mut left_is_bst = true;
         let mut right_is_bst = true;
         if let Some(left) = node.borrow().left.as_ref() {
             if left.borrow().data >= node.borrow().data {
                 return false;
             }
-            left_is_bst = self.check_is_bst_inner(left);
+            left_is_bst = Self::check_is_bst_inner(left);
         }
         if let Some(right) = node.borrow().right.as_ref() {
             if right.borrow().data < node.borrow().data {
                 return false;
             }
-            right_is_bst = self.check_is_bst_inner(right);
+            right_is_bst = Self::check_is_bst_inner(right);
         }
         left_is_bst && right_is_bst
     }
 
     fn check_is_bst(&self) -> bool {
         if let Some(head) = self.head.as_ref() {
-            self.check_is_bst_inner(head)
+            Self::check_is_bst_inner(head)
         } else {
             true
         }
@@ -131,6 +131,13 @@ where
     }
 }
 
+fn main() {
+    let mut binary_tree = BinaryTree::<i32>::new();
+    let arr: Vec<i32> = (0..10).collect();
+    binary_tree.add_vector(&arr);
+    binary_tree.check_is_bst();
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -140,7 +147,7 @@ mod tests {
         let mut balanced_binary_tree = BinaryTree::<i32>::new();
         let arr: Vec<i32> = (0..10).collect();
         balanced_binary_tree.add_vector(&arr);
-        assert_eq!(balanced_binary_tree.check_is_bst(), true);
+        assert!(balanced_binary_tree.check_is_bst());
 
         let mut imbalanced_binary_tree = BinaryTree::<i32>::new();
         for i in arr {
@@ -151,13 +158,6 @@ mod tests {
                 right: None,
             })));
         }
-        assert_eq!(imbalanced_binary_tree.check_is_bst(), false);
+        assert!(!imbalanced_binary_tree.check_is_bst());
     }
 }
-
-fn main() {
-    let mut binary_tree = BinaryTree::<i32>::new();
-    let arr: Vec<i32> = (0..10).collect();
-    binary_tree.add_vector(&arr);
-    binary_tree.check_is_bst();
-}
diff --git a/src/bin/c04p06.rs b/src/bin/c04p06.rs
index 3accae2..f8fde10 100644
--- a/src/bin/c04p06.rs
+++ b/src/bin/c04p06.rs
@@ -34,38 +34,38 @@ where
             ret
         } else {
             let mut head = self.head.as_mut().unwrap().clone();
-            self.insert_at(&mut head, ret)
+            Self::insert_at(&mut head, ret)
         }
     }
 
-    fn insert_at(&mut self, parent_node: &mut NodeRef<T>, new_node: NodeRef<T>) -> NodeRef<T> {
+    fn insert_at(parent_node: &mut NodeRef<T>, new_node: NodeRef<T>) -> NodeRef<T> {
         if new_node.borrow().data < parent_node.borrow().data {
             if parent_node.borrow().left.is_some() {
                 let mut new_parent = parent_node.borrow_mut().left.as_mut().unwrap().clone();
-                self.insert_at(&mut new_parent, new_node)
+                Self::insert_at(&mut new_parent, new_node)
             } else {
                 parent_node.borrow_mut().left = Some(new_node.clone());
                 new_node
             }
         } else if parent_node.borrow().right.is_some() {
             let mut new_parent = parent_node.borrow_mut().right.as_mut().unwrap().clone();
-            self.insert_at(&mut new_parent, new_node)
+            Self::insert_at(&mut new_parent, new_node)
         } else {
             parent_node.borrow_mut().right = Some(new_node.clone());
             new_node
         }
     }
 
-    fn visit_from<F>(&self, parent_node: &NodeRef<T>, f: &mut F)
+    fn visit_from<F>(parent_node: &NodeRef<T>, f: &mut F)
     where
         F: FnMut(&NodeRef<T>),
     {
         f(parent_node);
         if let Some(left) = parent_node.borrow().left.as_ref() {
-            self.visit_from(left, f);
+            Self::visit_from(left, f);
         }
         if let Some(right) = parent_node.borrow().right.as_ref() {
-            self.visit_from(right, f);
+            Self::visit_from(right, f);
         }
     }
 
@@ -74,7 +74,7 @@ where
         F: FnMut(&NodeRef<T>),
     {
         if self.head.is_some() {
-            self.visit_from(self.head.as_ref().unwrap(), &mut f)
+            Self::visit_from(self.head.as_ref().unwrap(), &mut f)
         }
     }
 
@@ -91,16 +91,16 @@ where
         }
     }
 
-    fn dfs_from<F>(&self, f: &mut F, node: NodeRef<T>)
+    fn dfs_from<F>(f: &mut F, node: NodeRef<T>)
     where
         F: FnMut(&NodeRef<T>),
     {
         if let Some(left) = node.borrow().left.as_ref() {
-            self.dfs_from(f, left.clone());
+            Self::dfs_from(f, left.clone());
         }
         f(&node);
         if let Some(right) = node.borrow().right.as_ref() {
-            self.dfs_from(f, right.clone());
+            Self::dfs_from(f, right.clone());
         }
     }
 
@@ -109,7 +109,7 @@ where
         F: FnMut(&NodeRef<T>),
     {
         if let Some(head) = &self.head {
-            self.dfs_from(&mut f, head.clone());
+            Self::dfs_from(&mut f, head.clone());
         }
     }
 }
@@ -127,6 +127,13 @@ where
     }
 }
 
+fn main() {
+    let mut binary_tree = BinaryTree::<i32>::new();
+    let arr: Vec<i32> = (0..10).collect();
+    binary_tree.add_vector(&arr);
+    binary_tree.dfs(|node| println!("{}", node.borrow().data));
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -143,10 +150,3 @@ mod tests {
         });
     }
 }
-
-fn main() {
-    let mut binary_tree = BinaryTree::<i32>::new();
-    let arr: Vec<i32> = (0..10).collect();
-    binary_tree.add_vector(&arr);
-    binary_tree.dfs(|node| println!("{}", node.borrow().data));
-}
diff --git a/src/bin/c04p07.rs b/src/bin/c04p07.rs
index 82daa59..5d77331 100644
--- a/src/bin/c04p07.rs
+++ b/src/bin/c04p07.rs
@@ -35,12 +35,12 @@ impl<T> Graph<T> {
         ret
     }
 
-    fn dfs_from<F>(&self, f: &mut F, vertex: VertexRef<T>)
+    fn dfs_from<F>(f: &mut F, vertex: VertexRef<T>)
     where
         F: FnMut(&VertexRef<T>),
     {
         for v in vertex.borrow().edges.iter() {
-            self.dfs_from(f, v.clone());
+            Self::dfs_from(f, v.clone());
         }
         f(&vertex);
     }
@@ -50,7 +50,7 @@ impl<T> Graph<T> {
         F: FnMut(&VertexRef<T>),
     {
         for head in self.head.iter() {
-            self.dfs_from(&mut f, head.clone());
+            Self::dfs_from(&mut f, head.clone());
         }
     }
 }
@@ -65,6 +65,25 @@ impl<T: Display> Display for Graph<T> {
     }
 }
 
+fn main() {
+    let mut graph = Graph::<char>::new();
+    let c_vertex = graph.add_vertex('c', &[]);
+    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]);
+    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();
+    graph.dfs(|vertex| {
+        let value = vertex.borrow().data;
+        if !graph_order.contains(&value) {
+            graph_order.push(value);
+        }
+    });
+    assert_eq!(graph_order, vec!['f', 'a', 'b', 'd', 'c', 'e']);
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -89,22 +108,3 @@ mod tests {
         assert_eq!(graph_order, vec!['f', 'a', 'b', 'd', 'c', 'e']);
     }
 }
-
-fn main() {
-    let mut graph = Graph::<char>::new();
-    let c_vertex = graph.add_vertex('c', &[]);
-    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]);
-    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();
-    graph.dfs(|vertex| {
-        let value = vertex.borrow().data;
-        if !graph_order.contains(&value) {
-            graph_order.push(value);
-        }
-    });
-    assert_eq!(graph_order, vec!['f', 'a', 'b', 'd', 'c', 'e']);
-}
diff --git a/src/bin/c04p08.rs b/src/bin/c04p08.rs
index aade0be..24a69bd 100644
--- a/src/bin/c04p08.rs
+++ b/src/bin/c04p08.rs
@@ -35,12 +35,12 @@ impl<T> Graph<T> {
         ret
     }
 
-    fn dfs_from<F>(&self, f: &mut F, vertex: VertexRef<T>)
+    fn dfs_from<F>(f: &mut F, vertex: VertexRef<T>)
     where
         F: FnMut(&VertexRef<T>),
     {
         for v in vertex.borrow().edges.iter() {
-            self.dfs_from(f, v.clone());
+            Self::dfs_from(f, v.clone());
         }
         f(&vertex);
     }
@@ -50,12 +50,11 @@ impl<T> Graph<T> {
         F: FnMut(&VertexRef<T>),
     {
         for head in self.head.iter() {
-            self.dfs_from(&mut f, head.clone());
+            Self::dfs_from(&mut f, head.clone());
         }
     }
 
     fn common_ancestor_from<F>(
-        &self,
         f: &mut F,
         vertex: VertexRef<T>,
         left_vertex: &VertexRef<T>,
@@ -76,7 +75,7 @@ impl<T> Graph<T> {
             }
         }
         for v in vertex.borrow().edges.iter() {
-            if self.common_ancestor_from(f, v.clone(), left_vertex, right_vertex) {
+            if Self::common_ancestor_from(f, v.clone(), left_vertex, right_vertex) {
                 return true;
             }
         }
@@ -88,7 +87,7 @@ impl<T> Graph<T> {
         F: FnMut(&VertexRef<T>),
     {
         for head in self.head.iter() {
-            if self.common_ancestor_from(&mut f, head.clone(), &left_vertex, &right_vertex) {
+            if Self::common_ancestor_from(&mut f, head.clone(), &left_vertex, &right_vertex) {
                 return;
             }
         }
@@ -105,6 +104,23 @@ impl<T: Display> Display for Graph<T> {
     }
 }
 
+fn main() {
+    let mut graph = Graph::<char>::new();
+    let c_vertex = graph.add_vertex('c', &[]);
+    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, b_vertex, |vertex| {
+        was_called = true;
+        assert!(Rc::ptr_eq(vertex, &d_vertex))
+    });
+    assert!(was_called);
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -122,25 +138,8 @@ mod tests {
         let mut was_called = false;
         graph.common_ancestor(a_vertex, b_vertex, |vertex| {
             was_called = true;
-            assert_eq!(Rc::ptr_eq(vertex, &d_vertex), true)
+            assert!(Rc::ptr_eq(vertex, &d_vertex))
         });
-        assert_eq!(was_called, true);
+        assert!(was_called);
     }
 }
-
-fn main() {
-    let mut graph = Graph::<char>::new();
-    let c_vertex = graph.add_vertex('c', &[]);
-    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, b_vertex, |vertex| {
-        was_called = true;
-        assert_eq!(Rc::ptr_eq(vertex, &d_vertex), true)
-    });
-    assert_eq!(was_called, true);
-}
diff --git a/src/bin/c04p09.rs b/src/bin/c04p09.rs
index 815aa4e..38c57d3 100644
--- a/src/bin/c04p09.rs
+++ b/src/bin/c04p09.rs
@@ -34,38 +34,38 @@ where
             ret
         } else {
             let mut head = self.head.as_mut().unwrap().clone();
-            self.insert_at(&mut head, ret)
+            Self::insert_at(&mut head, ret)
         }
     }
 
-    fn insert_at(&mut self, parent_node: &mut NodeRef<T>, new_node: NodeRef<T>) -> NodeRef<T> {
+    fn insert_at(parent_node: &mut NodeRef<T>, new_node: NodeRef<T>) -> NodeRef<T> {
         if new_node.borrow().data < parent_node.borrow().data {
             if parent_node.borrow().left.is_some() {
                 let mut new_parent = parent_node.borrow_mut().left.as_mut().unwrap().clone();
-                self.insert_at(&mut new_parent, new_node)
+                Self::insert_at(&mut new_parent, new_node)
             } else {
                 parent_node.borrow_mut().left = Some(new_node.clone());
                 new_node
             }
         } else if parent_node.borrow().right.is_some() {
             let mut new_parent = parent_node.borrow_mut().right.as_mut().unwrap().clone();
-            self.insert_at(&mut new_parent, new_node)
+            Self::insert_at(&mut new_parent, new_node)
         } else {
             parent_node.borrow_mut().right = Some(new_node.clone());
             new_node
         }
     }
 
-    fn visit_from<F>(&self, parent_node: &NodeRef<T>, f: &mut F)
+    fn visit_from<F>(parent_node: &NodeRef<T>, f: &mut F)
     where
         F: FnMut(&NodeRef<T>),
     {
         f(parent_node);
         if let Some(left) = parent_node.borrow().left.as_ref() {
-            self.visit_from(left, f);
+            Self::visit_from(left, f);
         }
         if let Some(right) = parent_node.borrow().right.as_ref() {
-            self.visit_from(right, f);
+            Self::visit_from(right, f);
         }
     }
 
@@ -74,16 +74,16 @@ where
         F: FnMut(&NodeRef<T>),
     {
         if self.head.is_some() {
-            self.visit_from(self.head.as_ref().unwrap(), &mut f)
+            Self::visit_from(self.head.as_ref().unwrap(), &mut f)
         }
     }
 
-    fn get_bst_sequences_inner(&self, node: &NodeRef<T>) -> Vec<Vec<T>> {
+    fn get_bst_sequences_inner(node: &NodeRef<T>) -> Vec<Vec<T>> {
         let mut final_seqs: Vec<Vec<T>> = vec![];
         if let Some(left) = node.borrow().left.as_ref() {
             if let Some(right) = node.borrow().right.as_ref() {
-                let left_seqs = self.get_bst_sequences_inner(left);
-                let right_seqs = self.get_bst_sequences_inner(right);
+                let left_seqs = Self::get_bst_sequences_inner(left);
+                let right_seqs = Self::get_bst_sequences_inner(right);
                 for seq_l in left_seqs.iter() {
                     for seq_r in right_seqs.iter() {
                         let mut l_s: Vec<T> = vec![];
@@ -99,7 +99,7 @@ where
                     }
                 }
             } else {
-                let left_seqs = self.get_bst_sequences_inner(left);
+                let left_seqs = Self::get_bst_sequences_inner(left);
                 for seq_l in left_seqs.iter() {
                     let mut l_s: Vec<T> = vec![];
                     l_s.push(node.borrow().data);
@@ -108,7 +108,7 @@ where
                 }
             }
         } else if let Some(right) = node.borrow().right.as_ref() {
-            let right_seqs = self.get_bst_sequences_inner(right);
+            let right_seqs = Self::get_bst_sequences_inner(right);
             for seq_r in right_seqs.iter() {
                 let mut r_s: Vec<T> = vec![];
                 r_s.push(node.borrow().data);
@@ -116,16 +116,14 @@ where
                 final_seqs.push(r_s);
             }
         } else {
-            let mut s: Vec<T> = vec![];
-            s.push(node.borrow().data);
-            final_seqs.push(s)
+            final_seqs.push(vec![node.borrow().data]);
         }
         final_seqs
     }
 
     fn get_bst_sequences(&self) -> Vec<Vec<T>> {
         if let Some(head) = self.head.as_ref() {
-            self.get_bst_sequences_inner(head)
+            Self::get_bst_sequences_inner(head)
         } else {
             vec![]
         }
@@ -145,6 +143,16 @@ where
     }
 }
 
+fn main() {
+    let mut binary_tree = BinaryTree::<i32>::new();
+    binary_tree.insert(2);
+    binary_tree.insert(1);
+    binary_tree.insert(3);
+
+    let sequences = binary_tree.get_bst_sequences();
+    assert_eq!(sequences, vec![vec![2, 1, 3], vec![2, 3, 1],]);
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -160,13 +168,3 @@ mod tests {
         assert_eq!(sequences, vec![vec![2, 1, 3], vec![2, 3, 1],]);
     }
 }
-
-fn main() {
-    let mut binary_tree = BinaryTree::<i32>::new();
-    binary_tree.insert(2);
-    binary_tree.insert(1);
-    binary_tree.insert(3);
-
-    let sequences = binary_tree.get_bst_sequences();
-    assert_eq!(sequences, vec![vec![2, 1, 3], vec![2, 3, 1],]);
-}
diff --git a/src/bin/c04p10.rs b/src/bin/c04p10.rs
index 076ce27..53b183b 100644
--- a/src/bin/c04p10.rs
+++ b/src/bin/c04p10.rs
@@ -34,38 +34,38 @@ where
             ret
         } else {
             let mut head = self.head.as_mut().unwrap().clone();
-            self.insert_at(&mut head, ret)
+            Self::insert_at(&mut head, ret)
         }
     }
 
-    fn insert_at(&mut self, parent_node: &mut NodeRef<T>, new_node: NodeRef<T>) -> NodeRef<T> {
+    fn insert_at(parent_node: &mut NodeRef<T>, new_node: NodeRef<T>) -> NodeRef<T> {
         if new_node.borrow().data < parent_node.borrow().data {
             if parent_node.borrow().left.is_some() {
                 let mut new_parent = parent_node.borrow_mut().left.as_mut().unwrap().clone();
-                self.insert_at(&mut new_parent, new_node)
+                Self::insert_at(&mut new_parent, new_node)
             } else {
                 parent_node.borrow_mut().left = Some(new_node.clone());
                 new_node
             }
         } else if parent_node.borrow().right.is_some() {
             let mut new_parent = parent_node.borrow_mut().right.as_mut().unwrap().clone();
-            self.insert_at(&mut new_parent, new_node)
+            Self::insert_at(&mut new_parent, new_node)
         } else {
             parent_node.borrow_mut().right = Some(new_node.clone());
             new_node
         }
     }
 
-    fn visit_from<F>(&self, parent_node: &NodeRef<T>, f: &mut F)
+    fn visit_from<F>(parent_node: &NodeRef<T>, f: &mut F)
     where
         F: FnMut(&NodeRef<T>),
     {
         f(parent_node);
         if let Some(left) = parent_node.borrow().left.as_ref() {
-            self.visit_from(left, f);
+            Self::visit_from(left, f);
         }
         if let Some(right) = parent_node.borrow().right.as_ref() {
-            self.visit_from(right, f);
+            Self::visit_from(right, f);
         }
     }
 
@@ -74,17 +74,17 @@ where
         F: FnMut(&NodeRef<T>),
     {
         if self.head.is_some() {
-            self.visit_from(self.head.as_ref().unwrap(), &mut f)
+            Self::visit_from(self.head.as_ref().unwrap(), &mut f)
         }
     }
 
-    fn trees_equal(&self, head: &NodeRef<T>, other_head: &NodeRef<T>) -> bool {
+    fn trees_equal(head: &NodeRef<T>, other_head: &NodeRef<T>) -> bool {
         if head.borrow().data != other_head.borrow().data {
             return false;
         }
         if let Some(left) = head.borrow().left.as_ref() {
             if let Some(other_left) = other_head.borrow().left.as_ref() {
-                if !self.trees_equal(left, other_left) {
+                if !Self::trees_equal(left, other_left) {
                     return false;
                 }
             } else {
@@ -95,7 +95,7 @@ where
         }
         if let Some(right) = head.borrow().right.as_ref() {
             if let Some(other_right) = other_head.borrow().right.as_ref() {
-                return self.trees_equal(right, other_right);
+                return Self::trees_equal(right, other_right);
             } else {
                 return false;
             }
@@ -105,7 +105,7 @@ where
         true
     }
 
-    fn find_head<F>(&self, head: &NodeRef<T>, node: &NodeRef<T>, f: &F) -> bool
+    fn find_head<F>(head: &NodeRef<T>, node: &NodeRef<T>, f: &F) -> bool
     where
         F: Fn(&NodeRef<T>) -> bool,
     {
@@ -113,12 +113,12 @@ where
             return f(node);
         }
         if let Some(left) = node.borrow().left.as_ref() {
-            if self.find_head(head, left, f) {
+            if Self::find_head(head, left, f) {
                 return true;
             }
         }
         if let Some(right) = node.borrow().right.as_ref() {
-            return self.find_head(head, right, f);
+            return Self::find_head(head, right, f);
         }
         false
     }
@@ -126,8 +126,8 @@ where
     fn is_subtree(&self, other: &BinaryTree<T>) -> bool {
         if let Some(head) = self.head.as_ref() {
             if let Some(other_head) = other.head.as_ref() {
-                return self.find_head(head, other_head, &|root_node| {
-                    self.trees_equal(head, root_node)
+                return Self::find_head(head, other_head, &|root_node| {
+                    Self::trees_equal(head, root_node)
                 });
             }
         }
@@ -148,6 +148,19 @@ where
     }
 }
 
+fn main() {
+    let mut t1 = BinaryTree::<i32>::new();
+    t1.insert(2);
+    t1.insert(1);
+    t1.insert(3);
+
+    let mut t2 = BinaryTree::<i32>::new();
+    t2.insert(2);
+    t2.insert(1);
+    t2.insert(3);
+
+    t2.is_subtree(&t1);
+}
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -164,26 +177,12 @@ mod tests {
         t2.insert(1);
         t2.insert(3);
 
-        assert_eq!(t2.is_subtree(&t1), true);
+        assert!(t2.is_subtree(&t1));
 
         let mut t3 = BinaryTree::<i32>::new();
         t3.insert(5);
         t3.insert(6);
         t3.insert(8);
-        assert_eq!(t3.is_subtree(&t1), false);
+        assert!(!t3.is_subtree(&t1));
     }
 }
-
-fn main() {
-    let mut t1 = BinaryTree::<i32>::new();
-    t1.insert(2);
-    t1.insert(1);
-    t1.insert(3);
-
-    let mut t2 = BinaryTree::<i32>::new();
-    t2.insert(2);
-    t2.insert(1);
-    t2.insert(3);
-
-    t2.is_subtree(&t1);
-}
diff --git a/src/bin/c04p11.rs b/src/bin/c04p11.rs
index c734e50..c31938e 100644
--- a/src/bin/c04p11.rs
+++ b/src/bin/c04p11.rs
@@ -1,11 +1,12 @@
 extern crate rand;
 
-use rand::seq::SliceRandom;
-use rand::thread_rng;
 use std::cell::RefCell;
 use std::fmt::Display;
 use std::rc::Rc;
 
+use rand::rng;
+use rand::seq::IndexedMutRandom;
+
 type NodeRef<T> = Rc<RefCell<Node<T>>>;
 
 struct BinaryTree<T> {
@@ -38,38 +39,38 @@ where
             ret
         } else {
             let mut head = self.head.as_mut().unwrap().clone();
-            self.insert_at(&mut head, ret)
+            Self::insert_at(&mut head, ret)
         }
     }
 
-    fn insert_at(&mut self, parent_node: &mut NodeRef<T>, new_node: NodeRef<T>) -> NodeRef<T> {
+    fn insert_at(parent_node: &mut NodeRef<T>, new_node: NodeRef<T>) -> NodeRef<T> {
         if new_node.borrow().data < parent_node.borrow().data {
             if parent_node.borrow().left.is_some() {
                 let mut new_parent = parent_node.borrow_mut().left.as_mut().unwrap().clone();
-                self.insert_at(&mut new_parent, new_node)
+                Self::insert_at(&mut new_parent, new_node)
             } else {
                 parent_node.borrow_mut().left = Some(new_node.clone());
                 new_node
             }
         } else if parent_node.borrow().right.is_some() {
             let mut new_parent = parent_node.borrow_mut().right.as_mut().unwrap().clone();
-            self.insert_at(&mut new_parent, new_node)
+            Self::insert_at(&mut new_parent, new_node)
         } else {
             parent_node.borrow_mut().right = Some(new_node.clone());
             new_node
         }
     }
 
-    fn visit_from<F>(&self, parent_node: &NodeRef<T>, f: &mut F)
+    fn visit_from<F>(parent_node: &NodeRef<T>, f: &mut F)
     where
         F: FnMut(&NodeRef<T>),
     {
         f(parent_node);
         if let Some(left) = parent_node.borrow().left.as_ref() {
-            self.visit_from(left, f);
+            Self::visit_from(left, f);
         }
         if let Some(right) = parent_node.borrow().right.as_ref() {
-            self.visit_from(right, f);
+            Self::visit_from(right, f);
         }
     }
 
@@ -78,15 +79,15 @@ where
         F: FnMut(&NodeRef<T>),
     {
         if self.head.is_some() {
-            self.visit_from(self.head.as_ref().unwrap(), &mut f)
+            Self::visit_from(self.head.as_ref().unwrap(), &mut f)
         }
     }
 
     fn get_random_node(&self) -> NodeRef<T> {
         let mut nodes: Vec<NodeRef<T>> = vec![];
         self.visit_all(|v| nodes.push(v.clone()));
-        let mut rng = thread_rng();
-        nodes.choose(&mut rng).unwrap().clone()
+        let mut rng = rng();
+        nodes.choose_mut(&mut rng).unwrap().clone()
     }
 }
 
@@ -103,6 +104,14 @@ where
     }
 }
 
+fn main() {
+    let mut t1 = BinaryTree::<i32>::new();
+    t1.insert(2);
+    t1.insert(1);
+    t1.insert(3);
+    t1.get_random_node();
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -114,17 +123,6 @@ mod tests {
         t1.insert(1);
         t1.insert(3);
 
-        assert_eq!(
-            vec![1, 2, 3].contains(&t1.get_random_node().borrow().data),
-            true
-        );
+        assert!([1, 2, 3].contains(&t1.get_random_node().borrow().data),);
     }
 }
-
-fn main() {
-    let mut t1 = BinaryTree::<i32>::new();
-    t1.insert(2);
-    t1.insert(1);
-    t1.insert(3);
-    t1.get_random_node();
-}
diff --git a/src/bin/c04p12.rs b/src/bin/c04p12.rs
index 625dd2a..9c3aaee 100644
--- a/src/bin/c04p12.rs
+++ b/src/bin/c04p12.rs
@@ -33,38 +33,38 @@ impl BinaryTree {
             ret
         } else {
             let mut head = self.head.as_mut().unwrap().clone();
-            self.insert_at(&mut head, ret)
+            Self::insert_at(&mut head, ret)
         }
     }
 
-    fn insert_at(&mut self, parent_node: &mut NodeRef, new_node: NodeRef) -> NodeRef {
+    fn insert_at(parent_node: &mut NodeRef, new_node: NodeRef) -> NodeRef {
         if new_node.borrow().data < parent_node.borrow().data {
             if parent_node.borrow().left.is_some() {
                 let mut new_parent = parent_node.borrow_mut().left.as_mut().unwrap().clone();
-                self.insert_at(&mut new_parent, new_node)
+                Self::insert_at(&mut new_parent, new_node)
             } else {
                 parent_node.borrow_mut().left = Some(new_node.clone());
                 new_node
             }
         } else if parent_node.borrow().right.is_some() {
             let mut new_parent = parent_node.borrow_mut().right.as_mut().unwrap().clone();
-            self.insert_at(&mut new_parent, new_node)
+            Self::insert_at(&mut new_parent, new_node)
         } else {
             parent_node.borrow_mut().right = Some(new_node.clone());
             new_node
         }
     }
 
-    fn visit_from<F>(&self, parent_node: &NodeRef, f: &mut F)
+    fn visit_from<F>(parent_node: &NodeRef, f: &mut F)
     where
         F: FnMut(&NodeRef),
     {
         f(parent_node);
         if let Some(left) = parent_node.borrow().left.as_ref() {
-            self.visit_from(left, f);
+            Self::visit_from(left, f);
         }
         if let Some(right) = parent_node.borrow().right.as_ref() {
-            self.visit_from(right, f);
+            Self::visit_from(right, f);
         }
     }
 
@@ -73,30 +73,30 @@ impl BinaryTree {
         F: FnMut(&NodeRef),
     {
         if self.head.is_some() {
-            self.visit_from(self.head.as_ref().unwrap(), &mut f)
+            Self::visit_from(self.head.as_ref().unwrap(), &mut f)
         }
     }
 
-    fn paths_with_sum_inner(&self, node: &NodeRef, sum: i32, accumulation: i32) -> i32 {
+    fn paths_with_sum_inner(node: &NodeRef, sum: i32, accumulation: i32) -> i32 {
         let mut paths = 0;
         let new_acc = accumulation + node.borrow().data;
         if new_acc == sum {
             paths += 1;
         }
         if let Some(left) = node.borrow().left.as_ref() {
-            paths += self.paths_with_sum_inner(left, sum, new_acc);
-            paths += self.paths_with_sum_inner(left, sum, 0);
+            paths += Self::paths_with_sum_inner(left, sum, new_acc);
+            paths += Self::paths_with_sum_inner(left, sum, 0);
         }
         if let Some(right) = node.borrow().right.as_ref() {
-            paths += self.paths_with_sum_inner(right, sum, new_acc);
-            paths += self.paths_with_sum_inner(right, sum, 0);
+            paths += Self::paths_with_sum_inner(right, sum, new_acc);
+            paths += Self::paths_with_sum_inner(right, sum, 0);
         }
         paths
     }
 
     fn paths_with_sum(&self, sum: i32) -> i32 {
         if let Some(head) = self.head.as_ref() {
-            self.paths_with_sum_inner(head, sum, 0)
+            Self::paths_with_sum_inner(head, sum, 0)
         } else {
             0
         }
@@ -113,6 +113,14 @@ impl Display for BinaryTree {
     }
 }
 
+fn main() {
+    let mut t1 = BinaryTree::new();
+    t1.insert(2);
+    t1.insert(1);
+    t1.insert(3);
+    t1.paths_with_sum(1);
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -133,11 +141,3 @@ mod tests {
         assert_eq!(t1.paths_with_sum(5), 2);
     }
 }
-
-fn main() {
-    let mut t1 = BinaryTree::new();
-    t1.insert(2);
-    t1.insert(1);
-    t1.insert(3);
-    t1.paths_with_sum(1);
-}
diff --git a/src/bin/c05p01.rs b/src/bin/c05p01.rs
index a3029a4..ad9efe1 100644
--- a/src/bin/c05p01.rs
+++ b/src/bin/c05p01.rs
@@ -9,6 +9,10 @@ fn insert_bits(n: i32, m: i32, i: i32, j: i32) -> i32 {
     ret
 }
 
+fn main() {
+    insert_bits(0b100_0000_0000, 0b10011, 2, 6);
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -18,7 +22,3 @@ mod tests {
         assert_eq!(insert_bits(0b100_0000_0000, 0b10011, 2, 6), 0b100_0100_1100);
     }
 }
-
-fn main() {
-    insert_bits(0b100_0000_0000, 0b10011, 2, 6);
-}
diff --git a/src/bin/c05p02.rs b/src/bin/c05p02.rs
index dc2a4bc..b9e6b67 100644
--- a/src/bin/c05p02.rs
+++ b/src/bin/c05p02.rs
@@ -11,6 +11,10 @@ fn float_bits_to_str(n: f64) -> String {
     ret
 }
 
+fn main() {
+    float_bits_to_str(0.72);
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -23,7 +27,3 @@ mod tests {
         );
     }
 }
-
-fn main() {
-    float_bits_to_str(0.72);
-}
diff --git a/src/bin/c05p03.rs b/src/bin/c05p03.rs
index b07493b..afa4cee 100644
--- a/src/bin/c05p03.rs
+++ b/src/bin/c05p03.rs
@@ -20,6 +20,10 @@ fn flip_bit_to_win(n: i32) -> i32 {
     ret
 }
 
+fn main() {
+    flip_bit_to_win(0b11_0001);
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -30,7 +34,3 @@ mod tests {
         assert_eq!(flip_bit_to_win(0b11_0001), 3);
     }
 }
-
-fn main() {
-    flip_bit_to_win(0b11_0001);
-}
diff --git a/src/bin/c05p04.rs b/src/bin/c05p04.rs
index cd736ad..371c226 100644
--- a/src/bin/c05p04.rs
+++ b/src/bin/c05p04.rs
@@ -13,7 +13,7 @@ fn next_number(n: i32) -> (i32, i32) {
     let mut next_largest = 0;
     let mut c = n + 1;
     let one_count = count_ones(n);
-    while c < std::i32::MAX {
+    while c < i32::MAX {
         if count_ones(c) == one_count {
             next_largest = c;
             break;
@@ -31,6 +31,10 @@ fn next_number(n: i32) -> (i32, i32) {
     (next_smallest, next_largest)
 }
 
+fn main() {
+    next_number(0b100);
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -40,7 +44,3 @@ mod tests {
         assert_eq!(next_number(0b100), (0b10, 0b1000));
     }
 }
-
-fn main() {
-    next_number(0b100);
-}
diff --git a/src/bin/c05p06.rs b/src/bin/c05p06.rs
index 6c27029..d3b9bde 100644
--- a/src/bin/c05p06.rs
+++ b/src/bin/c05p06.rs
@@ -13,6 +13,10 @@ fn conversion_count(a: i32, b: i32) -> i32 {
     count_ones(xor)
 }
 
+fn main() {
+    conversion_count(0b1_1101, 0b0_1111);
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -22,7 +26,3 @@ mod tests {
         assert_eq!(conversion_count(0b1_1101, 0b0_1111), 2);
     }
 }
-
-fn main() {
-    conversion_count(0b1_1101, 0b0_1111);
-}
diff --git a/src/bin/c05p07.rs b/src/bin/c05p07.rs
index 8dc0a38..a0c5704 100644
--- a/src/bin/c05p07.rs
+++ b/src/bin/c05p07.rs
@@ -2,6 +2,12 @@ fn bitwise_swap(a: &mut i32, b: &mut i32) {
     std::mem::swap(&mut (*a), &mut (*b))
 }
 
+fn main() {
+    let mut a = 0b110;
+    let mut b = 0b001;
+    bitwise_swap(&mut a, &mut b);
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -15,9 +21,3 @@ mod tests {
         assert_eq!(b, 0b110);
     }
 }
-
-fn main() {
-    let mut a = 0b110;
-    let mut b = 0b001;
-    bitwise_swap(&mut a, &mut b);
-}
diff --git a/src/bin/c05p08.rs b/src/bin/c05p08.rs
index 4717fbf..b820b51 100644
--- a/src/bin/c05p08.rs
+++ b/src/bin/c05p08.rs
@@ -1,4 +1,4 @@
-fn draw_line(bytes: &mut Vec<u8>, width: usize, x1: usize, x2: usize, y: usize) {
+fn draw_line(bytes: &mut [u8], width: usize, x1: usize, x2: usize, y: usize) {
     let start_pos = y * width + x1;
     let end_pos = y * width + x2;
     for i in start_pos..end_pos {
@@ -6,6 +6,12 @@ fn draw_line(bytes: &mut Vec<u8>, width: usize, x1: usize, x2: usize, y: usize)
     }
 }
 
+fn main() {
+    let v: u8 = 0;
+    let mut vec = vec![v; 8];
+    draw_line(&mut vec, 8, 0, 8, 1);
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -18,9 +24,3 @@ mod tests {
         assert_eq!(vec, vec![0, 255, 0, 0, 0, 0, 0, 0]);
     }
 }
-
-fn main() {
-    let v: u8 = 0;
-    let mut vec = vec![v; 8];
-    draw_line(&mut vec, 8, 0, 8, 1);
-}
diff --git a/src/bin/c07p01.rs b/src/bin/c07p01.rs
index ba95ea5..7e6c48b 100644
--- a/src/bin/c07p01.rs
+++ b/src/bin/c07p01.rs
@@ -23,12 +23,14 @@ enum Rank {
     Ace,
 }
 
+#[allow(dead_code)]
 #[derive(Copy, Clone, Debug)]
 struct Card {
     suit: Suit,
     rank: Rank,
 }
 
+#[allow(dead_code)]
 #[derive(Clone, Debug)]
 struct DeckOfCards {
     cards: Vec<Card>,
@@ -102,6 +104,10 @@ impl DeckOfCards {
     }
 }
 
+fn main() {
+    let _deck_of_cards = DeckOfCards::new();
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -112,7 +118,3 @@ mod tests {
         assert_eq!(deck_of_cards.cards.len(), 52);
     }
 }
-
-fn main() {
-    let _deck_of_cards = DeckOfCards::new();
-}
diff --git a/src/bin/c07p02.rs b/src/bin/c07p02.rs
index aa8e7b6..03b41d9 100644
--- a/src/bin/c07p02.rs
+++ b/src/bin/c07p02.rs
@@ -11,6 +11,7 @@ enum State {
     Unavailable,
 }
 
+#[allow(dead_code)]
 #[derive(Debug, Clone)]
 struct Employee {
     name: String,
@@ -18,6 +19,7 @@ struct Employee {
     state: State,
 }
 
+#[allow(dead_code)]
 #[derive(Debug, Clone)]
 struct Call {
     from: String,
@@ -47,6 +49,28 @@ impl CallCentre {
     }
 }
 
+fn main() {
+    let call_centre = CallCentre {
+        employees: vec![
+            Employee {
+                name: "Bob".to_string(),
+                title: Title::Respondent,
+                state: State::Unavailable,
+            },
+            Employee {
+                name: "Jane".to_string(),
+                title: Title::Manager,
+                state: State::Available,
+            },
+        ],
+    };
+    let _employee = call_centre
+        .dispatch_call(Call {
+            from: "Obama".to_string(),
+        })
+        .unwrap();
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -75,25 +99,3 @@ mod tests {
         assert_eq!(employee.name, "Jane");
     }
 }
-
-fn main() {
-    let call_centre = CallCentre {
-        employees: vec![
-            Employee {
-                name: "Bob".to_string(),
-                title: Title::Respondent,
-                state: State::Unavailable,
-            },
-            Employee {
-                name: "Jane".to_string(),
-                title: Title::Manager,
-                state: State::Available,
-            },
-        ],
-    };
-    let _employee = call_centre
-        .dispatch_call(Call {
-            from: "Obama".to_string(),
-        })
-        .unwrap();
-}
diff --git a/src/bin/c07p03.rs b/src/bin/c07p03.rs
index 46a7c46..2007729 100644
--- a/src/bin/c07p03.rs
+++ b/src/bin/c07p03.rs
@@ -1,6 +1,7 @@
-use rand::seq::SliceRandom;
-use rand::thread_rng;
+use rand::rng;
+use rand::seq::IndexedMutRandom;
 
+#[allow(dead_code)]
 #[derive(Debug, Clone)]
 struct Song {
     title: String,
@@ -45,8 +46,8 @@ impl Jukebox {
     fn next_song(&mut self) -> Option<Song> {
         if self.queue.is_empty() {
             // pick random song
-            let mut rng = thread_rng();
-            self.catalogue.choose(&mut rng).cloned()
+            let mut rng = rng();
+            self.catalogue.choose_mut(&mut rng).cloned()
         } else {
             Some(self.queue.remove(0))
         }
@@ -57,6 +58,16 @@ impl Jukebox {
     }
 }
 
+fn main() {
+    let mut jukebox = Jukebox::new();
+
+    // Get a shuffled song
+    let _song = jukebox.next_song().unwrap();
+
+    // Add a song to the queue, and fetch it
+    jukebox.enqueue_song(jukebox.catalogue[1].clone());
+    let _next_song = jukebox.next_song().unwrap();
+}
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -67,7 +78,7 @@ mod tests {
 
         // Get a shuffled song
         let song = jukebox.next_song().unwrap();
-        assert_eq!(song.year.starts_with("20"), true);
+        assert!(song.year.starts_with("20"));
 
         // Add a song to the queue, and fetch it
         jukebox.enqueue_song(jukebox.catalogue[1].clone());
@@ -75,14 +86,3 @@ mod tests {
         assert_eq!(next_song.title, "Baby");
     }
 }
-
-fn main() {
-    let mut jukebox = Jukebox::new();
-
-    // Get a shuffled song
-    let _song = jukebox.next_song().unwrap();
-
-    // Add a song to the queue, and fetch it
-    jukebox.enqueue_song(jukebox.catalogue[1].clone());
-    let _next_song = jukebox.next_song().unwrap();
-}
diff --git a/src/bin/c07p04.rs b/src/bin/c07p04.rs
index d9fb37e..2bf02f2 100644
--- a/src/bin/c07p04.rs
+++ b/src/bin/c07p04.rs
@@ -53,6 +53,13 @@ impl ParkingLot {
     }
 }
 
+fn main() {
+    let mut parking_lot = ParkingLot::new(3, 6);
+    parking_lot.occupy_space("A1");
+    assert_eq!(parking_lot.parking_spaces[0].state, State::Occupied);
+    parking_lot.release_space("A1");
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -66,10 +73,3 @@ mod tests {
         assert_eq!(parking_lot.parking_spaces[0].state, State::Unoccupied);
     }
 }
-
-fn main() {
-    let mut parking_lot = ParkingLot::new(3, 6);
-    parking_lot.occupy_space("A1");
-    assert_eq!(parking_lot.parking_spaces[0].state, State::Occupied);
-    parking_lot.release_space("A1");
-}
diff --git a/src/bin/c07p05.rs b/src/bin/c07p05.rs
index b6b6f2a..c7913c8 100644
--- a/src/bin/c07p05.rs
+++ b/src/bin/c07p05.rs
@@ -6,6 +6,7 @@ struct User {
     password_hash: String,
 }
 
+#[allow(dead_code)]
 #[derive(Debug, Clone)]
 struct Book {
     title: String,
@@ -54,6 +55,14 @@ impl OnlineReader {
     }
 }
 
+fn main() {
+    let mut online_reader = OnlineReader::new();
+    let user = online_reader.add_user("Bob", "catscatscats");
+    let _book = online_reader
+        .add_book(&user, "Green Eggs and Ham", "Dr. Suess")
+        .unwrap();
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -75,11 +84,3 @@ mod tests {
         assert_eq!(online_reader.libraries.len(), 1);
     }
 }
-
-fn main() {
-    let mut online_reader = OnlineReader::new();
-    let user = online_reader.add_user("Bob", "catscatscats");
-    let _book = online_reader
-        .add_book(&user, "Green Eggs and Ham", "Dr. Suess")
-        .unwrap();
-}
diff --git a/src/bin/c07p06.rs b/src/bin/c07p06.rs
index d473785..f0581e3 100644
--- a/src/bin/c07p06.rs
+++ b/src/bin/c07p06.rs
@@ -1,8 +1,9 @@
-use rand::seq::SliceRandom;
-use rand::thread_rng;
 use std::cell::RefCell;
 use std::rc::Rc;
 
+use rand::rng;
+use rand::seq::SliceRandom;
+
 #[derive(PartialEq)]
 enum Side {
     Top,
@@ -66,7 +67,7 @@ impl Puzzle {
                 final_pieces.push(pieces[w][h].clone());
             }
         }
-        let mut rng = thread_rng();
+        let mut rng = rng();
         final_pieces.shuffle(&mut rng);
         Puzzle {
             pieces: final_pieces,
@@ -179,6 +180,11 @@ impl Piece {
     }
 }
 
+fn main() {
+    let mut puzzle = Puzzle::new(10, 5);
+    puzzle.solve();
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -196,8 +202,3 @@ mod tests {
         }
     }
 }
-
-fn main() {
-    let mut puzzle = Puzzle::new(10, 5);
-    puzzle.solve();
-}
diff --git a/src/bin/c07p07.rs b/src/bin/c07p07.rs
index 1ebb02a..d18c1c8 100644
--- a/src/bin/c07p07.rs
+++ b/src/bin/c07p07.rs
@@ -3,6 +3,7 @@ struct User {
     name: String,
 }
 
+#[allow(dead_code)]
 #[derive(Clone, Debug)]
 struct Client {
     user: User,
@@ -64,6 +65,16 @@ impl ChatServer {
     }
 }
 
+fn main() {
+    let mut chat_server = ChatServer::new();
+
+    chat_server.add_client(Client::new("Alice", "10.1.0.1"));
+    chat_server.add_client(Client::new("Bob", "10.1.0.2"));
+
+    chat_server.send(&Message::new("Alice", "Hello Bob"));
+    chat_server.send(&Message::new("Bob", "Hello Alice"));
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -79,13 +90,3 @@ mod tests {
         chat_server.send(&Message::new("Bob", "Hello Alice"));
     }
 }
-
-fn main() {
-    let mut chat_server = ChatServer::new();
-
-    chat_server.add_client(Client::new("Alice", "10.1.0.1"));
-    chat_server.add_client(Client::new("Bob", "10.1.0.2"));
-
-    chat_server.send(&Message::new("Alice", "Hello Bob"));
-    chat_server.send(&Message::new("Bob", "Hello Alice"));
-}
diff --git a/src/bin/c07p08.rs b/src/bin/c07p08.rs
index ced1c3d..bf02302 100644
--- a/src/bin/c07p08.rs
+++ b/src/bin/c07p08.rs
@@ -10,6 +10,7 @@ struct Board {
     squares: Vec<Vec<Piece>>,
 }
 
+#[allow(dead_code)]
 #[derive(Clone, Debug)]
 struct GameResult {
     winner: Piece,
@@ -114,6 +115,13 @@ impl Board {
     }
 }
 
+fn main() {
+    let mut board = Board::new();
+    board.start_game();
+    board.place_piece(Piece::White, 2, 4);
+    let _result = board.get_result();
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -135,10 +143,3 @@ mod tests {
         let _result = board.get_result();
     }
 }
-
-fn main() {
-    let mut board = Board::new();
-    board.start_game();
-    board.place_piece(Piece::White, 2, 4);
-    let _result = board.get_result();
-}
diff --git a/src/bin/c07p09.rs b/src/bin/c07p09.rs
index 9932916..37b1579 100644
--- a/src/bin/c07p09.rs
+++ b/src/bin/c07p09.rs
@@ -45,6 +45,12 @@ impl<'a, T> Iterator for Iter<'a, T> {
         }
     }
 }
+
+fn main() {
+    let mut arr = CircularArray::<char>::new(&['a', 'b', 'c']);
+    let _res1: Vec<char> = arr.iter().cloned().collect();
+    arr.rotate(1);
+}
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -59,9 +65,3 @@ mod tests {
         assert_eq!(res2, vec!['b', 'c', 'a']);
     }
 }
-
-fn main() {
-    let mut arr = CircularArray::<char>::new(&['a', 'b', 'c']);
-    let _res1: Vec<char> = arr.iter().cloned().collect();
-    arr.rotate(1);
-}
diff --git a/src/bin/c07p10.rs b/src/bin/c07p10.rs
index 8dbb8f7..56567de 100644
--- a/src/bin/c07p10.rs
+++ b/src/bin/c07p10.rs
@@ -1,5 +1,5 @@
+use rand::rng;
 use rand::seq::SliceRandom;
-use rand::thread_rng;
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 enum SquareState {
@@ -94,7 +94,7 @@ impl Board {
 
     fn place_mines(&mut self, count: usize) -> &mut Self {
         let mut mines: Vec<usize> = (0..(self.squares.len() * self.squares[0].len())).collect();
-        let mut rng = thread_rng();
+        let mut rng = rng();
         mines.shuffle(&mut rng);
         for location in mines.iter().take(count) {
             let x = location / self.squares.len();
@@ -170,6 +170,16 @@ impl std::fmt::Display for Board {
     }
 }
 
+fn main() {
+    let mut board = Board::new(10, 10);
+    board.place_mines(8);
+    println!("{}", board);
+    board.flag_square(0, 1);
+    println!("{}", board);
+    board.expose_square(3, 4);
+    println!("{}", board);
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -186,13 +196,3 @@ mod tests {
         println!("Game result -> {:?}", result);
     }
 }
-
-fn main() {
-    let mut board = Board::new(10, 10);
-    board.place_mines(8);
-    println!("{}", board);
-    board.flag_square(0, 1);
-    println!("{}", board);
-    board.expose_square(3, 4);
-    println!("{}", board);
-}
diff --git a/src/bin/c07p11.rs b/src/bin/c07p11.rs
index f358cf9..230c3c4 100644
--- a/src/bin/c07p11.rs
+++ b/src/bin/c07p11.rs
@@ -7,6 +7,7 @@ enum Type {
     Directory,
 }
 
+#[allow(dead_code)]
 #[derive(Debug, Clone)]
 struct INode {
     name: String,
@@ -34,6 +35,7 @@ impl INode {
         self.children.push(file.clone());
         file
     }
+
     fn add_directory(&mut self, name: &str) -> Rc<RefCell<INode>> {
         let dir = Rc::new(RefCell::new(INode {
             name: name.to_string(),
@@ -72,6 +74,12 @@ impl Filesystem {
     }
 }
 
+fn main() {
+    let mut fs = Filesystem::new();
+    let derp = fs.root.add_directory("derp");
+    let _file = derp.borrow_mut().add_file("herp", vec![0; 5]);
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -83,9 +91,3 @@ mod tests {
         let _file = derp.borrow_mut().add_file("herp", vec![0; 5]);
     }
 }
-
-fn main() {
-    let mut fs = Filesystem::new();
-    let derp = fs.root.add_directory("derp");
-    let _file = derp.borrow_mut().add_file("herp", vec![0; 5]);
-}
diff --git a/src/bin/c07p12.rs b/src/bin/c07p12.rs
index 6d8dccd..57c85fd 100644
--- a/src/bin/c07p12.rs
+++ b/src/bin/c07p12.rs
@@ -57,6 +57,13 @@ where
     }
 }
 
+fn main() {
+    let mut table = HashTable::<String, String>::new(10);
+    table.put("dog".to_string(), "Doge".to_string());
+    table.get("dog".to_string());
+    table.delete("dog".to_string());
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -70,10 +77,3 @@ mod tests {
         assert_eq!(table.get("dog".to_string()), None);
     }
 }
-
-fn main() {
-    let mut table = HashTable::<String, String>::new(10);
-    table.put("dog".to_string(), "Doge".to_string());
-    table.get("dog".to_string());
-    table.delete("dog".to_string());
-}
diff --git a/src/bin/c08p01.rs b/src/bin/c08p01.rs
index f7dbd87..a16e552 100644
--- a/src/bin/c08p01.rs
+++ b/src/bin/c08p01.rs
@@ -10,6 +10,10 @@ fn triple_step(steps: i32) -> i32 {
     }
 }
 
+fn main() {
+    triple_step(1);
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -23,7 +27,3 @@ mod tests {
         assert_eq!(triple_step(5), 13);
     }
 }
-
-fn main() {
-    triple_step(1);
-}
diff --git a/src/bin/c08p02.rs b/src/bin/c08p02.rs
index 53d2b36..23e7cba 100644
--- a/src/bin/c08p02.rs
+++ b/src/bin/c08p02.rs
@@ -49,18 +49,23 @@ fn get_path_to(
     vec![]
 }
 
+fn main() {
+    get_path_to(Location { x: 0, y: 0 }, Location { x: 100, y: 100 }, &[]);
+}
+
 #[cfg(test)]
 mod tests {
-    use super::*;
     use rand::Rng;
 
+    use super::*;
+
     #[test]
     fn test_robot_in_a_grid() {
         let mut off_limits: Vec<Location> = vec![];
-        let mut rng = rand::thread_rng();
+        let mut rng = rand::rng();
         for _ in 0..100 {
-            let x = rng.gen_range(1..100);
-            let y = rng.gen_range(1..100);
+            let x = rng.random_range(1..100);
+            let y = rng.random_range(1..100);
             off_limits.push(Location { x, y });
         }
         let path = get_path_to(
@@ -71,7 +76,3 @@ mod tests {
         assert_eq!(path.last().unwrap(), &Location { x: 100, y: 100 });
     }
 }
-
-fn main() {
-    get_path_to(Location { x: 0, y: 0 }, Location { x: 100, y: 100 }, &[]);
-}
diff --git a/src/bin/c08p03.rs b/src/bin/c08p03.rs
index d618ac8..0260d41 100644
--- a/src/bin/c08p03.rs
+++ b/src/bin/c08p03.rs
@@ -14,6 +14,10 @@ fn find_magic_index(arr: &[i64]) -> Option<usize> {
     }
 }
 
+fn main() {
+    find_magic_index(&[0, 2, 3, 5]);
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -24,7 +28,3 @@ mod tests {
         assert_eq!(find_magic_index(&[-10, 2, 3, 5]), None);
     }
 }
-
-fn main() {
-    find_magic_index(&[0, 2, 3, 5]);
-}
diff --git a/src/bin/c08p04.rs b/src/bin/c08p04.rs
index 62d3f7e..f5f73e2 100644
--- a/src/bin/c08p04.rs
+++ b/src/bin/c08p04.rs
@@ -17,28 +17,25 @@ fn power_set(arr: &[i64]) -> Vec<Vec<i64>> {
     }
 }
 
+fn main() {
+    power_set(&[0, 1, 2]);
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
 
     #[test]
     fn test_power_set() {
-        assert_eq!(
-            power_set(&[0, 1, 2]),
-            vec![
-                vec![],
-                vec![2],
-                vec![1],
-                vec![1, 2],
-                vec![0],
-                vec![0, 2],
-                vec![0, 1],
-                vec![0, 1, 2],
-            ]
-        );
+        assert_eq!(power_set(&[0, 1, 2]), vec![
+            vec![],
+            vec![2],
+            vec![1],
+            vec![1, 2],
+            vec![0],
+            vec![0, 2],
+            vec![0, 1],
+            vec![0, 1, 2],
+        ]);
     }
 }
-
-fn main() {
-    power_set(&[0, 1, 2]);
-}
diff --git a/src/bin/c08p05.rs b/src/bin/c08p05.rs
index 0e9410a..7ac7623 100644
--- a/src/bin/c08p05.rs
+++ b/src/bin/c08p05.rs
@@ -10,6 +10,10 @@ fn recursive_multiply(a: i64, b: i64) -> i64 {
     }
 }
 
+fn main() {
+    recursive_multiply(2, 0);
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -33,7 +37,3 @@ mod tests {
         assert_eq!(recursive_multiply(0, 1), 0);
     }
 }
-
-fn main() {
-    recursive_multiply(2, 0);
-}
diff --git a/src/bin/c08p06.rs b/src/bin/c08p06.rs
index 9b054c4..6f3e026 100644
--- a/src/bin/c08p06.rs
+++ b/src/bin/c08p06.rs
@@ -6,6 +6,13 @@ fn move_to_target(n: usize, source: &mut Vec<i32>, target: &mut Vec<i32>, aux: &
     }
 }
 
+fn main() {
+    let mut source = vec![5, 4, 3, 2, 1];
+    let mut target: Vec<i32> = vec![];
+    let mut aux: Vec<i32> = vec![];
+    move_to_target(source.len(), &mut source, &mut target, &mut aux);
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -21,10 +28,3 @@ mod tests {
         assert_eq!(aux, vec![]);
     }
 }
-
-fn main() {
-    let mut source = vec![5, 4, 3, 2, 1];
-    let mut target: Vec<i32> = vec![];
-    let mut aux: Vec<i32> = vec![];
-    move_to_target(source.len(), &mut source, &mut target, &mut aux);
-}
diff --git a/src/bin/c08p07.rs b/src/bin/c08p07.rs
index a8a43c4..57e3d58 100644
--- a/src/bin/c08p07.rs
+++ b/src/bin/c08p07.rs
@@ -26,6 +26,11 @@ fn permutations_without_dups(s: &str) -> Vec<String> {
     }
 }
 
+fn main() {
+    let s1 = "abc";
+    permutations_without_dups(s1);
+}
+
 #[cfg(test)]
 mod tests {
     use std::collections::HashSet;
@@ -50,8 +55,3 @@ mod tests {
         assert_eq!(s2_perms.len(), s2_set.len());
     }
 }
-
-fn main() {
-    let s1 = "abc";
-    permutations_without_dups(s1);
-}
diff --git a/src/bin/c08p08.rs b/src/bin/c08p08.rs
index 86ac874..781f85c 100644
--- a/src/bin/c08p08.rs
+++ b/src/bin/c08p08.rs
@@ -26,6 +26,11 @@ fn permutations_with_dups(s: &str) -> Vec<String> {
     }
 }
 
+fn main() {
+    let s1 = "abc";
+    permutations_with_dups(s1);
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -37,8 +42,3 @@ mod tests {
         assert_eq!(permutations_with_dups(s1), permutations);
     }
 }
-
-fn main() {
-    let s1 = "abc";
-    permutations_with_dups(s1);
-}
diff --git a/src/bin/c08p09.rs b/src/bin/c08p09.rs
index 1fb1055..a9ff33a 100644
--- a/src/bin/c08p09.rs
+++ b/src/bin/c08p09.rs
@@ -24,28 +24,25 @@ fn get_parens(n: u32) -> Vec<String> {
     }
 }
 
+fn main() {
+    get_parens(3);
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
 
     #[test]
     fn test_parens() {
-        assert_eq!(get_parens(0).is_empty(), true);
+        assert!(get_parens(0).is_empty());
         assert_eq!(get_parens(1), vec!["()".to_string()]);
         assert_eq!(get_parens(2), vec!["()()".to_string(), "(())".to_string(),]);
-        assert_eq!(
-            get_parens(3),
-            vec![
-                "()()()".to_string(),
-                "(()())".to_string(),
-                "()(())".to_string(),
-                "(())()".to_string(),
-                "((()))".to_string(),
-            ]
-        );
+        assert_eq!(get_parens(3), vec![
+            "()()()".to_string(),
+            "(()())".to_string(),
+            "()(())".to_string(),
+            "(())()".to_string(),
+            "((()))".to_string(),
+        ]);
     }
 }
-
-fn main() {
-    get_parens(3);
-}
diff --git a/src/bin/c08p10.rs b/src/bin/c08p10.rs
index a5a73db..f0255fb 100644
--- a/src/bin/c08p10.rs
+++ b/src/bin/c08p10.rs
@@ -16,6 +16,17 @@ fn paint_fill(x: usize, y: usize, canvas: &mut Vec<Vec<i32>>, new_colour: i32) {
     }
 }
 
+fn main() {
+    let mut canvas = vec![
+        vec![0, 0, 1, 0, 0],
+        vec![0, 0, 1, 0, 0],
+        vec![1, 1, 1, 0, 0],
+        vec![0, 0, 0, 0, 0],
+        vec![0, 0, 0, 0, 0],
+    ];
+    paint_fill(0, 0, &mut canvas, 2);
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -30,26 +41,12 @@ mod tests {
             vec![0, 0, 0, 0, 0],
         ];
         paint_fill(0, 0, &mut canvas, 2);
-        assert_eq!(
-            canvas,
-            vec![
-                vec![2, 2, 1, 0, 0],
-                vec![2, 2, 1, 0, 0],
-                vec![1, 1, 1, 0, 0],
-                vec![0, 0, 0, 0, 0],
-                vec![0, 0, 0, 0, 0],
-            ]
-        );
+        assert_eq!(canvas, vec![
+            vec![2, 2, 1, 0, 0],
+            vec![2, 2, 1, 0, 0],
+            vec![1, 1, 1, 0, 0],
+            vec![0, 0, 0, 0, 0],
+            vec![0, 0, 0, 0, 0],
+        ]);
     }
 }
-
-fn main() {
-    let mut canvas = vec![
-        vec![0, 0, 1, 0, 0],
-        vec![0, 0, 1, 0, 0],
-        vec![1, 1, 1, 0, 0],
-        vec![0, 0, 0, 0, 0],
-        vec![0, 0, 0, 0, 0],
-    ];
-    paint_fill(0, 0, &mut canvas, 2);
-}
diff --git a/src/bin/c08p11.rs b/src/bin/c08p11.rs
index 6cdf29b..74193e5 100644
--- a/src/bin/c08p11.rs
+++ b/src/bin/c08p11.rs
@@ -13,6 +13,11 @@ fn make_change(amount: i64, denoms: &[i64], index: usize) -> i64 {
     }
 }
 
+fn main() {
+    let denoms: Vec<i64> = vec![25, 10, 5, 1];
+    make_change(10, &denoms, 0);
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -25,8 +30,3 @@ mod tests {
         assert_eq!(make_change(15, &denoms, 0), 6);
     }
 }
-
-fn main() {
-    let denoms: Vec<i64> = vec![25, 10, 5, 1];
-    make_change(10, &denoms, 0);
-}
diff --git a/src/bin/c08p12.rs b/src/bin/c08p12.rs
index 5a78604..983ade2 100644
--- a/src/bin/c08p12.rs
+++ b/src/bin/c08p12.rs
@@ -1,6 +1,6 @@
 static GRID_SIZE: usize = 8;
 
-fn check_valid(columns: &mut Vec<usize>, row1: usize, column1: usize) -> bool {
+fn check_valid(columns: &mut [usize], row1: usize, column1: usize) -> bool {
     for (row2, column2) in columns.iter().take(row1).enumerate() {
         if column1 == *column2 {
             return false;
@@ -29,6 +29,12 @@ fn place_queens(row: usize, columns: &mut Vec<usize>, results: &mut Vec<Vec<usiz
     }
 }
 
+fn main() {
+    let mut results: Vec<Vec<usize>> = vec![];
+    let mut columns: Vec<usize> = vec![0; 8];
+    place_queens(0, &mut columns, &mut results);
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -41,9 +47,3 @@ mod tests {
         assert_eq!(results.len(), 92);
     }
 }
-
-fn main() {
-    let mut results: Vec<Vec<usize>> = vec![];
-    let mut columns: Vec<usize> = vec![0; 8];
-    place_queens(0, &mut columns, &mut results);
-}
diff --git a/src/bin/c08p13.rs b/src/bin/c08p13.rs
index a31834d..b39f431 100644
--- a/src/bin/c08p13.rs
+++ b/src/bin/c08p13.rs
@@ -35,6 +35,27 @@ fn get_max_stack_height(stack: &[BremBox], remaining_boxes: &[BremBox]) -> usize
     }
 }
 
+fn main() {
+    let stack = vec![
+        BremBox {
+            height: 1,
+            width: 1,
+            depth: 1,
+        },
+        BremBox {
+            height: 2,
+            width: 2,
+            depth: 2,
+        },
+        BremBox {
+            height: 3,
+            width: 3,
+            depth: 3,
+        },
+    ];
+    get_max_stack_height(&[], &stack);
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -62,24 +83,3 @@ mod tests {
         assert_eq!(result, 6);
     }
 }
-
-fn main() {
-    let stack = vec![
-        BremBox {
-            height: 1,
-            width: 1,
-            depth: 1,
-        },
-        BremBox {
-            height: 2,
-            width: 2,
-            depth: 2,
-        },
-        BremBox {
-            height: 3,
-            width: 3,
-            depth: 3,
-        },
-    ];
-    get_max_stack_height(&[], &stack);
-}
diff --git a/src/bin/c08p14.rs b/src/bin/c08p14.rs
index 722134a..7f2fe25 100644
--- a/src/bin/c08p14.rs
+++ b/src/bin/c08p14.rs
@@ -2,11 +2,7 @@ fn count_eval(s: &str, result: bool) -> u64 {
     if s.is_empty() {
         0
     } else if s.len() == 1 {
-        if (s == "1") == result {
-            1
-        } else {
-            0
-        }
+        if (s == "1") == result { 1 } else { 0 }
     } else {
         let mut ways: u64 = 0;
         for (i, c) in s.char_indices().skip(1).step_by(2) {
@@ -40,6 +36,10 @@ fn count_eval(s: &str, result: bool) -> u64 {
     }
 }
 
+fn main() {
+    count_eval("1^0|0|1", false);
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -50,7 +50,3 @@ mod tests {
         assert_eq!(count_eval("0&0&0&1^1|0", true), 10);
     }
 }
-
-fn main() {
-    count_eval("1^0|0|1", false);
-}