Merge pull request #77 from orxfun/concurrent-iterators

Concurrent iterators

Author: orxfun

.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

Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "orx-split-vec"
-version = "3.15.0"
-edition = "2021"
+version = "3.16.0"
+edition = "2024"
 authors = ["orxfun <orx.ugur.arikan@gmail.com>"]
 description = "An efficient dynamic capacity vector with pinned element guarantees."
 license = "MIT OR Apache-2.0"
@@ -10,9 +10,9 @@ keywords = ["vec", "array", "split", "fragments", "pinned"]
 categories = ["data-structures", "rust-patterns", "no-std"]
 
 [dependencies]
-orx-iterable = { version = "1.2.0", default-features = false }
-orx-pseudo-default = { version = "2.0.0", default-features = false }
-orx-pinned-vec = "3.15"
+orx-iterable = { version = "1.3.0", default-features = false }
+orx-pseudo-default = { version = "2.1.0", default-features = false }
+orx-pinned-vec = { version = "3.16.0", default-features = false }
 
 [[bench]]
 name = "serial_access"
@@ -23,5 +23,3 @@ criterion = { version = "0.5", default-features = false }
 rand = { version = "0.9", default-features = false }
 rand_chacha = { version = "0.9", default-features = false }
 test-case = "3.3.1"
-wasm-bindgen = "0.2"
-wasm-bindgen-test = "0.3"

README.md

@@ -142,19 +142,19 @@ let slice = vec.try_get_slice(3..7);
 assert_eq!(slice, SplitVecSlice::OutOfBounds);
 
 // instead of a single slice; we can get an iterator of slices
-let slices = vec.slices(..);
+let mut slices = vec.slices(..);
 assert_eq!(2, slices.len());
-assert_eq!(slices[0], &[0, 1, 2, 3]);
-assert_eq!(slices[1], &[4]);
+assert_eq!(slices.next().unwrap(), &[0, 1, 2, 3]);
+assert_eq!(slices.next().unwrap(), &[4]);
 
-let slices = vec.slices(0..3);
+let mut slices = vec.slices(0..3);
 assert_eq!(1, slices.len());
-assert_eq!(slices[0], &[0, 1, 2]);
+assert_eq!(slices.next().unwrap(), &[0, 1, 2]);
 
-let slices = vec.slices(3..5);
+let mut slices = vec.slices(3..5);
 assert_eq!(2, slices.len());
-assert_eq!(slices[0], &[3]);
-assert_eq!(slices[1], &[4]);
+assert_eq!(slices.next().unwrap(), &[3]);
+assert_eq!(slices.next().unwrap(), &[4]);
 ```
 
 Finally, its main difference and objective is to provide pinned element guarantees as demonstrated in the example below.

benches/append.rs

@@ -1,4 +1,4 @@
-use criterion::{black_box, criterion_group, criterion_main, BatchSize, BenchmarkId, Criterion};
+use criterion::{BatchSize, BenchmarkId, Criterion, black_box, criterion_group, criterion_main};
 use orx_split_vec::*;
 use rand::prelude::*;
 use rand_chacha::ChaCha8Rng;
@@ -17,7 +17,7 @@ fn get_vectors(n: usize) -> Vectors {
     let mut rng = ChaCha8Rng::seed_from_u64(685412);
     Vectors(
         (0..NUM_APPEND_OPS)
-            .map(|_| (0..n).map(|_| rng.gen_range(0..n)).collect())
+            .map(|_| (0..n).map(|_| rng.random_range(0..n)).collect())
             .collect(),
     )
 }

benches/random_access.rs

@@ -1,6 +1,6 @@
 use criterion::{
-    black_box, criterion_group, criterion_main, measurement::WallTime, BenchmarkGroup, BenchmarkId,
-    Criterion,
+    BenchmarkGroup, BenchmarkId, Criterion, black_box, criterion_group, criterion_main,
+    measurement::WallTime,
 };
 use orx_split_vec::*;
 use rand::prelude::*;
@@ -10,7 +10,7 @@ fn get_indices(n: usize) -> Vec<usize> {
     let mut rng = ChaCha8Rng::seed_from_u64(7541);
     let mut vec = Vec::with_capacity(n);
     for _ in 0..n {
-        vec.push(rng.gen_range(0..n));
+        vec.push(rng.random_range(0..n));
     }
     vec
 }

src/algorithms/tests/binary_search.rs

@@ -1,5 +1,5 @@
 use crate::algorithms::binary_search::binary_search_by;
-use crate::{test_all_growth_types, Growth, SplitVec};
+use crate::{Growth, SplitVec, test_all_growth_types};
 use core::cmp::Ordering;
 use orx_pinned_vec::PinnedVec;
 
@@ -78,10 +78,15 @@ fn bin_search_randomized() {
     use rand_chacha::ChaCha8Rng;
 
     fn test<G: Growth>(mut vec: SplitVec<usize, G>) {
+        #[cfg(not(miri))]
+        let len = 1033;
+        #[cfg(miri)]
+        let len = 33;
+
         let mut rng = ChaCha8Rng::seed_from_u64(8654);
         let mut ref_vec = alloc::vec![];
         let mut idx = 0;
-        while ref_vec.len() < 1033 {
+        while ref_vec.len() < len {
             if rng.random::<f32>() < 0.85 {
                 ref_vec.push(idx);
                 vec.push(idx);

src/algorithms/tests/in_place_sort.rs

@@ -1,6 +1,6 @@
 use crate::{
-    algorithms::in_place_sort::{find_position_to_insert, in_place_sort_by},
     Doubling, Fragment, Growth, Linear, Recursive,
+    algorithms::in_place_sort::{find_position_to_insert, in_place_sort_by},
 };
 use alloc::vec::Vec;
 use core::cmp::Ordering::*;
@@ -82,11 +82,15 @@ fn sort_simple() {
 
 #[test_case(Doubling)]
 #[test_case(Recursive)]
-#[test_case(Linear::new(10))]
+#[test_case(Linear::new(6))]
 fn sort_growth(growth: impl Growth) {
     let mut c = |a: &i32, b: &i32| a.cmp(b);
 
+    #[cfg(not(miri))]
     let num_fragments = 10;
+    #[cfg(miri)]
+    let num_fragments = 3;
+
     let mut fragments: Vec<Fragment<_>> = alloc::vec![];
 
     let mut len = 0;

src/common_traits/clone.rs

@@ -27,7 +27,7 @@ mod tests {
     #[test]
     fn clone() {
         fn test<G: Growth>(mut vec: SplitVec<usize, G>) {
-            for i in 0..168 {
+            for i in 0..57 {
                 vec.push(i);
             }
 

src/common_traits/eq.rs

@@ -87,7 +87,7 @@ mod tests {
     #[test]
     fn eq() {
         fn test<G: Growth>(mut vec: SplitVec<usize, G>) {
-            for i in 0..142 {
+            for i in 0..57 {
                 vec.push(i);
             }
 

src/common_traits/index.rs

@@ -196,17 +196,17 @@ mod tests {
     #[test]
     fn index() {
         fn test<G: Growth>(mut vec: SplitVec<usize, G>) {
-            vec.extend_from_slice(&(0..42).collect::<Vec<_>>());
-            vec.extend_from_slice(&(42..63).collect::<Vec<_>>());
-            vec.extend_from_slice(&(63..100).collect::<Vec<_>>());
+            vec.extend_from_slice(&(0..21).collect::<Vec<_>>());
+            vec.extend_from_slice(&(21..33).collect::<Vec<_>>());
+            vec.extend_from_slice(&(33..50).collect::<Vec<_>>());
 
-            assert_eq!(100, vec.len());
-            for i in 0..100 {
+            assert_eq!(50, vec.len());
+            for i in 0..50 {
                 assert_eq!(i, vec[i]);
-                vec[i] += 100;
+                vec[i] += 50;
             }
-            for i in 0..100 {
-                assert_eq!(100 + i, vec[i]);
+            for i in 0..50 {
+                assert_eq!(50 + i, vec[i]);
             }
         }
         test_all_growth_types!(test);
@@ -215,19 +215,19 @@ mod tests {
     #[test]
     fn double_indices() {
         fn test<G: Growth>(mut vec: SplitVec<usize, G>) {
-            vec.extend_from_slice(&(0..42).collect::<Vec<_>>());
-            vec.extend_from_slice(&(42..63).collect::<Vec<_>>());
-            vec.extend_from_slice(&(63..100).collect::<Vec<_>>());
+            vec.extend_from_slice(&(0..21).collect::<Vec<_>>());
+            vec.extend_from_slice(&(21..33).collect::<Vec<_>>());
+            vec.extend_from_slice(&(33..50).collect::<Vec<_>>());
 
-            assert_eq!(100, vec.len());
-            for i in 0..100 {
+            assert_eq!(50, vec.len());
+            for i in 0..50 {
                 let (f, j) = vec.get_fragment_and_inner_indices(i).expect("is-some");
                 assert_eq!(i, vec[(f, j)]);
-                vec[(f, j)] += 100;
+                vec[(f, j)] += 50;
             }
-            for i in 0..100 {
+            for i in 0..50 {
                 let (f, j) = vec.get_fragment_and_inner_indices(i).expect("is-some");
-                assert_eq!(100 + i, vec[(f, j)]);
+                assert_eq!(50 + i, vec[(f, j)]);
             }
         }
         test_all_growth_types!(test);