Merge pull request #41 from orxfun/migration-to-2024-edition

orxfun · web-flow · commit e973e12280d8 · 2025-04-11T10:13:14.000+02:00
Migration to 2024 edition
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
@@ -0,0 +1,58 @@
+name: Rust
+
+on:
+  push:
+    branches: [ "main" ]
+  pull_request:
+    branches: [ "main" ]
+
+env:
+  CARGO_TERM_COLOR: always
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        toolchain: ["stable"]
+
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Install toolchain
+      uses: dtolnay/rust-toolchain@master
+      with:
+        toolchain: ${{ matrix.toolchain }}
+
+    - name: Install 32bit target
+      run: rustup target add i686-unknown-linux-musl
+    - name: Install wasm target
+      run: rustup target add wasm32v1-none
+    - name: Install miri
+      run: rustup component add --toolchain nightly-x86_64-unknown-linux-gnu miri
+    - name: Install no-std-check
+      run: cargo install cargo-no-std-check
+      
+    - name: Build
+      run: cargo build --verbose
+    - name: Build-32bit
+      run: cargo build --verbose --target i686-unknown-linux-musl
+    - name: Build-wasm
+      run: cargo build --verbose --target wasm32v1-none
+
+    - name: Test
+      run: cargo test --verbose
+    - name: Test-32bit
+      run: cargo test --verbose --target i686-unknown-linux-musl
+    - name: Check-wasm
+      run: cargo check --verbose --target wasm32v1-none
+
+    - name: Clippy
+      run: cargo clippy -- -D warnings --verbose
+
+    - name: Miri
+      run: cargo +nightly miri test --verbose
+
+    - name: NoStd
+      run: cargo +nightly no-std-check
diff --git a/Cargo.toml b/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "orx-linked-list"
-version = "3.6.0"
-edition = "2021"
+version = "3.7.0"
+edition = "2024"
 authors = ["orxfun <orx.ugur.arikan@gmail.com>"]
 description = "A linked list implementation with unique features and an extended list of constant time methods providing high performance traversals and mutations."
 license = "MIT OR Apache-2.0"
@@ -10,24 +10,25 @@ keywords = ["linked", "list", "doubly", "singly", "pinned"]
 categories = ["data-structures", "rust-patterns", "no-std"]
 
 [dependencies]
-orx-pseudo-default = { version = "2.0.0", default-features = false }
-orx-pinned-vec = "3.15"
-orx-fixed-vec = "3.15"
-orx-split-vec = "3.15"
-orx-selfref-col = "2.7"
-orx-iterable = { version = "1.2.0", default-features = false }
+orx-iterable = { version = "1.3.0", default-features = false }
+orx-pseudo-default = { version = "2.1.0", default-features = false }
+orx-pinned-vec = "3.16.0"
+orx-fixed-vec = "3.16.0"
+orx-split-vec = "3.16.0"
+orx-selfref-col = "2.8.0"
+
 
 [dev-dependencies]
-clap = { version = "4.5.27", features = ["derive"] }
+clap = { version = "4.5.35", features = ["derive"] }
 criterion = "0.5"
-rand = "0.8.5"
-rand_chacha = "0.3.1"
+rand = "0.9.0"
+rand_chacha = "0.9.0"
 test-case = "3.3.1"
 
 [features]
 default = []
 validation = []
 
 [[bench]]
-name = "doubly_shuffling_around"
+name = "doubly_mutation_ends"
 harness = false
diff --git a/benches/doubly_iter.rs b/benches/doubly_iter.rs
@@ -1,4 +1,4 @@
-use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};
+use criterion::{BenchmarkId, Criterion, criterion_group, criterion_main};
 use orx_linked_list::*;
 use orx_selfref_col::MemoryPolicy;
 use rand::prelude::*;
@@ -15,15 +15,15 @@ enum Action {
 fn get_test_data(n: usize) -> Vec<Action> {
     let mut rng = ChaCha8Rng::seed_from_u64(56456);
     let mut vec: Vec<_> = (0..n)
-        .map(|_| match rng.gen::<f32>() {
-            x if x < 0.5 => Action::PushBack(rng.gen_range(0..n).to_string()),
-            _ => Action::PushFront(rng.gen_range(0..n).to_string()),
+        .map(|_| match rng.random::<f32>() {
+            x if x < 0.5 => Action::PushBack(rng.random_range(0..n).to_string()),
+            _ => Action::PushFront(rng.random_range(0..n).to_string()),
         })
         .collect();
     for _ in 0..2 * n {
-        let action = match rng.gen::<f32>() {
-            x if x < 0.25 => Action::PushBack(rng.gen_range(0..n).to_string()),
-            x if x < 0.50 => Action::PushFront(rng.gen_range(0..n).to_string()),
+        let action = match rng.random::<f32>() {
+            x if x < 0.25 => Action::PushBack(rng.random_range(0..n).to_string()),
+            x if x < 0.50 => Action::PushFront(rng.random_range(0..n).to_string()),
             x if x < 0.75 => Action::PopBack,
             _ => Action::PopFront,
         };
diff --git a/benches/doubly_iter_rev.rs b/benches/doubly_iter_rev.rs
@@ -1,4 +1,4 @@
-use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};
+use criterion::{BenchmarkId, Criterion, criterion_group, criterion_main};
 use orx_linked_list::*;
 use orx_selfref_col::MemoryPolicy;
 use rand::prelude::*;
@@ -15,15 +15,15 @@ enum Action {
 fn get_test_data(n: usize) -> Vec<Action> {
     let mut rng = ChaCha8Rng::seed_from_u64(56456);
     let mut vec: Vec<_> = (0..n)
-        .map(|_| match rng.gen::<f32>() {
-            x if x < 0.5 => Action::PushBack(rng.gen_range(0..n).to_string()),
-            _ => Action::PushFront(rng.gen_range(0..n).to_string()),
+        .map(|_| match rng.random::<f32>() {
+            x if x < 0.5 => Action::PushBack(rng.random_range(0..n).to_string()),
+            _ => Action::PushFront(rng.random_range(0..n).to_string()),
         })
         .collect();
     for _ in 0..2 * n {
-        let action = match rng.gen::<f32>() {
-            x if x < 0.25 => Action::PushBack(rng.gen_range(0..n).to_string()),
-            x if x < 0.50 => Action::PushFront(rng.gen_range(0..n).to_string()),
+        let action = match rng.random::<f32>() {
+            x if x < 0.25 => Action::PushBack(rng.random_range(0..n).to_string()),
+            x if x < 0.50 => Action::PushFront(rng.random_range(0..n).to_string()),
             x if x < 0.75 => Action::PopBack,
             _ => Action::PopFront,
         };
diff --git a/benches/doubly_mutation_by_pos.rs b/benches/doubly_mutation_by_pos.rs
@@ -1,4 +1,4 @@
-use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};
+use criterion::{BenchmarkId, Criterion, criterion_group, criterion_main};
 use orx_linked_list::*;
 use orx_selfref_col::MemoryPolicy;
 use rand::prelude::*;
@@ -15,15 +15,15 @@ enum Action {
 fn get_test_data(n: usize) -> Vec<Action> {
     let mut rng = ChaCha8Rng::seed_from_u64(56456);
     let mut vec: Vec<_> = (0..n)
-        .map(|_| match rng.gen::<f32>() {
-            x if x < 0.5 => Action::PushBack(rng.gen_range(0..n) as u32),
-            _ => Action::PushFront(rng.gen_range(0..n) as u32),
+        .map(|_| match rng.random::<f32>() {
+            x if x < 0.5 => Action::PushBack(rng.random_range(0..n) as u32),
+            _ => Action::PushFront(rng.random_range(0..n) as u32),
         })
         .collect();
     for _ in 0..2 * n {
-        let action = match rng.gen::<f32>() {
-            x if x < 0.50 => Action::Insert(rng.gen_range(0..n), rng.gen_range(0..n) as u32),
-            _ => Action::Remove(rng.gen_range(0..n)),
+        let action = match rng.random::<f32>() {
+            x if x < 0.50 => Action::Insert(rng.random_range(0..n), rng.random_range(0..n) as u32),
+            _ => Action::Remove(rng.random_range(0..n)),
         };
         vec.push(action)
     }
diff --git a/benches/doubly_mutation_ends.rs b/benches/doubly_mutation_ends.rs
@@ -1,4 +1,4 @@
-use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};
+use criterion::{BenchmarkId, Criterion, criterion_group, criterion_main};
 use orx_linked_list::*;
 use orx_selfref_col::MemoryPolicy;
 use rand::prelude::*;
@@ -15,15 +15,15 @@ enum Action {
 fn get_test_data(n: usize) -> Vec<Action> {
     let mut rng = ChaCha8Rng::seed_from_u64(56456);
     let mut vec: Vec<_> = (0..n)
-        .map(|_| match rng.gen::<f32>() {
-            x if x < 0.5 => Action::PushBack(rng.gen_range(0..n) as u32),
-            _ => Action::PushFront(rng.gen_range(0..n) as u32),
+        .map(|_| match rng.random::<f32>() {
+            x if x < 0.5 => Action::PushBack(rng.random_range(0..n) as u32),
+            _ => Action::PushFront(rng.random_range(0..n) as u32),
         })
         .collect();
     for _ in 0..2 * n {
-        let action = match rng.gen::<f32>() {
-            x if x < 0.25 => Action::PushBack(rng.gen_range(0..n) as u32),
-            x if x < 0.50 => Action::PushFront(rng.gen_range(0..n) as u32),
+        let action = match rng.random::<f32>() {
+            x if x < 0.25 => Action::PushBack(rng.random_range(0..n) as u32),
+            x if x < 0.50 => Action::PushFront(rng.random_range(0..n) as u32),
             x if x < 0.75 => Action::PopBack,
             _ => Action::PopFront,
         };
diff --git a/benches/doubly_shuffling_around.rs b/benches/doubly_shuffling_around.rs
@@ -1,4 +1,4 @@
-use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};
+use criterion::{BenchmarkId, Criterion, criterion_group, criterion_main};
 use orx_linked_list::*;
 use rand::prelude::*;
 use rand_chacha::ChaCha8Rng;
@@ -16,8 +16,8 @@ fn get_moves(num_moves: usize, num_cities: usize) -> Vec<(usize, usize)> {
     let mut moves = vec![];
 
     for _ in 0..num_moves {
-        let a = rng.gen_range(0..num_cities);
-        let b = rng.gen_range(0..num_cities);
+        let a = rng.random_range(0..num_cities);
+        let b = rng.random_range(0..num_cities);
         moves.push((a, b));
     }
 
diff --git a/benches/singly_mutation_ends.rs b/benches/singly_mutation_ends.rs
@@ -1,4 +1,4 @@
-use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};
+use criterion::{BenchmarkId, Criterion, criterion_group, criterion_main};
 use orx_linked_list::*;
 use orx_selfref_col::MemoryPolicy;
 use rand::prelude::*;
@@ -13,11 +13,11 @@ enum Action {
 fn get_test_data(n: usize) -> Vec<Action> {
     let mut rng = ChaCha8Rng::seed_from_u64(56456);
     let mut vec: Vec<_> = (0..n)
-        .map(|_| Action::PushFront(rng.gen_range(0..n) as u32))
+        .map(|_| Action::PushFront(rng.random_range(0..n) as u32))
         .collect();
     for _ in 0..2 * n {
-        let action = match rng.gen::<f32>() {
-            x if x < 0.50 => Action::PushFront(rng.gen_range(0..n) as u32),
+        let action = match rng.random::<f32>() {
+            x if x < 0.50 => Action::PushFront(rng.random_range(0..n) as u32),
             _ => Action::PopFront,
         };
         vec.push(action)
diff --git a/examples/tour_mutations.rs b/examples/tour_mutations.rs
@@ -17,8 +17,8 @@ fn get_moves(num_moves: usize, num_cities: usize) -> Vec<(usize, usize)> {
     let mut moves = vec![];
 
     for _ in 0..num_moves {
-        let a = rng.gen_range(0..num_cities);
-        let b = rng.gen_range(0..num_cities);
+        let a = rng.random_range(0..num_cities);
+        let b = rng.random_range(0..num_cities);
         moves.push((a, b));
     }
 
diff --git a/src/pointers/doubly_ptr.rs b/src/pointers/doubly_ptr.rs
@@ -29,7 +29,7 @@ pub trait DoublyPointer<T> {
     /// Alternatively, you may use `NodeIdx` for safe access.
     #[inline(always)]
     unsafe fn node(&self) -> &Node<Doubly<T>> {
-        &*self.raw_ptr()
+        unsafe { &*self.raw_ptr() }
     }
 
     /// Returns a mutable reference to the node.
@@ -45,7 +45,7 @@ pub trait DoublyPointer<T> {
     /// Alternatively, you may use `NodeIdx` for safe access.
     #[inline(always)]
     unsafe fn node_mut(&mut self) -> &mut Node<Doubly<T>> {
-        &mut *self.raw_ptr()
+        unsafe { &mut *self.raw_ptr() }
     }
 
     /// Returns the pointer to the next node if exists; None otherwise.
@@ -61,7 +61,7 @@ pub trait DoublyPointer<T> {
     /// Alternatively, you may use `NodeIdx` for safe access.
     #[inline(always)]
     unsafe fn next(&self) -> Option<DoublyPtr<T>> {
-        self.node().next().get().cloned()
+        unsafe { self.node() }.next().get().cloned()
     }
 
     /// Returns the pointer to the prev node if exists; None otherwise.
@@ -77,6 +77,6 @@ pub trait DoublyPointer<T> {
     /// Alternatively, you may use `NodeIdx` for safe access.
     #[inline(always)]
     unsafe fn prev(&self) -> Option<DoublyPtr<T>> {
-        self.node().prev().get().cloned()
+        unsafe { self.node() }.prev().get().cloned()
     }
 }
diff --git a/src/pointers/singly_ptr.rs b/src/pointers/singly_ptr.rs
@@ -29,7 +29,7 @@ pub trait SinglyPointer<T> {
     /// Alternatively, you may use `NodeIdx` for safe access.
     #[inline(always)]
     unsafe fn node(&self) -> &Node<Singly<T>> {
-        &*self.raw_ptr()
+        unsafe { &*self.raw_ptr() }
     }
 
     /// Returns a mutable reference to the node.
@@ -45,7 +45,7 @@ pub trait SinglyPointer<T> {
     /// Alternatively, you may use `NodeIdx` for safe access.
     #[inline(always)]
     unsafe fn node_mut(&mut self) -> &mut Node<Singly<T>> {
-        &mut *self.raw_ptr()
+        unsafe { &mut *self.raw_ptr() }
     }
 
     /// Returns the pointer to the next node if exists; None otherwise.
@@ -61,6 +61,6 @@ pub trait SinglyPointer<T> {
     /// Alternatively, you may use `NodeIdx` for safe access.
     #[inline(always)]
     unsafe fn next(&self) -> Option<SinglyPtr<T>> {
-        self.node().next().get().cloned()
+        unsafe { self.node() }.next().get().cloned()
     }
 }
diff --git a/tests/doubly.rs b/tests/doubly.rs
@@ -37,16 +37,16 @@ const ACTIONS: [Actions; 10] = [
 const GROW_ACTIONS: [Actions; 3] = [Actions::PushBack, Actions::PushFront, Actions::Insert];
 
 fn val(r: &mut R) -> String {
-    r.gen_range(0..10000).to_string()
+    r.random_range(0..10000).to_string()
 }
 
 impl Actions {
     fn pick_grow(r: &mut R) -> Self {
-        GROW_ACTIONS[r.gen_range(0..GROW_ACTIONS.len())]
+        GROW_ACTIONS[r.random_range(0..GROW_ACTIONS.len())]
     }
 
     fn pick(r: &mut R) -> Self {
-        ACTIONS[r.gen_range(0..ACTIONS.len())]
+        ACTIONS[r.random_range(0..ACTIONS.len())]
     }
 
     fn apply<M>(self, r: &mut R, list: &mut List<Doubly<String>, M>)
@@ -86,14 +86,14 @@ impl Actions {
             Insert => {
                 let pos = match list.len() {
                     0 => 0,
-                    _ => r.gen_range(0..=list.len()),
+                    _ => r.random_range(0..=list.len()),
                 };
                 list.insert_at(pos, val(r));
             }
             Remove => {
                 let pos = match list.len() {
                     0 => 0,
-                    _ => r.gen_range(0..list.len()),
+                    _ => r.random_range(0..list.len()),
                 };
                 list.remove_at(pos);
             }
diff --git a/tests/list_swap.rs b/tests/list_swap.rs
@@ -19,8 +19,8 @@ fn list_swap() {
     let mut control: Vec<_> = list.iter().cloned().collect();
 
     for _ in 0..100 {
-        let a = r.gen_range(0..list.len());
-        let b = r.gen_range(0..list.len());
+        let a = r.random_range(0..list.len());
+        let b = r.random_range(0..list.len());
 
         list.swap(&idx[a], &idx[b]);
 
diff --git a/tests/ring_iter_mut.rs b/tests/ring_iter_mut.rs
@@ -2,23 +2,6 @@ mod doubly;
 
 use orx_linked_list::*;
 
-#[test]
-fn abc() {
-    let mut list: DoublyList<_> = (0..5).collect();
-    let idx: Vec<_> = list.indices().collect();
-
-    let i = 1;
-
-    let iter = list.ring_iter_mut(&idx[i]);
-    for x in iter {
-        dbg!(*x);
-    }
-
-    dbg!("_---------_");
-
-    // assert_eq!(list.len(), 3333);
-}
-
 #[test]
 fn ring_iter_mut_on_list() {
     let mut list = doubly::new_doubly(&mut doubly::rng(), 40, 40);
diff --git a/tests/singly.rs b/tests/singly.rs
diff --git a/tests/utilization.rs b/tests/utilization.rs

Original file line number	Diff line number	Diff line change
`@@ -17,8 +17,8 @@ fn get_moves(num_moves: usize, num_cities: usize) -> Vec<(usize, usize)> {`
`17`	`17`	`let mut moves = vec![];`
`18`	`18`
`19`	`19`	`for _ in 0..num_moves {`
`20`		`- let a = rng.gen_range(0..num_cities);`
`21`		`- let b = rng.gen_range(0..num_cities);`
	`20`	`+ let a = rng.random_range(0..num_cities);`
	`21`	`+ let b = rng.random_range(0..num_cities);`
`22`	`22`	`moves.push((a, b));`
`23`	`23`	`}`
`24`	`24`
Original file line number	Diff line number	Diff line change
`@@ -29,7 +29,7 @@ pub trait DoublyPointer<T> {`
`29`	`29`	/// Alternatively, you may use `NodeIdx` for safe access.
`30`	`30`	`#[inline(always)]`
`31`	`31`	`unsafe fn node(&self) -> &Node<Doubly<T>> {`
`32`		`- &*self.raw_ptr()`
	`32`	`+ unsafe { &*self.raw_ptr() }`
`33`	`33`	`}`
`34`	`34`
`35`	`35`	`/// Returns a mutable reference to the node.`
`@@ -45,7 +45,7 @@ pub trait DoublyPointer<T> {`
`45`	`45`	/// Alternatively, you may use `NodeIdx` for safe access.
`46`	`46`	`#[inline(always)]`
`47`	`47`	`unsafe fn node_mut(&mut self) -> &mut Node<Doubly<T>> {`
`48`		`- &mut *self.raw_ptr()`
	`48`	`+ unsafe { &mut *self.raw_ptr() }`
`49`	`49`	`}`
`50`	`50`
`51`	`51`	`/// Returns the pointer to the next node if exists; None otherwise.`
`@@ -61,7 +61,7 @@ pub trait DoublyPointer<T> {`
`61`	`61`	/// Alternatively, you may use `NodeIdx` for safe access.
`62`	`62`	`#[inline(always)]`
`63`	`63`	`unsafe fn next(&self) -> Option<DoublyPtr<T>> {`
`64`		`- self.node().next().get().cloned()`
	`64`	`+ unsafe { self.node() }.next().get().cloned()`
`65`	`65`	`}`
`66`	`66`
`67`	`67`	`/// Returns the pointer to the prev node if exists; None otherwise.`
`@@ -77,6 +77,6 @@ pub trait DoublyPointer<T> {`
`77`	`77`	/// Alternatively, you may use `NodeIdx` for safe access.
`78`	`78`	`#[inline(always)]`
`79`	`79`	`unsafe fn prev(&self) -> Option<DoublyPtr<T>> {`
`80`		`- self.node().prev().get().cloned()`
	`80`	`+ unsafe { self.node() }.prev().get().cloned()`
`81`	`81`	`}`
`82`	`82`	`}`