Use prelude Ord::min/max instead of from cmp

Author: cuviper

rayon-core/src/scope/test.rs

@@ -3,7 +3,6 @@ use crate::ThreadPoolBuilder;
 use crate::{scope, scope_fifo, Scope, ScopeFifo};
 use rand::{Rng, SeedableRng};
 use rand_xorshift::XorShiftRng;
-use std::cmp;
 use std::iter::once;
 use std::sync::atomic::{AtomicUsize, Ordering};
 use std::sync::{Barrier, Mutex};
@@ -182,7 +181,7 @@ fn the_final_countdown<'scope>(
     let diff = if p > q { p - q } else { q - p };
 
     let mut data = max.lock().unwrap();
-    *data = cmp::max(diff, *data);
+    *data = Ord::max(diff, *data);
 
     if n > 0 {
         s.spawn(move |s| the_final_countdown(s, bottom_of_stack, max, n - 1));

rayon-core/src/sleep/counters.rs

@@ -166,7 +166,7 @@ impl AtomicCounters {
         // Current heuristic: whenever an inactive thread goes away, if
         // there are any sleeping threads, wake 'em up.
         let sleeping_threads = old_value.sleeping_threads();
-        std::cmp::min(sleeping_threads, 2)
+        Ord::min(sleeping_threads, 2)
     }
 
     /// Subtracts a sleeping thread. This cannot fail, but it is only

rayon-core/src/sleep/mod.rs

@@ -264,10 +264,10 @@ impl Sleep {
         // -- clearly the existing idle jobs aren't enough. Otherwise,
         // check to see if we have enough idle workers.
         if !queue_was_empty {
-            let num_to_wake = std::cmp::min(num_jobs, num_sleepers);
+            let num_to_wake = Ord::min(num_jobs, num_sleepers);
             self.wake_any_threads(num_to_wake);
         } else if num_awake_but_idle < num_jobs {
-            let num_to_wake = std::cmp::min(num_jobs - num_awake_but_idle, num_sleepers);
+            let num_to_wake = Ord::min(num_jobs - num_awake_but_idle, num_sleepers);
             self.wake_any_threads(num_to_wake);
         }
     }

rayon-demo/src/mergesort/mod.rs

@@ -26,7 +26,6 @@ pub struct Args {
 
 use docopt::Docopt;
 
-use std::cmp::max;
 use std::mem::MaybeUninit;
 use std::slice;
 use std::time::Instant;
@@ -132,7 +131,7 @@ fn seq_merge<T: Ord + Copy>(a: &[T], b: &[T], dest: &mut [MaybeUninit<T>]) {
         dest.copy_from_slice(as_uninit_slice(a));
         return;
     }
-    let biggest = max(*a.last().unwrap(), *b.last().unwrap());
+    let biggest = Ord::max(*a.last().unwrap(), *b.last().unwrap());
     let mut ai = a.iter();
     let mut an = *ai.next().unwrap();
     let mut bi = b.iter();

rayon-demo/src/tsp/step.rs

@@ -1,5 +1,4 @@
 use rayon::Scope;
-use std::cmp;
 use std::sync::Arc;
 
 use super::graph::{Graph, Node, NodeSet};
@@ -90,7 +89,7 @@ fn compute_lower_bound(
                 // track the cheapest way to reach node `j` that doesn't
                 // start from one of the nodes we've been to already (but
                 // maybe starts from the most recent node):
-                min_weights[j.index()] = cmp::min(w, min_weights[j.index()]);
+                min_weights[j.index()] = Ord::min(w, min_weights[j.index()]);
             }
         }
     }

src/iter/chain.rs

@@ -1,7 +1,6 @@
 use super::plumbing::*;
 use super::*;
 use rayon_core::join;
-use std::cmp;
 use std::iter;
 
 /// `Chain` is an iterator that joins `b` after `a` in one continuous iterator.
@@ -178,11 +177,11 @@ where
     }
 
     fn min_len(&self) -> usize {
-        cmp::max(self.a.min_len(), self.b.min_len())
+        Ord::max(self.a.min_len(), self.b.min_len())
     }
 
     fn max_len(&self) -> usize {
-        cmp::min(self.a.max_len(), self.b.max_len())
+        Ord::min(self.a.max_len(), self.b.max_len())
     }
 
     fn split_at(self, index: usize) -> (Self, Self) {

src/iter/chunks.rs

@@ -1,5 +1,3 @@
-use std::cmp::min;
-
 use super::plumbing::*;
 use super::*;
 use crate::math::div_round_up;
@@ -133,7 +131,7 @@ where
     }
 
     fn split_at(self, index: usize) -> (Self, Self) {
-        let elem_index = min(index * self.chunk_size, self.len);
+        let elem_index = Ord::min(index * self.chunk_size, self.len);
         let (left, right) = self.base.split_at(elem_index);
         (
             ChunkProducer {

src/iter/interleave.rs

@@ -1,6 +1,5 @@
 use super::plumbing::*;
 use super::*;
-use std::cmp;
 use std::iter::Fuse;
 
 /// `Interleave` is an iterator that interleaves elements of iterators
@@ -185,11 +184,11 @@ where
     }
 
     fn min_len(&self) -> usize {
-        cmp::max(self.i.min_len(), self.j.min_len())
+        Ord::max(self.i.min_len(), self.j.min_len())
     }
 
     fn max_len(&self) -> usize {
-        cmp::min(self.i.max_len(), self.j.max_len())
+        Ord::min(self.i.max_len(), self.j.max_len())
     }
 
     /// We know 0 < index <= self.i_len + self.j_len

src/iter/len.rs

@@ -1,6 +1,5 @@
 use super::plumbing::*;
 use super::*;
-use std::cmp;
 
 /// `MinLen` is an iterator that imposes a minimum length on iterator splits.
 /// This struct is created by the [`with_min_len()`] method on [`IndexedParallelIterator`]
@@ -107,7 +106,7 @@ where
     }
 
     fn min_len(&self) -> usize {
-        cmp::max(self.min, self.base.min_len())
+        Ord::max(self.min, self.base.min_len())
     }
 
     fn max_len(&self) -> usize {
@@ -245,7 +244,7 @@ where
     }
 
     fn max_len(&self) -> usize {
-        cmp::min(self.max, self.base.max_len())
+        Ord::min(self.max, self.base.max_len())
     }
 
     fn split_at(self, index: usize) -> (Self, Self) {

src/iter/mod.rs

@@ -82,7 +82,7 @@
 use self::plumbing::*;
 use self::private::Try;
 pub use either::Either;
-use std::cmp::{self, Ordering};
+use std::cmp::Ordering;
 use std::collections::LinkedList;
 use std::iter::{Product, Sum};
 use std::ops::{Fn, RangeBounds};
@@ -1432,7 +1432,7 @@ pub trait ParallelIterator: Sized + Send {
     /// specified, so if the `Ord` impl is not truly associative, then
     /// the results are not deterministic.
     ///
-    /// Basically equivalent to `self.reduce_with(|a, b| cmp::min(a, b))`.
+    /// Basically equivalent to `self.reduce_with(|a, b| Ord::min(a, b))`.
     ///
     /// # Examples
     ///
@@ -1451,7 +1451,7 @@ pub trait ParallelIterator: Sized + Send {
     where
         Self::Item: Ord,
     {
-        self.reduce_with(cmp::min)
+        self.reduce_with(Ord::min)
     }
 
     /// Computes the minimum of all the items in the iterator with respect to
@@ -1530,7 +1530,7 @@ pub trait ParallelIterator: Sized + Send {
     /// specified, so if the `Ord` impl is not truly associative, then
     /// the results are not deterministic.
     ///
-    /// Basically equivalent to `self.reduce_with(|a, b| cmp::max(a, b))`.
+    /// Basically equivalent to `self.reduce_with(|a, b| Ord::max(a, b))`.
     ///
     /// # Examples
     ///
@@ -1549,7 +1549,7 @@ pub trait ParallelIterator: Sized + Send {
     where
         Self::Item: Ord,
     {
-        self.reduce_with(cmp::max)
+        self.reduce_with(Ord::max)
     }
 
     /// Computes the maximum of all the items in the iterator with respect to