dbg lines are cleaned

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "orx-linked-list"
-version = "3.9.0"
+version = "3.9.1"
 edition = "2024"
 authors = ["orxfun <[email protected]>"]
 description = "A linked list implementation with unique features and an extended list of constant time methods providing high performance traversals and mutations."

examples/bench_parallelization.rs

@@ -74,7 +74,7 @@ fn main() {
             Box::new(move || {
                 let list: DoublyList<_> = (0..args.len as usize).collect();
 
-                list.par_x() // replace iter_ (into_iter_x) with par_x (into_par_x) to parallelize !
+                list.par_x() // replace iter_x (into_iter_x) with par_x (into_par_x) to parallelize !
                     .filter(|x| *x % 3 != 0)
                     .map(|x| x + fibonacci(x % 1000))
                     .filter(|x| x % 2 == 0)

src/list/consuming.rs

@@ -50,7 +50,7 @@ where
     /// In brief, computation is defined as chain of iterator transformations and parallelization
     /// is handled by the underlying parallel executor.
     ///
-    /// Required **orx-parallel** feature.
+    /// Requires **orx-parallel** feature.
     ///
     /// [`ParIter`]: orx_parallel::ParIter
     /// [`into_iter_x`]: crate::List::into_iter_x
@@ -75,7 +75,6 @@ where
     ///
     /// let expected: usize = new_list().into_iter_x().filter(|x| x % 2 == 0).sum();
     /// let sum_evens = new_list().into_par_x().filter(|x| x % 2 == 0).sum();
-    /// std::dbg!(sum_evens, expected);
     /// ```
     #[cfg(feature = "orx-parallel")]
     pub fn into_par_x(self) -> impl orx_parallel::ParIter<Item = V::Item>

src/list/ends_traits/doubly_ends_mut.rs

@@ -393,7 +393,6 @@ where
     /// let e = list.push_back('e');
     ///
     /// assert!(list.eq_to_iter_vals(['a', 'b', 'c', 'd', 'e']));
-    /// dbg!(list.front());
     ///
     /// list.reverse();
     /// assert!(list.eq_to_iter_vals(['e', 'd', 'c', 'b', 'a']));

src/list/get.rs

@@ -113,7 +113,7 @@ where
     /// In brief, computation is defined as chain of iterator transformations and parallelization
     /// is handled by the underlying parallel executor.
     ///
-    /// Required **orx-parallel** feature.
+    /// Requires **orx-parallel** feature.
     ///
     /// [`ParIter`]: orx_parallel::ParIter
     /// [`iter_x`]: crate::List::iter_x
@@ -138,7 +138,6 @@ where
     ///
     /// let expected: usize = list.iter_x().filter(|x| *x % 2 == 0).sum();
     /// let sum_evens = list.par_x().filter(|x| *x % 2 == 0).sum();
-    /// std::dbg!(sum_evens, expected);
     /// ```
     #[cfg(feature = "orx-parallel")]
     pub fn par_x(&self) -> impl orx_parallel::ParIter<Item = &V::Item>

tests/list_move_next_to.rs

@@ -32,8 +32,6 @@ fn list_move_next_to_back() {
         let mut vec: Vec<_> = (0..n).into_iter().filter(|x| x != &i).collect();
         vec.insert(n - 1, i);
 
-        dbg!(i, &vec, list.iter().collect::<Vec<_>>());
-
         #[cfg(feature = "validation")]
         list.validate();
         assert!(list.eq_to_iter_refs(&vec));

tests/reverse.rs

@@ -84,7 +84,6 @@ fn slice_reverse_until_back() {
 #[test]
 fn slice_reverse_middle() {
     for i in 0..20 {
-        dbg!(i);
         let mut list = doubly::new_doubly(&mut &mut doubly::rng_with_seed(100 * i as u64), 20, 50);
         let mut expected: Vec<_> = list.iter().cloned().collect();
         let idx: Vec<_> = list.indices().collect();

tests/ring_iter_mut.rs

@@ -11,7 +11,6 @@ fn ring_iter_mut_on_list() {
     let values: Vec<_> = list.iter().cloned().collect();
 
     for i in 0..n {
-        dbg!(i, n);
         let cyclic: Vec<_> = list.ring_iter_mut(&idx[i]).map(|x| x.clone()).collect();
         assert_eq!(cyclic.len(), n);
 

tests/slice_move_prev_to.rs

@@ -12,7 +12,6 @@ fn slice_move_prev_to_front() {
     let a = 1;
     let b = 5;
     for i in a..=b {
-        dbg!(i);
         let (mut list, idx) = list_and_indices(n);
         let mut slice = list.slice_mut(&idx[a]..=&idx[b]);
         let idx: Vec<_> = slice.indices().collect();