Change is_sorted[_by_key] methods to require Ord instead of PartialOrd

With `f32::total_cmp` and `f64::total_cmp`, the main reason for having
an `PartialOrd` bound on these methods is mostly gone. By requiring
`Ord`, we have no more edges cases with non-comparable values that need
to be explained in the docs. These methods are now also in line with
the `sort*` methods.

Also note that `is_sorted` is mostly for convenience; if it is not
powerful enough, there are more powerful tools that are only slightly
less convenient. Finally, the trait bound can be relaxed in the future.

Author: LukasKalbertodt

library/core/src/iter/traits/iterator.rs

@@ -3272,9 +3272,6 @@ pub trait Iterator {
     /// That is, for each element `a` and its following element `b`, `a <= b` must hold. If the
     /// iterator yields exactly zero or one element, `true` is returned.
     ///
-    /// Note that if `Self::Item` is only `PartialOrd`, but not `Ord`, the above definition
-    /// implies that this function returns `false` if any two consecutive items are not
-    /// comparable.
     ///
     /// # Examples
     ///
@@ -3285,16 +3282,15 @@ pub trait Iterator {
     /// assert!(![1, 3, 2, 4].iter().is_sorted());
     /// assert!([0].iter().is_sorted());
     /// assert!(std::iter::empty::<i32>().is_sorted());
-    /// assert!(![0.0, 1.0, f32::NAN].iter().is_sorted());
     /// ```
     #[inline]
     #[unstable(feature = "is_sorted", reason = "new API", issue = "53485")]
     fn is_sorted(self) -> bool
     where
         Self: Sized,
-        Self::Item: PartialOrd,
+        Self::Item: Ord,
     {
-        self.is_sorted_by(PartialOrd::partial_cmp)
+        self.is_sorted_by(|a, b| Some(a.cmp(b)))
     }
 
     /// Checks if the elements of this iterator are sorted using the given comparator function.

library/core/src/slice/mod.rs

@@ -3322,9 +3322,6 @@ impl<T> [T] {
     /// That is, for each element `a` and its following element `b`, `a <= b` must hold. If the
     /// slice yields exactly zero or one element, `true` is returned.
     ///
-    /// Note that if `Self::Item` is only `PartialOrd`, but not `Ord`, the above definition
-    /// implies that this function returns `false` if any two consecutive items are not
-    /// comparable.
     ///
     /// # Examples
     ///
@@ -3336,15 +3333,14 @@ impl<T> [T] {
     /// assert!(![1, 3, 2, 4].is_sorted());
     /// assert!([0].is_sorted());
     /// assert!(empty.is_sorted());
-    /// assert!(![0.0, 1.0, f32::NAN].is_sorted());
     /// ```
     #[inline]
     #[unstable(feature = "is_sorted", reason = "new API", issue = "53485")]
     pub fn is_sorted(&self) -> bool
     where
-        T: PartialOrd,
+        T: Ord,
     {
-        self.is_sorted_by(|a, b| a.partial_cmp(b))
+        self.is_sorted_by(|a, b| Some(a.cmp(b)))
     }
 
     /// Checks if the elements of this slice are sorted using the given comparator function.
@@ -3383,7 +3379,7 @@ impl<T> [T] {
     pub fn is_sorted_by_key<F, K>(&self, f: F) -> bool
     where
         F: FnMut(&T) -> K,
-        K: PartialOrd,
+        K: Ord,
     {
         self.iter().map(f).is_sorted()
     }

library/core/tests/iter/traits/iterator.rs

@@ -373,7 +373,6 @@ fn test_is_sorted() {
     assert!(![1, 3, 2].iter().is_sorted());
     assert!([0].iter().is_sorted());
     assert!(std::iter::empty::<i32>().is_sorted());
-    assert!(![0.0, 1.0, f32::NAN].iter().is_sorted());
     assert!([-2, -1, 0, 3].iter().is_sorted());
     assert!(!["c", "bb", "aaa"].iter().is_sorted());
 }

library/core/tests/slice.rs

@@ -2005,7 +2005,6 @@ fn test_is_sorted() {
     assert!(![1, 3, 2].is_sorted());
     assert!([0].is_sorted());
     assert!(empty.is_sorted());
-    assert!(![0.0, 1.0, f32::NAN].is_sorted());
     assert!([-2, -1, 0, 3].is_sorted());
     assert!(![-2i32, -1, 0, 3].is_sorted_by_key(|n| n.abs()));
     assert!(!["c", "bb", "aaa"].is_sorted());