rename extract to extract_lane (#1586)

benjamin-lieser · web-flow · commit 49d76cd7b4a3 · 2025-02-12T19:05:01.000+01:00
- [x] Added a `CHANGELOG.md` entry

# Summary

Rename a function which is only used for testing because it clashes with
`std::simd`

# Motivation

CI fails otherwise

# Details
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -8,6 +8,9 @@ A [separate changelog is kept for rand_core](rand_core/CHANGELOG.md).
 
 You may also find the [Upgrade Guide](https://rust-random.github.io/book/update.html) useful.
 
+## [Unreleased]
+- Fix feature `simd_support` for recent nightly rust (#1586)
+
 ## [0.9.0] - 2025-01-27
 ### Security and unsafe
 - Policy: "rand is not a crypto library" (#1514)
diff --git a/src/distr/uniform_float.rs b/src/distr/uniform_float.rs
@@ -248,39 +248,42 @@ mod tests {
                         let my_uniform = Uniform::new(low, high).unwrap();
                         let my_incl_uniform = Uniform::new_inclusive(low, high).unwrap();
                         for _ in 0..100 {
-                            let v = rng.sample(my_uniform).extract(lane);
+                            let v = rng.sample(my_uniform).extract_lane(lane);
                             assert!(low_scalar <= v && v <= high_scalar);
-                            let v = rng.sample(my_incl_uniform).extract(lane);
+                            let v = rng.sample(my_incl_uniform).extract_lane(lane);
                             assert!(low_scalar <= v && v <= high_scalar);
                             let v =
                                 <$ty as SampleUniform>::Sampler::sample_single(low, high, &mut rng)
                                     .unwrap()
-                                    .extract(lane);
+                                    .extract_lane(lane);
                             assert!(low_scalar <= v && v <= high_scalar);
                             let v = <$ty as SampleUniform>::Sampler::sample_single_inclusive(
                                 low, high, &mut rng,
                             )
                             .unwrap()
-                            .extract(lane);
+                            .extract_lane(lane);
                             assert!(low_scalar <= v && v <= high_scalar);
                         }
 
                         assert_eq!(
                             rng.sample(Uniform::new_inclusive(low, low).unwrap())
-                                .extract(lane),
+                                .extract_lane(lane),
                             low_scalar
                         );
 
-                        assert_eq!(zero_rng.sample(my_uniform).extract(lane), low_scalar);
-                        assert_eq!(zero_rng.sample(my_incl_uniform).extract(lane), low_scalar);
+                        assert_eq!(zero_rng.sample(my_uniform).extract_lane(lane), low_scalar);
+                        assert_eq!(
+                            zero_rng.sample(my_incl_uniform).extract_lane(lane),
+                            low_scalar
+                        );
                         assert_eq!(
                             <$ty as SampleUniform>::Sampler::sample_single(
                                 low,
                                 high,
                                 &mut zero_rng
                             )
                             .unwrap()
-                            .extract(lane),
+                            .extract_lane(lane),
                             low_scalar
                         );
                         assert_eq!(
@@ -290,12 +293,12 @@ mod tests {
                                 &mut zero_rng
                             )
                             .unwrap()
-                            .extract(lane),
+                            .extract_lane(lane),
                             low_scalar
                         );
 
-                        assert!(max_rng.sample(my_uniform).extract(lane) <= high_scalar);
-                        assert!(max_rng.sample(my_incl_uniform).extract(lane) <= high_scalar);
+                        assert!(max_rng.sample(my_uniform).extract_lane(lane) <= high_scalar);
+                        assert!(max_rng.sample(my_incl_uniform).extract_lane(lane) <= high_scalar);
                         // sample_single cannot cope with max_rng:
                         // assert!(<$ty as SampleUniform>::Sampler
                         //     ::sample_single(low, high, &mut max_rng).unwrap()
@@ -307,7 +310,7 @@ mod tests {
                                 &mut max_rng
                             )
                             .unwrap()
-                            .extract(lane)
+                            .extract_lane(lane)
                                 <= high_scalar
                         );
 
@@ -326,7 +329,7 @@ mod tests {
                                     &mut lowering_max_rng
                                 )
                                 .unwrap()
-                                .extract(lane)
+                                .extract_lane(lane)
                                     <= high_scalar
                             );
                         }
diff --git a/src/distr/utils.rs b/src/distr/utils.rs
@@ -236,7 +236,7 @@ pub(crate) trait FloatSIMDScalarUtils: FloatSIMDUtils {
     type Scalar;
 
     fn replace(self, index: usize, new_value: Self::Scalar) -> Self;
-    fn extract(self, index: usize) -> Self::Scalar;
+    fn extract_lane(self, index: usize) -> Self::Scalar;
 }
 
 /// Implement functions on f32/f64 to give them APIs similar to SIMD types
@@ -320,7 +320,7 @@ macro_rules! scalar_float_impl {
             }
 
             #[inline]
-            fn extract(self, index: usize) -> Self::Scalar {
+            fn extract_lane(self, index: usize) -> Self::Scalar {
                 debug_assert_eq!(index, 0);
                 self
             }
@@ -395,7 +395,7 @@ macro_rules! simd_impl {
             }
 
             #[inline]
-            fn extract(self, index: usize) -> Self::Scalar {
+            fn extract_lane(self, index: usize) -> Self::Scalar {
                 self.as_array()[index]
             }
         }

Original file line number	Diff line number	Diff line change
`@@ -236,7 +236,7 @@ pub(crate) trait FloatSIMDScalarUtils: FloatSIMDUtils {`
`236`	`236`	`type Scalar;`
`237`	`237`
`238`	`238`	`fn replace(self, index: usize, new_value: Self::Scalar) -> Self;`
`239`		`- fn extract(self, index: usize) -> Self::Scalar;`
	`239`	`+ fn extract_lane(self, index: usize) -> Self::Scalar;`
`240`	`240`	`}`
`241`	`241`
`242`	`242`	`/// Implement functions on f32/f64 to give them APIs similar to SIMD types`
`@@ -320,7 +320,7 @@ macro_rules! scalar_float_impl {`
`320`	`320`	`}`
`321`	`321`
`322`	`322`	`#[inline]`
`323`		`- fn extract(self, index: usize) -> Self::Scalar {`
	`323`	`+ fn extract_lane(self, index: usize) -> Self::Scalar {`
`324`	`324`	`debug_assert_eq!(index, 0);`
`325`	`325`	`self`
`326`	`326`	`}`
`@@ -395,7 +395,7 @@ macro_rules! simd_impl {`
`395`	`395`	`}`
`396`	`396`
`397`	`397`	`#[inline]`
`398`		`- fn extract(self, index: usize) -> Self::Scalar {`
	`398`	`+ fn extract_lane(self, index: usize) -> Self::Scalar {`
`399`	`399`	`self.as_array()[index]`
`400`	`400`	`}`
`401`	`401`	`}`