From b911dba40b441a65d8566e2013256612a15d27a4 Mon Sep 17 00:00:00 2001
From: "Havvy (Ryan Scheel)" <ryan.havvy@gmail.com>
Date: Sun, 9 Sep 2018 22:07:17 -0700
Subject: [PATCH] Slice total example: Move closer to total defn

---
 src/liballoc/slice.rs    | 15 +++++++++------
 src/libcore/slice/mod.rs | 15 +++++++++------
 2 files changed, 18 insertions(+), 12 deletions(-)

diff --git a/src/liballoc/slice.rs b/src/liballoc/slice.rs
index ad47eb4b70bb8..0802dc3e50073 100644
--- a/src/liballoc/slice.rs
+++ b/src/liballoc/slice.rs
@@ -218,6 +218,15 @@ impl<T> [T] {
     /// * total and antisymmetric: exactly one of a < b, a == b or a > b is true; and
     /// * transitive, a < b and b < c implies a < c. The same must hold for both == and >.
     ///
+    /// For example, while `f64` doesn't implement `Ord` because `NaN != NaN`, we can use
+    /// `partial_cmp` as our sort function when we know the slice doesn't contain a `NaN`.
+    ///
+    /// ```
+    /// let mut floats = [5f64, 4.0, 1.0, 3.0, 2.0];
+    /// floats.sort_by(|a, b| a.partial_cmp(b).unwrap());
+    /// assert_eq!(floats, [1.0, 2.0, 3.0, 4.0, 5.0]);
+    /// ```
+    ///
     /// When applicable, unstable sorting is preferred because it is generally faster than stable
     /// sorting and it doesn't allocate auxiliary memory.
     /// See [`sort_unstable_by`](#method.sort_unstable_by).
@@ -242,12 +251,6 @@ impl<T> [T] {
     /// // reverse sorting
     /// v.sort_by(|a, b| b.cmp(a));
     /// assert!(v == [5, 4, 3, 2, 1]);
-    ///
-    /// // While f64 doesn't implement Ord because NaN != NaN, we can use
-    /// // partial_cmp here because we know none of the elements are NaN.
-    /// let mut floats = [5f64, 4.0, 1.0, 3.0, 2.0];
-    /// floats.sort_by(|a, b| a.partial_cmp(b).unwrap());
-    /// assert_eq!(floats, [1.0, 2.0, 3.0, 4.0, 5.0]);
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
     #[inline]
diff --git a/src/libcore/slice/mod.rs b/src/libcore/slice/mod.rs
index a6e0389e66f1d..f6695d876f8d6 100644
--- a/src/libcore/slice/mod.rs
+++ b/src/libcore/slice/mod.rs
@@ -1346,6 +1346,15 @@ impl<T> [T] {
     /// * total and antisymmetric: exactly one of a < b, a == b or a > b is true; and
     /// * transitive, a < b and b < c implies a < c. The same must hold for both == and >.
     ///
+    /// For example, while `f64` doesn't implement `Ord` because `NaN != NaN`, we can use
+    /// `partial_cmp` as our sort function when we know the slice doesn't contain a `NaN`.
+    ///
+    /// ```
+    /// let mut floats = [5f64, 4.0, 1.0, 3.0, 2.0];
+    /// floats.sort_by(|a, b| a.partial_cmp(b).unwrap());
+    /// assert_eq!(floats, [1.0, 2.0, 3.0, 4.0, 5.0]);
+    /// ```
+    ///
     /// # Current implementation
     ///
     /// The current algorithm is based on [pattern-defeating quicksort][pdqsort] by Orson Peters,
@@ -1367,12 +1376,6 @@ impl<T> [T] {
     /// // reverse sorting
     /// v.sort_unstable_by(|a, b| b.cmp(a));
     /// assert!(v == [5, 4, 3, 2, 1]);
-    ///
-    /// // While f64 doesn't implement Ord because NaN != NaN, we can use
-    /// // partial_cmp here because we know none of the elements are NaN.
-    /// let mut floats = [5f64, 4.0, 1.0, 3.0, 2.0];
-    /// floats.sort_unstable_by(|a, b| a.partial_cmp(b).unwrap());
-    /// assert_eq!(floats, [1.0, 2.0, 3.0, 4.0, 5.0]);
     /// ```
     ///
     /// [pdqsort]: https://github.com/orlp/pdqsort