Fix an empty split bug

Fixes a bug in the tutorial that happened when `split_before` and
`split_after` resulted in an empty split. This was fixed by checking
for an empty split and updating the `front` and `back` pointers
accordingly.

This change-set fixes both the final code and the tutorial text.

Author: irbull

.github/workflows/main.yml

@@ -3,8 +3,8 @@ name: Rust
 on:
   push:
     branches:
-      - "master"
-      - "!gh-pages"
+      - 'master'
+      - '!gh-pages'
   pull_request:
 
 jobs:

lists/src/sixth.rs

@@ -535,8 +535,13 @@ impl<'a, T> CursorMut<'a, T> {
 
                 // What the output will become
                 let output_len = old_len - new_len;
-                let output_front = self.list.front;
-                let output_back = prev;
+                let mut output_front = self.list.front;
+                let mut output_back = prev;
+
+                if output_len == 0 {
+                    output_front = None;
+                    output_back = None;
+                }
 
                 // Break the links between cur and prev
                 if let Some(prev) = prev {
@@ -597,8 +602,13 @@ impl<'a, T> CursorMut<'a, T> {
 
                 // What the output will become
                 let output_len = old_len - new_len;
-                let output_front = next;
-                let output_back = self.list.back;
+                let mut output_front = next;
+                let mut output_back = self.list.back;
+
+                if output_len == 0 {
+                    output_front = None;
+                    output_back = None;
+                }
 
                 // Break the links between cur and next
                 if let Some(next) = next {
@@ -1190,6 +1200,33 @@ mod test {
         );
     }
 
+    #[test]
+    fn test_empty_slice() {
+        let mut list = LinkedList::new();
+        list.push_back(7);
+        list.push_back(8);
+        list.push_back(9);
+
+        let mut cur = list.cursor_mut();
+        cur.move_next(); // Point at the first node
+        let result = cur.split_before(); // Everything before the first node
+
+        assert_eq!(result.len, 0);
+        assert_eq!(result.front(), None);
+        assert_eq!(result.back(), None);
+
+        assert_eq!(list.len, 3);
+        assert_eq!(list.front(), Some(7).as_ref());
+
+        let mut cur = list.cursor_mut();
+        cur.move_prev(); // Point at the last node
+        let result = cur.split_after(); // Everything after the last node
+
+        assert_eq!(result.len, 0);
+        assert_eq!(result.front(), None);
+        assert_eq!(result.back(), None);
+    }
+
     fn check_links<T: Eq + std::fmt::Debug>(list: &LinkedList<T>) {
         let from_front: Vec<_> = list.iter().collect();
         let from_back: Vec<_> = list.iter().rev().collect();

src/sixth-cursors-testing.md

@@ -377,6 +377,46 @@ DONE.
 
 Done.
 
+> **Community Contribution:** After completing the exercises a small bug was discovered when creating an empty slice from the list.
+
+```rust ,ignore
+    #[test]
+    fn test_empty_slice() {
+        let mut list = LinkedList::new();
+        list.push_back(7);
+        list.push_back(8);
+        list.push_back(9);
+
+        let mut cur = list.cursor_mut();
+        cur.move_next(); // Point at the first node
+        let result = cur.split_before(); // Everything before the first node
+
+        assert_eq!(result.len, 0);
+        assert_eq!(result.front(), None);
+        assert_eq!(result.back(), None);
+
+        assert_eq!(list.len, 3);
+        assert_eq!(list.front(), Some(7).as_ref());
+
+        let mut cur = list.cursor_mut();
+        cur.move_prev(); // Point at the last node
+        let result = cur.split_after(); // Everything after the last node
+
+        assert_eq!(result.len, 0);
+        assert_eq!(result.front(), None);
+        assert_eq!(result.back(), None);
+    }
+```
+
+In this case, we attempt to create a slice from all the elements before the first node (which should be empty). This is because the `split_before` method does not set the front and back pointers to None when the list is empty. This can be fixed by adding the following line to the `split_before` method:
+
+```rust ,ignore
+        if self.len == 0 {
+            self.front = None;
+            self.back = None;
+        }
+```
+
 We did it. We made a god damn production-quality LinkedList, with basically all the same functionality as the one in std. Are we missing little convenience methods here and there? Absolutely. Will I add them into the final published version of the crate? Probably!
 
 But, I am, So Very Tired.

src/sixth-final.md

@@ -546,8 +546,13 @@ impl<'a, T> CursorMut<'a, T> {
 
                 // What the output will become
                 let output_len = old_len - new_len;
-                let output_front = self.list.front;
-                let output_back = prev;
+                let mut output_front = self.list.front;
+                let mut output_back = prev;
+
+                if output_len == 0 {
+                    output_front = None;
+                    output_back = None;
+                }
 
                 // Break the links between cur and prev
                 if let Some(prev) = prev {
@@ -608,8 +613,13 @@ impl<'a, T> CursorMut<'a, T> {
 
                 // What the output will become
                 let output_len = old_len - new_len;
-                let output_front = next;
-                let output_back = self.list.back;
+                let mut output_front = next;
+                let mut output_back = self.list.back;
+
+                if output_len == 0 {
+                    output_front = None;
+                    output_back = None;
+                }
 
                 // Break the links between cur and next
                 if let Some(next) = next {
@@ -1201,6 +1211,33 @@ mod test {
         );
     }
 
+    #[test]
+    fn test_empty_slice() {
+        let mut list = LinkedList::new();
+        list.push_back(7);
+        list.push_back(8);
+        list.push_back(9);
+
+        let mut cur = list.cursor_mut();
+        cur.move_next(); // Point at the first node
+        let result = cur.split_before(); // Everything before the first node
+
+        assert_eq!(result.len, 0);
+        assert_eq!(result.front(), None);
+        assert_eq!(result.back(), None);
+
+        assert_eq!(list.len, 3);
+        assert_eq!(list.front(), Some(7).as_ref());
+
+        let mut cur = list.cursor_mut();
+        cur.move_prev(); // Point at the last node
+        let result = cur.split_after(); // Everything after the last node
+
+        assert_eq!(result.len, 0);
+        assert_eq!(result.front(), None);
+        assert_eq!(result.back(), None);
+    }
+
     fn check_links<T: Eq + std::fmt::Debug>(list: &LinkedList<T>) {
         let from_front: Vec<_> = list.iter().collect();
         let from_back: Vec<_> = list.iter().rev().collect();
@@ -1209,4 +1246,4 @@ mod test {
         assert_eq!(from_front, re_reved);
     }
 }
-```
+```