test: update compiler errors

Author: tusharmath

src/chunk.rs

@@ -238,7 +238,7 @@ impl<A> Chunk<A> {
     /// # Arguments
     /// * `buf` - A mutable reference to a vector that will be populated with
     ///           references to the chunk's elements
-    pub fn as_vec_mut<'a>(&'a self, buf: &mut Vec<A>)
+    pub fn as_vec_mut(&self, buf: &mut Vec<A>)
     where
         A: Clone,
     {
@@ -292,13 +292,13 @@ mod tests {
     #[test]
     fn test_prepend() {
         let chunk = Chunk::new().prepend(1).prepend(2).prepend(3);
-        assert_eq!(chunk.as_vec(), vec![&3, &2, &1]);
+        assert_eq!(chunk.as_vec(), vec![3, 2, 1]);
 
         // Test that original chunk remains unchanged (persistence)
         let chunk1 = Chunk::new().prepend(1);
         let chunk2 = chunk1.clone().prepend(2);
-        assert_eq!(chunk1.as_vec(), vec![&1]);
-        assert_eq!(chunk2.as_vec(), vec![&2, &1]);
+        assert_eq!(chunk1.as_vec(), vec![1]);
+        assert_eq!(chunk2.as_vec(), vec![2, 1]);
     }
 
     #[test]
@@ -307,7 +307,7 @@ mod tests {
         let chunk2 = Chunk::new().prepend(3).prepend(4);
         let combined = chunk1.clone().concat(chunk2.clone());
 
-        assert_eq!(combined.as_vec(), vec![&2, &1, &4, &3]);
+        assert_eq!(combined.as_vec(), vec![2, 1, 4, 3]);
 
         // Test concatenation with empty chunks
         let empty = Chunk::new();
@@ -319,28 +319,28 @@ mod tests {
             chunk1.clone().concat(empty.clone()).as_vec(),
             chunk1.as_vec()
         );
-        assert_eq!(empty.clone().concat(empty).as_vec(), Vec::<&i32>::new());
+        assert_eq!(empty.clone().concat(empty).as_vec(), Vec::<i32>::new());
     }
 
     #[test]
     fn test_as_vec() {
         // Test empty chunk
         let empty: Chunk<i32> = Chunk::new();
-        assert_eq!(empty.as_vec(), Vec::<&i32>::new());
+        assert_eq!(empty.as_vec(), Vec::<i32>::new());
 
         // Test single element
         let single = Chunk::new().prepend(42);
-        assert_eq!(single.as_vec(), vec![&42]);
+        assert_eq!(single.as_vec(), vec![42]);
 
         // Test multiple elements
         let multiple = Chunk::new().prepend(1).prepend(2).prepend(3);
-        assert_eq!(multiple.as_vec(), vec![&3, &2, &1]);
+        assert_eq!(multiple.as_vec(), vec![3, 2, 1]);
 
         // Test complex structure with concatenation
         let chunk1 = Chunk::new().prepend(1).prepend(2);
         let chunk2 = Chunk::new().prepend(3).prepend(4);
         let complex = chunk1.concat(chunk2);
-        assert_eq!(complex.as_vec(), vec![&2, &1, &4, &3]);
+        assert_eq!(complex.as_vec(), vec![2, 1, 4, 3]);
     }
 
     #[test]
@@ -350,9 +350,9 @@ mod tests {
         let chunk3 = chunk1.clone().prepend(4);
 
         // Verify that modifications create new structures while preserving the original
-        assert_eq!(chunk1.as_vec(), vec![&1, &2]);
-        assert_eq!(chunk2.as_vec(), vec![&1, &2, &3]);
-        assert_eq!(chunk3.as_vec(), vec![&1, &2, &4]);
+        assert_eq!(chunk1.as_vec(), vec![1, 2]);
+        assert_eq!(chunk2.as_vec(), vec![1, 2, 3]);
+        assert_eq!(chunk3.as_vec(), vec![1, 2, 4]);
     }
 
     #[test]
@@ -365,11 +365,11 @@ mod tests {
 
         // Test with floating point numbers
         let float_chunk = Chunk::new().prepend(3.14).prepend(2.718);
-        assert_eq!(float_chunk.as_vec(), vec![&3.14, &2.718]);
+        assert_eq!(float_chunk.as_vec(), vec![3.14, 2.718]);
 
         // Test with boolean values
         let bool_chunk = Chunk::new().prepend(true).prepend(false).prepend(true);
-        assert_eq!(bool_chunk.as_vec(), vec![&true, &false, &true]);
+        assert_eq!(bool_chunk.as_vec(), vec![true, false, true]);
     }
 
     #[test]
@@ -378,22 +378,22 @@ mod tests {
         let chunk = Chunk::new().prepend(1).prepend(2);
         let mapped = Chunk::FlatMap(
             Rc::new(chunk),
-            Rc::new(|x| Chunk::new().prepend(*x * 2).prepend(*x)),
+            Rc::new(|x| Chunk::new().prepend(x * 2).prepend(x)),
         );
-        assert_eq!(mapped.as_vec(), vec![&2, &4, &2, &1]);
+        assert_eq!(mapped.as_vec(), vec![2, 1, 4, 2]);
 
         // Test flat_map with empty chunk
         let empty: Chunk<i32> = Chunk::new();
-        let mapped_empty = Chunk::FlatMap(Rc::new(empty), Rc::new(|x| Chunk::new().prepend(*x)));
+        let mapped_empty = Chunk::FlatMap(Rc::new(empty), Rc::new(|x| Chunk::new().prepend(x)));
         assert_eq!(mapped_empty.as_vec(), Vec::<i32>::new());
 
         // Test nested flat_map
         let chunk = Chunk::new().prepend(1).prepend(2);
-        let first_map = Chunk::FlatMap(Rc::new(chunk), Rc::new(|x| Chunk::new().prepend(*x * 2)));
+        let first_map = Chunk::FlatMap(Rc::new(chunk), Rc::new(|x| Chunk::new().prepend(x * 2)));
         let nested_map = Chunk::FlatMap(
             Rc::new(first_map),
-            Rc::new(|x| Chunk::new().prepend(*x + 1)),
+            Rc::new(|x| Chunk::new().prepend(x + 1)),
         );
-        assert_eq!(nested_map.as_vec(), vec![&3, &5]);
+        assert_eq!(nested_map.as_vec(), vec![3, 5]);
     }
 }