optimize clear method and impl Array up to 64 items

Author: daddinuz

Cargo.lock

@@ -2,7 +2,7 @@
 authors = ["Davide Di Carlo <daddinuz@gmail.com>"]
 description = "A dynamic container that combines the characteristics of a Vec and a LinkedList"
 name = "array_list"
-version = "0.1.0"
+version = "0.2.0"
 edition = "2021"
 license = "MIT"
 keywords = ["collections", "vec", "xor", "linked-list", "unrolled"]

Cargo.toml

@@ -11,13 +11,12 @@ or iterations are required.
 
 - **Dynamic:** Combines the benefits of a `Vec` (compact, cache-friendly storage) and a `LinkedList` (efficient insertions and deletions).
 - **Reduced pointer overhead:** Implements a **XOR linked list**, requiring only a single pointer per node for bidirectional traversal.
-- **Customizable chunk size:** The size of each chunk is determined at compile time via a const generic parameter up to 32 elements.
+- **Customizable chunk size:** The size of each chunk is determined at compile time via a const generic parameter up to 64 elements.
 - **Efficient memory operations:** Splits and merges nodes dynamically, redistributing elements when necessary.
 - **Rich API:** Provides functionality for:
-  - Insertions and deletions at arbitrary positions.
-  - Access to front and back elements.
-  - Iterators for traversal.
+  - Insertions, deletions and access at arbitrary positions.
   - Index-based access with `get` methods.
+  - Access to front and back elements.
 
 ## Strengths
 
@@ -43,7 +42,7 @@ or edit your Cargo.toml manually by adding:
 
 ```toml
 [dependencies]
-array_list = "0.1"
+array_list = "0.2"
 ```
 
 ## Example Usage

README.md

@@ -683,10 +683,25 @@ where
     /// assert_eq!(list.back(), None);
     /// ```
     pub fn clear(&mut self) {
-        // TODO: optimize dropping nodes instead of items one at time
-        while !self.is_empty() {
-            self.pop_back();
+        let mut right: Option<NonNull<Node<T, N>>> = None;
+        let mut cursor = self.tail;
+
+        while let Some(mut node) = cursor {
+            let tmp = cursor;
+
+            cursor = NonNull::new(
+                (unsafe { node.as_ref().link() } ^ right.map_or(0, |p| p.as_ptr() as usize))
+                    as *mut Node<T, N>,
+            );
+
+            right = tmp;
+
+            drop(unsafe { Box::from_raw(node.as_mut()) })
         }
+
+        self.tail = None;
+        self.head = None;
+        self.len = 0;
     }
 
     /// Returns a reference to the first element of the `ArrayList`, if any.

src/lib.rs

@@ -183,10 +183,12 @@ where
     [T; N]: Array<T, N>,
 {
     fn drop(&mut self) {
-        while !self.is_empty() {
-            self.len -= 1;
-            unsafe { self.data[self.len].assume_init_drop() };
+        for i in (0..self.len).rev() {
+            unsafe { self.data[i].assume_init_drop() };
         }
+
+        self.link = 0;
+        self.len = 0;
     }
 }
 

src/node.rs

@@ -38,3 +38,35 @@ impl<T> Array<T, 29> for [T; 29] {}
 impl<T> Array<T, 30> for [T; 30] {}
 impl<T> Array<T, 31> for [T; 31] {}
 impl<T> Array<T, 32> for [T; 32] {}
+impl<T> Array<T, 33> for [T; 33] {}
+impl<T> Array<T, 34> for [T; 34] {}
+impl<T> Array<T, 35> for [T; 35] {}
+impl<T> Array<T, 36> for [T; 36] {}
+impl<T> Array<T, 37> for [T; 37] {}
+impl<T> Array<T, 38> for [T; 38] {}
+impl<T> Array<T, 39> for [T; 39] {}
+impl<T> Array<T, 40> for [T; 40] {}
+impl<T> Array<T, 41> for [T; 41] {}
+impl<T> Array<T, 42> for [T; 42] {}
+impl<T> Array<T, 43> for [T; 43] {}
+impl<T> Array<T, 44> for [T; 44] {}
+impl<T> Array<T, 45> for [T; 45] {}
+impl<T> Array<T, 46> for [T; 46] {}
+impl<T> Array<T, 47> for [T; 47] {}
+impl<T> Array<T, 48> for [T; 48] {}
+impl<T> Array<T, 49> for [T; 49] {}
+impl<T> Array<T, 50> for [T; 50] {}
+impl<T> Array<T, 51> for [T; 51] {}
+impl<T> Array<T, 52> for [T; 52] {}
+impl<T> Array<T, 53> for [T; 53] {}
+impl<T> Array<T, 54> for [T; 54] {}
+impl<T> Array<T, 55> for [T; 55] {}
+impl<T> Array<T, 56> for [T; 56] {}
+impl<T> Array<T, 57> for [T; 57] {}
+impl<T> Array<T, 58> for [T; 58] {}
+impl<T> Array<T, 59> for [T; 59] {}
+impl<T> Array<T, 60> for [T; 60] {}
+impl<T> Array<T, 61> for [T; 61] {}
+impl<T> Array<T, 62> for [T; 62] {}
+impl<T> Array<T, 63> for [T; 63] {}
+impl<T> Array<T, 64> for [T; 64] {}