Add is_sorted impl for [T]

Author: kleimkuhler

src/libcore/iter/iterator.rs

@@ -2608,19 +2608,18 @@ pub trait Iterator {
 
     /// Checks if the elements of this iterator are sorted.
     ///
-    /// 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.
+    /// 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.
+    /// 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
     ///
     /// ```
     /// #![feature(is_sorted)]
-    /// 
+    ///
     /// assert!([1, 2, 2, 9].iter().is_sorted());
     /// assert!(![1, 3, 2, 4].iter().is_sorted());
     /// assert!([0].iter().is_sorted());
@@ -2636,13 +2635,11 @@ pub trait Iterator {
         self.is_sorted_by(|a, b| a.partial_cmp(b))
     }
 
-    /// Checks if the elements of this iterator are sorted using the given
-    /// comparator function.
+    /// Checks if the elements of this iterator are sorted using the given comparator function.
     ///
-    /// Instead of using `PartialOrd::partial_cmp`, this function uses the given
-    /// `compare` function to determine the ordering of two elements. Apart from
-    /// that, it's equivalent to `is_sorted`; see its documentation for more
-    /// information.
+    /// Instead of using `PartialOrd::partial_cmp`, this function uses the given `compare`
+    /// function to determine the ordering of two elements. Apart from that, it's equivalent to
+    /// `is_sorted`; see its documentation for more information.
     #[unstable(feature = "is_sorted", reason = "new API", issue = "53485")]
     fn is_sorted_by<F>(mut self, mut compare: F) -> bool
     where
@@ -2664,19 +2661,18 @@ pub trait Iterator {
         true
     }
 
-    /// Checks if the elements of this iterator are sorted using the given
-    /// key extraction function.
+    /// Checks if the elements of this iterator are sorted using the given key extraction
+    /// function.
     ///
-    /// Instead of comparing the iterator's elements directly, this function
-    /// compares the keys of the elements, as determined by `f`. Apart from
-    /// that, it's equivalent to `is_sorted`; see its documentation for more
-    /// information.
+    /// Instead of comparing the iterator's elements directly, this function compares the keys of
+    /// the elements, as determined by `f`. Apart from that, it's equivalent to `is_sorted`; see
+    /// its documentation for more information.
     ///
     /// # Examples
     ///
     /// ```
     /// #![feature(is_sorted)]
-    /// 
+    ///
     /// assert!(["c", "bb", "aaa"].iter().is_sorted_by_key(|s| s.len()));
     /// assert!(![-2i32, -1, 0, 3].iter().is_sorted_by_key(|n| n.abs()));
     /// ```

src/libcore/slice/mod.rs

@@ -1783,7 +1783,7 @@ impl<T> [T] {
     /// let mut a = ['a', 'b', 'c', 'd', 'e', 'f'];
     /// a[1..5].rotate_left(1);
     /// assert_eq!(a, ['a', 'c', 'd', 'e', 'b', 'f']);
-   /// ```
+    /// ```
     #[stable(feature = "slice_rotate", since = "1.26.0")]
     pub fn rotate_left(&mut self, mid: usize) {
         assert!(mid <= self.len());
@@ -2250,6 +2250,83 @@ impl<T> [T] {
              from_raw_parts_mut(mut_ptr.add(rest.len() - ts_len), ts_len))
         }
     }
+
+    /// Checks if the elements of this slice are sorted.
+    ///
+    /// 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
+    ///
+    /// ```
+    /// #![feature(is_sorted)]
+    /// let empty: [i32; 0] = [];
+    ///
+    /// assert!([1, 2, 2, 9].is_sorted());
+    /// assert!(![1, 3, 2, 4].is_sorted());
+    /// assert!([0].is_sorted());
+    /// assert!(empty.is_sorted());
+    /// assert!(![0.0, 1.0, std::f32::NAN].is_sorted());
+    /// ```
+    #[unstable(feature = "is_sorted", reason = "new API", issue = "53485")]
+    pub fn is_sorted(&self) -> bool
+    where
+        T: PartialOrd,
+    {
+        self.is_sorted_by(|a, b| a.partial_cmp(b))
+    }
+
+    /// Checks if the elements of this slice are sorted using the given comparator function.
+    ///
+    /// Instead of using `PartialOrd::partial_cmp`, this function uses the given `compare`
+    /// function to determine the ordering of two elements. Apart from that, it's equivalent to
+    /// `is_sorted`; see its documentation for more information.
+    #[unstable(feature = "is_sorted", reason = "new API", issue = "53485")]
+    pub fn is_sorted_by<F>(&self, mut compare: F) -> bool
+    where
+        F: FnMut(&T, &T) -> Option<Ordering>
+    {
+        let mut last = match self.first() {
+            Some(e) => e,
+            None => return true,
+        };
+
+        for curr in &self[1..] {
+            if compare(&last, &curr).map(|o| o == Ordering::Greater).unwrap_or(true) {
+                return false;
+            }
+            last = &curr;
+        }
+
+        true
+    }
+
+    /// Checks if the elements of this slice are sorted using the given key extraction function.
+    ///
+    /// Instead of comparing the slice's elements directly, this function compares the keys of the
+    /// elements, as determined by `f`. Apart from that, it's equivalent to `is_sorted`; see its
+    /// documentation for more information.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// #![feature(is_sorted)]
+    ///
+    /// assert!(["c", "bb", "aaa"].is_sorted_by_key(|s| s.len()));
+    /// assert!(![-2i32, -1, 0, 3].is_sorted_by_key(|n| n.abs()));
+    /// ```
+    #[unstable(feature = "is_sorted", reason = "new API", issue = "53485")]
+    pub fn is_sorted_by_key<F, K>(&self, mut f: F) -> bool
+    where
+        F: FnMut(&T) -> K,
+        K: PartialOrd
+    {
+        self.is_sorted_by(|a, b| f(a).partial_cmp(&f(b)))
+    }
 }
 
 #[lang = "slice_u8"]

src/libcore/tests/slice.rs

@@ -1317,3 +1317,18 @@ fn test_copy_within_panics_src_inverted() {
     // 2 is greater than 1, so this range is invalid.
     bytes.copy_within(2..1, 0);
 }
+
+#[test]
+fn test_is_sorted() {
+    let empty: [i32; 0] = [];
+
+    assert!([1, 2, 2, 9].is_sorted());
+    assert!(![1, 3, 2].is_sorted());
+    assert!([0].is_sorted());
+    assert!(empty.is_sorted());
+    assert!(![0.0, 1.0, std::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());
+    assert!(["c", "bb", "aaa"].is_sorted_by_key(|s| s.len()));
+}

src/test/ui/feature-gates/feature-gate-is_sorted.rs

@@ -13,4 +13,4 @@ fn main() {
     //^ ERROR: use of unstable library feature 'is_sorted'
     assert!(![-2i32, -1, 0, 3].iter().is_sorted_by_key(|n| n.abs()));
     //^ ERROR: use of unstable library feature 'is_sorted'
-}
+}