std::vec: make the sorting closure use Ordering rather than just being

(implicitly) less_eq.

Author: huonw

src/libextra/glob.rs

@@ -148,7 +148,7 @@ impl Iterator<Path> for GlobIterator {
 fn list_dir_sorted(path: &Path) -> ~[Path] {
     match io::result(|| fs::readdir(path)) {
         Ok(mut children) => {
-            children.sort_by(|p1, p2| p2.filename() <= p1.filename());
+            children.sort_by(|p1, p2| p2.filename().cmp(&p1.filename()));
             children
         }
         Err(..) => ~[]

src/libextra/priority_queue.rs

@@ -231,11 +231,7 @@ mod tests {
     fn test_top_and_pop() {
         let data = ~[2u, 4, 6, 2, 1, 8, 10, 3, 5, 7, 0, 9, 1];
         let mut sorted = data.clone();
-<<<<<<< HEAD
-        sorted.sort(|x, y| x.le(y));
-=======
         sorted.sort();
->>>>>>> 9ceda35... std::vec: add a sugary .sort() method for plain Ord sorting.
         let mut heap = PriorityQueue::from_vec(data);
         while !heap.is_empty() {
             assert_eq!(heap.top(), sorted.last());

src/libextra/stats.rs

@@ -19,6 +19,25 @@ use std::util;
 // NB: this can probably be rewritten in terms of num::Num
 // to be less f64-specific.
 
+fn f64_cmp(x: f64, y: f64) -> Ordering {
+    // arbitrarily decide that NaNs are larger than everything.
+    if y.is_nan() {
+        Less
+    } else if x.is_nan() {
+        Greater
+    } else if x < y {
+        Less
+    } else if x == y {
+        Equal
+    } else {
+        Greater
+    }
+}
+
+fn f64_sort(v: &mut [f64]) {
+    v.sort_by(|x: &f64, y: &f64| f64_cmp(*x, *y));
+}
+
 /// Trait that provides simple descriptive statistics on a univariate set of numeric samples.
 pub trait Stats {
 
@@ -239,13 +258,13 @@ impl<'a> Stats for &'a [f64] {
 
     fn percentile(self, pct: f64) -> f64 {
         let mut tmp = self.to_owned();
-        tmp.sort();
+        f64_sort(tmp);
         percentile_of_sorted(tmp, pct)
     }
 
     fn quartiles(self) -> (f64,f64,f64) {
         let mut tmp = self.to_owned();
-        tmp.sort();
+        f64_sort(tmp);
         let a = percentile_of_sorted(tmp, 25.0);
         let b = percentile_of_sorted(tmp, 50.0);
         let c = percentile_of_sorted(tmp, 75.0);
@@ -290,7 +309,7 @@ fn percentile_of_sorted(sorted_samples: &[f64],
 /// See: http://en.wikipedia.org/wiki/Winsorising
 pub fn winsorize(samples: &mut [f64], pct: f64) {
     let mut tmp = samples.to_owned();
-    tmp.sort();
+    f64_sort(tmp);
     let lo = percentile_of_sorted(tmp, pct);
     let hi = percentile_of_sorted(tmp, 100.0-pct);
     for samp in samples.mut_iter() {

src/libextra/test.rs

@@ -837,10 +837,7 @@ pub fn filter_tests(
     };
 
     // Sort the tests alphabetically
-    fn lteq(t1: &TestDescAndFn, t2: &TestDescAndFn) -> bool {
-        t1.desc.name.to_str() <= t2.desc.name.to_str()
-    }
-    filtered.sort_by(lteq);
+    filtered.sort_by(|t1, t2| t1.desc.name.to_str().cmp(&t2.desc.name.to_str()));
 
     // Shard the remaining tests, if sharding requested.
     match opts.test_shard {

src/librustc/metadata/cstore.rs

@@ -167,7 +167,7 @@ pub fn find_extern_mod_stmt_cnum(cstore: &CStore,
     cstore.extern_mod_crate_map.find(&emod_id).map(|x| *x)
 }
 
-#[deriving(Clone)]
+#[deriving(Clone, TotalEq, TotalOrd)]
 struct crate_hash {
     name: @str,
     vers: @str,

src/librustc/metadata/encoder.rs

@@ -1531,7 +1531,7 @@ fn encode_crate_deps(ecx: &EncodeContext,
         });
 
         // Sort by cnum
-        deps.sort_by(|kv1, kv2| kv1.cnum <= kv2.cnum);
+        deps.sort_by(|kv1, kv2| kv1.cnum.cmp(&kv2.cnum));
 
         // Sanity-check the crate numbers
         let mut expected_cnum = 1;

src/librustc/middle/check_match.rs

@@ -466,9 +466,9 @@ fn missing_ctor(cx: &MatchCheckCtxt,
         // those with a destructured slice come first.
         vec_pat_lens.sort_by(|&(len1, slice1), &(len2, slice2)| {
                     if len1 == len2 {
-                        slice1 > slice2
+                        slice2.cmp(&slice1)
                     } else {
-                        len1 <= len2
+                        len1.cmp(&len2)
                     }
                 });
         vec_pat_lens.dedup();

src/librustc/middle/lint.rs

@@ -63,7 +63,7 @@ use syntax::{ast, ast_util, visit};
 use syntax::ast_util::IdVisitingOperation;
 use syntax::visit::Visitor;
 
-#[deriving(Clone, Eq)]
+#[deriving(Clone, Eq, Ord, TotalEq, TotalOrd)]
 pub enum lint {
     ctypes,
     unused_imports,
@@ -110,20 +110,16 @@ pub fn level_to_str(lv: level) -> &'static str {
     }
 }
 
-#[deriving(Clone, Eq, Ord)]
+#[deriving(Clone, Eq, Ord, TotalEq, TotalOrd)]
 pub enum level {
     allow, warn, deny, forbid
 }
 
-#[deriving(Clone, Eq)]
+#[deriving(Clone, Eq, Ord, TotalEq, TotalOrd)]
 pub struct LintSpec {
+    default: level,
     lint: lint,
     desc: &'static str,
-    default: level
-}
-
-impl Ord for LintSpec {
-    fn lt(&self, other: &LintSpec) -> bool { self.default < other.default }
 }
 
 pub type LintDict = HashMap<&'static str, LintSpec>;

src/librustc/middle/trans/base.rs

@@ -3163,7 +3163,7 @@ pub fn trans_crate(sess: session::Session,
         println!("n_closures: {}", ccx.stats.n_closures);
         println("fn stats:");
 
-        ccx.stats.fn_stats.sort_by(|&(_, _, insns_a), &(_, _, insns_b)| insns_a >= insns_b);
+        ccx.stats.fn_stats.sort_by(|&(_, _, insns_a), &(_, _, insns_b)| insns_b.cmp(&insns_a));
 
         for tuple in ccx.stats.fn_stats.iter() {
             match *tuple {

src/librustdoc/html/render.rs

@@ -898,44 +898,44 @@ fn item_module(w: &mut Writer, cx: &Context,
     debug!("{:?}", items);
     let mut indices = vec::from_fn(items.len(), |i| i);
 
-    fn le(i1: &clean::Item, i2: &clean::Item, idx1: uint, idx2: uint) -> bool {
+    fn cmp(i1: &clean::Item, i2: &clean::Item, idx1: uint, idx2: uint) -> Ordering {
         if shortty(i1) == shortty(i2) {
-            return i1.name <= i2.name;
+            return i1.name.cmp(&i2.name);
         }
         match (&i1.inner, &i2.inner) {
             (&clean::ViewItemItem(ref a), &clean::ViewItemItem(ref b)) => {
                 match (&a.inner, &b.inner) {
-                    (&clean::ExternMod(..), _) => true,
-                    (_, &clean::ExternMod(..)) => false,
-                    _ => idx1 <= idx2,
+                    (&clean::ExternMod(..), _) => Less,
+                    (_, &clean::ExternMod(..)) => Greater,
+                    _ => idx1.cmp(&idx2),
                 }
             }
-            (&clean::ViewItemItem(..), _) => true,
-            (_, &clean::ViewItemItem(..)) => false,
-            (&clean::ModuleItem(..), _) => true,
-            (_, &clean::ModuleItem(..)) => false,
-            (&clean::StructItem(..), _) => true,
-            (_, &clean::StructItem(..)) => false,
-            (&clean::EnumItem(..), _) => true,
-            (_, &clean::EnumItem(..)) => false,
-            (&clean::StaticItem(..), _) => true,
-            (_, &clean::StaticItem(..)) => false,
-            (&clean::ForeignFunctionItem(..), _) => true,
-            (_, &clean::ForeignFunctionItem(..)) => false,
-            (&clean::ForeignStaticItem(..), _) => true,
-            (_, &clean::ForeignStaticItem(..)) => false,
-            (&clean::TraitItem(..), _) => true,
-            (_, &clean::TraitItem(..)) => false,
-            (&clean::FunctionItem(..), _) => true,
-            (_, &clean::FunctionItem(..)) => false,
-            (&clean::TypedefItem(..), _) => true,
-            (_, &clean::TypedefItem(..)) => false,
-            _ => idx1 <= idx2,
+            (&clean::ViewItemItem(..), _) => Less,
+            (_, &clean::ViewItemItem(..)) => Greater,
+            (&clean::ModuleItem(..), _) => Less,
+            (_, &clean::ModuleItem(..)) => Greater,
+            (&clean::StructItem(..), _) => Less,
+            (_, &clean::StructItem(..)) => Greater,
+            (&clean::EnumItem(..), _) => Less,
+            (_, &clean::EnumItem(..)) => Greater,
+            (&clean::StaticItem(..), _) => Less,
+            (_, &clean::StaticItem(..)) => Greater,
+            (&clean::ForeignFunctionItem(..), _) => Less,
+            (_, &clean::ForeignFunctionItem(..)) => Greater,
+            (&clean::ForeignStaticItem(..), _) => Less,
+            (_, &clean::ForeignStaticItem(..)) => Greater,
+            (&clean::TraitItem(..), _) => Less,
+            (_, &clean::TraitItem(..)) => Greater,
+            (&clean::FunctionItem(..), _) => Less,
+            (_, &clean::FunctionItem(..)) => Greater,
+            (&clean::TypedefItem(..), _) => Less,
+            (_, &clean::TypedefItem(..)) => Greater,
+            _ => idx1.cmp(&idx2),
         }
     }
 
     debug!("{:?}", indices);
-    indices.sort_by(|&i1, &i2| le(&items[i1], &items[i2], i1, i2));
+    indices.sort_by(|&i1, &i2| cmp(&items[i1], &items[i2], i1, i2));
 
     debug!("{:?}", indices);
     let mut curty = "";
@@ -1530,7 +1530,7 @@ fn build_sidebar(m: &clean::Module) -> HashMap<~str, ~[~str]> {
     }
 
     for (_, items) in map.mut_iter() {
-        items.sort(|i1, i2| i1 <= i2);
+        items.sort();
     }
     return map;
 }

src/libstd/prelude.rs

@@ -79,7 +79,8 @@ pub use tuple::{Tuple1, Tuple2, Tuple3, Tuple4};
 pub use tuple::{Tuple5, Tuple6, Tuple7, Tuple8};
 pub use tuple::{Tuple9, Tuple10, Tuple11, Tuple12};
 pub use vec::{ImmutableEqVector, ImmutableTotalOrdVector, ImmutableCopyableVector};
-pub use vec::{OwnedVector, OwnedCopyableVector,OwnedEqVector, MutableVector, MutableOrdVector};
+pub use vec::{OwnedVector, OwnedCopyableVector,OwnedEqVector};
+pub use vec::{MutableVector, MutableTotalOrdVector};
 pub use vec::{Vector, VectorVector, CopyableVector, ImmutableVector};
 
 // Reexported runtime types