Edition 2024.

Author: n3vu0r

Cargo.toml

@@ -1,8 +1,8 @@
 [package]
 name = "ndarray-slice"
-version = "0.4.0"
-rust-version = "1.65.0"
-edition = "2021"
+version = "0.5.0"
+rust-version = "1.85.0"
+edition = "2024"
 authors = ["Rouven Spreckels <rs@qu1x.dev>"]
 description = """Fast and robust slice-based algorithms (e.g., sorting, selection, search)
 for non-contiguous (sub)views into n-dimensional arrays."""
@@ -37,13 +37,13 @@ rustdoc-args = ["--cfg", "docsrs"]
 
 [dependencies]
 ndarray = { version = "0.16.1", default-features = false }
-stacker = { version = "0.1.17", optional = true }
+stacker = { version = "0.1.19", optional = true }
 rayon = { version = "1.10.0", optional = true }
 
 [dev-dependencies]
 quickcheck = "1.0.3"
 quickcheck_macros = "1.0.0"
-rand = "0.8.5"
+rand = "0.9.0"
 
 [features]
 default = ["std", "stacker"]

README.md

@@ -11,7 +11,7 @@
 [Documentation]: https://docs.rs/ndarray-slice/badge.svg
 [Downloads]: https://img.shields.io/crates/d/ndarray-slice.svg
 [Version]: https://img.shields.io/crates/v/ndarray-slice.svg
-[Rust]: https://img.shields.io/badge/rust-v1.65.0-brightgreen.svg
+[Rust]: https://img.shields.io/badge/rust-v1.85.0-brightgreen.svg
 [License]: https://img.shields.io/badge/License-MIT%20OR%20Apache--2.0-blue.svg
 
 Fast and robust slice-based algorithms (e.g., [sorting], [selection], [search]) for
@@ -95,7 +95,7 @@ See the [release history](RELEASES.md) to keep track of the development.
 
 # License
 
-Copyright © 2023 Rouven Spreckels <rs@qu1x.dev>
+Copyright © 2023-2025 Rouven Spreckels <rs@qu1x.dev>
 
 This project contains derivative works of [`rust`] and [`rayon`]. For full authorship information,
 see their version control histories. Respective copyrights are retained by their contributors.

src/heap_sort.rs

@@ -2,7 +2,7 @@
 //!
 //! [`core::slice::sort`]: https://doc.rust-lang.org/src/core/slice/sort.rs.html
 
-use ndarray::{s, ArrayViewMut1};
+use ndarray::{ArrayViewMut1, s};
 
 /// Sorts `v` using heapsort, which guarantees *O*(*n* \* log(*n*)) worst-case.
 #[cold]

src/insertion_sort.rs

@@ -3,7 +3,7 @@
 //! [`core::slice::sort`]: https://doc.rust-lang.org/src/core/slice/sort.rs.html
 
 use core::{marker::PhantomData, mem, ptr};
-use ndarray::{s, ArrayViewMut1, IndexLonger};
+use ndarray::{ArrayViewMut1, IndexLonger, s};
 
 // When dropped, copies from `src` into `dest`.
 #[must_use]

src/merge_sort.rs

@@ -7,7 +7,7 @@
 use crate::insertion_sort::insertion_sort_shift_left;
 use crate::partition::reverse;
 use core::{cmp, mem, ptr};
-use ndarray::{s, ArrayView1, ArrayViewMut1, IndexLonger};
+use ndarray::{ArrayView1, ArrayViewMut1, IndexLonger, s};
 
 /// Merges non-decreasing runs `v[..mid]` and `v[mid..]` using `buf` as temporary storage, and
 /// stores the result into `v[..]`.
@@ -178,7 +178,7 @@ where
 	//    }
 	//}
 
-	impl<'a, T> Drop for MergeHole<'a, T> {
+	impl<T> Drop for MergeHole<'_, T> {
 		fn drop(&mut self) {
 			// SAFETY: `T` is not a zero-sized type, and these are pointers into a slice's elements.
 			unsafe {

src/par/heap_sort.rs

@@ -2,7 +2,7 @@
 //!
 //! [`core::slice::sort`]: https://doc.rust-lang.org/src/core/slice/sort.rs.html
 
-use ndarray::{s, ArrayViewMut1};
+use ndarray::{ArrayViewMut1, s};
 
 /// Sorts `v` using heapsort, which guarantees *O*(*n* \* log(*n*)) worst-case.
 #[cold]

src/par/insertion_sort.rs

@@ -4,7 +4,7 @@
 
 use crate::insertion_sort::InsertionHole;
 use core::{mem, ptr};
-use ndarray::{s, ArrayViewMut1, IndexLonger};
+use ndarray::{ArrayViewMut1, IndexLonger, s};
 
 /// Inserts `v[v.len() - 1]` into pre-sorted sequence `v[..v.len() - 1]` so that whole `v[..]`
 /// becomes sorted.

src/par/merge_sort.rs

@@ -7,7 +7,7 @@ use core::{
 	mem::{self, size_of},
 	ptr,
 };
-use ndarray::{s, ArrayView1, ArrayViewMut1, Axis, IndexLonger};
+use ndarray::{ArrayView1, ArrayViewMut1, Axis, IndexLonger, s};
 use rayon::iter::{ParallelBridge, ParallelIterator};
 
 /// We need to transmit raw pointers across threads. It is possible to do this
@@ -920,25 +920,28 @@ where
 mod test {
 	use super::{par_merge_sort, split_for_merge};
 	use core::cmp::Ordering;
-	use ndarray::{s, Array1, ArrayView1};
+	use ndarray::{Array1, ArrayView1, s};
 	use quickcheck_macros::quickcheck;
 	use rand::distributions::Uniform;
-	use rand::{thread_rng, Rng};
+	use rand::{Rng, thread_rng};
 
 	#[test]
 	fn split() {
 		fn check(left: &[u32], right: &[u32]) {
 			let left = ArrayView1::from_shape(left.len(), left).unwrap();
 			let right = ArrayView1::from_shape(right.len(), right).unwrap();
 			let (l, r) = split_for_merge(left, right, &|&a, &b| a < b);
-			assert!(left
-				.slice(s![..l])
-				.iter()
-				.all(|&x| right.slice(s![r..]).iter().all(|&y| x <= y)));
-			assert!(right
-				.slice(s![..r])
-				.iter()
-				.all(|&x| left.slice(s![l..]).iter().all(|&y| x < y)));
+			assert!(
+				left.slice(s![..l])
+					.iter()
+					.all(|&x| right.slice(s![r..]).iter().all(|&y| x <= y))
+			);
+			assert!(
+				right
+					.slice(s![..r])
+					.iter()
+					.all(|&x| left.slice(s![l..]).iter().all(|&y| x < y))
+			);
 		}
 
 		check(&[1, 2, 2, 2, 2, 3], &[1, 2, 2, 2, 2, 3]);

src/par/partition.rs

@@ -16,7 +16,7 @@ use core::{
 	mem::{self, ManuallyDrop, MaybeUninit},
 	ptr,
 };
-use ndarray::{s, ArrayView1, ArrayViewMut1, Axis, IndexLonger};
+use ndarray::{ArrayView1, ArrayViewMut1, Axis, IndexLonger, s};
 
 // For slices of up to this length it's probably faster to simply sort them.
 // Defined at the module scope because it's used in multiple functions.

src/partition.rs

@@ -11,7 +11,7 @@ use core::{
 	mem::{self, ManuallyDrop, MaybeUninit},
 	ptr,
 };
-use ndarray::{s, ArrayView1, ArrayViewMut1, Axis, IndexLonger};
+use ndarray::{ArrayView1, ArrayViewMut1, Axis, IndexLonger, s};
 
 // For slices of up to this length it's probably faster to simply sort them.
 // Defined at the module scope because it's used in multiple functions.
@@ -934,7 +934,7 @@ impl<T> Drop for InsertionHole<T> {
 mod test {
 	use super::{partition_at_index, partition_at_indices, reverse};
 	use crate::{partition_dedup::partition_dedup, quick_sort::quick_sort};
-	use ndarray::{arr1, Array1};
+	use ndarray::{Array1, arr1};
 	use quickcheck::TestResult;
 	use quickcheck_macros::quickcheck;