extra: remove sort in favour of the std method.

Fixes #9676.

6 files changed, 17 insertions, 1203 deletions

diff --git a/src/libextra/glob.rs b/src/libextra/glob.rs
index e398a10ecf1..75795d13991 100644
--- a/src/libextra/glob.rs
+++ b/src/libextra/glob.rs
@@ -28,8 +28,6 @@ use std::io;
 use std::io::fs;
 use std::path::is_sep;
 
-use sort;
-
 /**
  * An iterator that yields Paths from the filesystem that match a particular
  * pattern - see the `glob` function for more details.
@@ -149,9 +147,8 @@ impl Iterator<Path> for GlobIterator {
 
 fn list_dir_sorted(path: &Path) -> ~[Path] {
     match io::result(|| fs::readdir(path)) {
-        Ok(children) => {
-            let mut children = children;
-            sort::quick_sort(children, |p1, p2| p2.filename() <= p1.filename());
+        Ok(mut children) => {
+            children.sort(|p1, p2| p2.filename() <= p1.filename());
             children
         }
         Err(..) => ~[]
@@ -771,4 +768,3 @@ mod test {
         assert!(Pattern::new("a/b").matches_path(&Path::new("a/b")));
     }
 }
-
diff --git a/src/libextra/lib.rs b/src/libextra/lib.rs
index 82ca4d65b23..51e105d23f7 100644
--- a/src/libextra/lib.rs
+++ b/src/libextra/lib.rs
@@ -61,8 +61,6 @@ pub mod ringbuf;
 pub mod priority_queue;
 pub mod smallintmap;
 
-pub mod sort;
-
 pub mod dlist;
 pub mod treemap;
 pub mod btree;
diff --git a/src/libextra/priority_queue.rs b/src/libextra/priority_queue.rs
index 77d1c5cdcf4..d2cace5e6f4 100644
--- a/src/libextra/priority_queue.rs
+++ b/src/libextra/priority_queue.rs
@@ -213,7 +213,6 @@ impl<T: Ord> Extendable<T> for PriorityQueue<T> {
 
 #[cfg(test)]
 mod tests {
-    use sort::merge_sort;
     use priority_queue::PriorityQueue;
 
     #[test]
@@ -231,7 +230,8 @@ mod tests {
     #[test]
     fn test_top_and_pop() {
         let data = ~[2u, 4, 6, 2, 1, 8, 10, 3, 5, 7, 0, 9, 1];
-        let mut sorted = merge_sort(data, |x, y| x.le(y));
+        let mut sorted = data.clone();
+        sorted.sort(|x, y| x.le(y));
         let mut heap = PriorityQueue::from_vec(data);
         while !heap.is_empty() {
             assert_eq!(heap.top(), sorted.last());
@@ -311,11 +311,14 @@ mod tests {
         assert_eq!(heap.len(), 5);
     }
 
-    fn check_to_vec(data: ~[int]) {
+    fn check_to_vec(mut data: ~[int]) {
         let heap = PriorityQueue::from_vec(data.clone());
-        assert_eq!(merge_sort(heap.clone().to_vec(), |x, y| x.le(y)),
-                   merge_sort(data, |x, y| x.le(y)));
-        assert_eq!(heap.to_sorted_vec(), merge_sort(data, |x, y| x.le(y)));
+        let mut v = heap.clone().to_vec();
+        v.sort(|x, y| x.le(y));
+        data.sort(|x, y| x.le(y));
+
+        assert_eq!(v, data);
+        assert_eq!(heap.to_sorted_vec(), data);
     }
 
     #[test]
diff --git a/src/libextra/sort.rs b/src/libextra/sort.rs
deleted file mode 100644
index bba26a16d4d..00000000000
--- a/src/libextra/sort.rs
+++ /dev/null
@@ -1,1181 +0,0 @@
-// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-//! Sorting methods
-
-
-use std::cmp::{Eq, Ord};
-use std::util::swap;
-use std::vec;
-
-type Le<'a, T> = 'a |v1: &T, v2: &T| -> bool;
-
-/**
- * Merge sort. Returns a new vector containing the sorted list.
- *
- * Has worst case O(n log n) performance, best case O(n), but
- * is not space efficient. This is a stable sort.
- */
-pub fn merge_sort<T:Clone>(v: &[T], le: Le<T>) -> ~[T] {
-    type Slice = (uint, uint);
-
-    return merge_sort_(v, (0u, v.len()), le);
-
-    fn merge_sort_<T:Clone>(v: &[T], slice: Slice, le: Le<T>) -> ~[T] {
-        let begin = slice.first();
-        let end = slice.second();
-
-        let v_len = end - begin;
-        if v_len == 0 { return ~[]; }
-        if v_len == 1 { return ~[v[begin].clone()]; }
-
-        let mid = v_len / 2 + begin;
-        let a = (begin, mid);
-        let b = (mid, end);
-        return merge(|x,y| le(x,y), merge_sort_(v, a, |x,y| le(x,y)),
-                                    merge_sort_(v, b, |x,y| le(x,y)));
-    }
-
-    fn merge<T:Clone>(le: Le<T>, a: &[T], b: &[T]) -> ~[T] {
-        let mut rs = vec::with_capacity(a.len() + b.len());
-        let a_len = a.len();
-        let mut a_ix = 0;
-        let b_len = b.len();
-        let mut b_ix = 0;
-        while a_ix < a_len && b_ix < b_len {
-            if le(&a[a_ix], &b[b_ix]) {
-                rs.push(a[a_ix].clone());
-                a_ix += 1;
-            } else {
-                rs.push(b[b_ix].clone());
-                b_ix += 1;
-            }
-        }
-        rs.push_all(a.slice(a_ix, a_len));
-        rs.push_all(b.slice(b_ix, b_len));
-        rs
-    }
-}
-
-fn part<T>(arr: &mut [T], left: uint,
-           right: uint, pivot: uint, compare_func: Le<T>) -> uint {
-    arr.swap(pivot, right);
-    let mut storage_index: uint = left;
-    let mut i: uint = left;
-    while i < right {
-        if compare_func(&arr[i], &arr[right]) {
-            arr.swap(i, storage_index);
-            storage_index += 1;
-        }
-        i += 1;
-    }
-    arr.swap(storage_index, right);
-    return storage_index;
-}
-
-fn qsort<T>(arr: &mut [T], left: uint,
-            right: uint, compare_func: Le<T>) {
-    if right > left {
-        let pivot = (left + right) / 2u;
-        let new_pivot = part::<T>(arr, left, right, pivot, |x,y| compare_func(x,y));
-        if new_pivot != 0u {
-            // Need to do this check before recursing due to overflow
-            qsort::<T>(arr, left, new_pivot - 1u, |x,y| compare_func(x,y));
-        }
-        qsort::<T>(arr, new_pivot + 1u, right, compare_func);
-    }
-}
-
-/**
- * Quicksort. Sorts a mut vector in place.
- *
- * Has worst case O(n^2) performance, average case O(n log n).
- * This is an unstable sort.
- */
-pub fn quick_sort<T>(arr: &mut [T], compare_func: Le<T>) {
-    let len = arr.len();
-    if len == 0u { return; }
-    qsort::<T>(arr, 0u, len - 1u, compare_func);
-}
-
-fn qsort3<T:Clone + Ord + Eq>(arr: &mut [T], left: int, right: int) {
-    if right <= left { return; }
-    let v: T = arr[right].clone();
-    let mut i: int = left - 1;
-    let mut j: int = right;
-    let mut p: int = i;
-    let mut q: int = j;
-    loop {
-        i += 1;
-        while arr[i] < v { i += 1; }
-        j -= 1;
-        while v < arr[j] {
-            if j == left { break; }
-            j -= 1;
-        }
-        if i >= j { break; }
-        arr.swap(i as uint, j as uint);
-        if arr[i] == v {
-            p += 1;
-            arr.swap(p as uint, i as uint);
-        }
-        if v == arr[j] {
-            q -= 1;
-            arr.swap(j as uint, q as uint);
-        }
-    }
-    arr.swap(i as uint, right as uint);
-    j = i - 1;
-    i += 1;
-    let mut k: int = left;
-    while k < p {
-        arr.swap(k as uint, j as uint);
-        k += 1;
-        j -= 1;
-        if k == arr.len() as int { break; }
-    }
-    k = right - 1;
-    while k > q {
-        arr.swap(i as uint, k as uint);
-        k -= 1;
-        i += 1;
-        if k == 0 { break; }
-    }
-    qsort3::<T>(arr, left, j);
-    qsort3::<T>(arr, i, right);
-}
-
-/**
- * Fancy quicksort. Sorts a mut vector in place.
- *
- * Based on algorithm presented by ~[Sedgewick and Bentley]
- * (http://www.cs.princeton.edu/~rs/talks/QuicksortIsOptimal.pdf).
- * According to these slides this is the algorithm of choice for
- * 'randomly ordered keys, abstract compare' & 'small number of key values'.
- *
- * This is an unstable sort.
- */
-pub fn quick_sort3<T:Clone + Ord + Eq>(arr: &mut [T]) {
-    if arr.len() <= 1 { return; }
-    let len = arr.len(); // FIXME(#5074) nested calls
-    qsort3(arr, 0, (len - 1) as int);
-}
-
-#[allow(missing_doc)]
-pub trait Sort {
-    fn qsort(self);
-}
-
-impl<'a, T:Clone + Ord + Eq> Sort for &'a mut [T] {
-    fn qsort(self) { quick_sort3(self); }
-}
-
-static MIN_MERGE: uint = 64;
-static MIN_GALLOP: uint = 7;
-
-#[allow(missing_doc)]
-pub fn tim_sort<T:Clone + Ord>(array: &mut [T]) {
-    let size = array.len();
-    if size < 2 {
-        return;
-    }
-
-    if size < MIN_MERGE {
-        let init_run_len = count_run_ascending(array);
-        binarysort(array, init_run_len);
-        return;
-    }
-
-    let mut ms = MergeState();
-    let min_run = min_run_length(size);
-
-    let mut idx = 0;
-    let mut remaining = size;
-    loop {
-        let run_len: uint = {
-            // This scope contains the slice `arr` here:
-            let arr = array.mut_slice(idx, size);
-            let mut run_len: uint = count_run_ascending(arr);
-
-            if run_len < min_run {
-                let force = if remaining <= min_run {remaining} else {min_run};
-                let slice = arr.mut_slice(0, force);
-                binarysort(slice, run_len);
-                run_len = force;
-            }
-
-            run_len
-        };
-
-        ms.push_run(idx, run_len);
-        ms.merge_collapse(array);
-
-        idx += run_len;
-        remaining -= run_len;
-        if remaining == 0 { break; }
-    }
-
-    ms.merge_force_collapse(array);
-}
-
-fn binarysort<T:Clone + Ord>(array: &mut [T], start: uint) {
-    let size = array.len();
-    let mut start = start;
-    assert!(start <= size);
-
-    if start == 0 { start += 1; }
-
-    while start < size {
-        let pivot = array[start].clone();
-        let mut left = 0;
-        let mut right = start;
-        assert!(left <= right);
-
-        while left < right {
-            let mid = (left + right) >> 1;
-            if pivot < array[mid] {
-                right = mid;
-            } else {
-                left = mid+1;
-            }
-        }
-        assert_eq!(left, right);
-        let n = start-left;
-
-        shift_vec(array, left+1, left, n);
-        array[left] = pivot;
-        start += 1;
-    }
-}
-
-// Reverse the order of elements in a slice, in place
-fn reverse_slice<T>(v: &mut [T], start: uint, end:uint) {
-    let mut i = start;
-    while i < end / 2 {
-        v.swap(i, end - i - 1);
-        i += 1;
-    }
-}
-
-fn min_run_length(n: uint) -> uint {
-    let mut n = n;
-    let mut r = 0;   // becomes 1 if any 1 bits are shifted off
-
-    while n >= MIN_MERGE {
-        r |= n & 1;
-        n >>= 1;
-    }
-    return n + r;
-}
-
-fn count_run_ascending<T:Clone + Ord>(array: &mut [T]) -> uint {
-    let size = array.len();
-    assert!(size > 0);
-    if size == 1 { return 1; }
-
-    let mut run = 2;
-    if array[1] < array[0] {
-        while run < size && array[run] < array[run-1] {
-            run += 1;
-        }
-        reverse_slice(array, 0, run);
-    } else {
-        while run < size && array[run] >= array[run-1] {
-            run += 1;
-        }
-    }
-
-    return run;
-}
-
-fn gallop_left<T:Clone + Ord>(key: &T,
-                             array: &[T],
-                             hint: uint)
-                          -> uint {
-    let size = array.len();
-    assert!(size != 0 && hint < size);
-
-    let mut last_ofs = 0;
-    let mut ofs = 1;
-
-    if *key > array[hint] {
-        // Gallop right until array[hint+last_ofs] < key <= array[hint+ofs]
-        let max_ofs = size - hint;
-        while ofs < max_ofs && *key > array[hint+ofs] {
-            last_ofs = ofs;
-            ofs = (ofs << 1) + 1;
-            if ofs < last_ofs { ofs = max_ofs; } // uint overflow guard
-        }
-        if ofs > max_ofs { ofs = max_ofs; }
-
-        last_ofs += hint;
-        ofs += hint;
-    } else {
-        let max_ofs = hint + 1;
-        while ofs < max_ofs && *key <= array[hint-ofs] {
-            last_ofs = ofs;
-            ofs = (ofs << 1) + 1;
-            if ofs < last_ofs { ofs = max_ofs; } // uint overflow guard
-        }
-
-        if ofs > max_ofs { ofs = max_ofs; }
-
-        let tmp = last_ofs;
-        last_ofs = hint - ofs;
-        ofs = hint - tmp;
-    }
-    assert!((last_ofs < ofs || last_ofs+1 < ofs+1) && ofs <= size);
-
-    last_ofs += 1;
-    while last_ofs < ofs {
-        let m = last_ofs + ((ofs - last_ofs) >> 1);
-        if *key > array[m] {
-            last_ofs = m+1;
-        } else {
-            ofs = m;
-        }
-    }
-    assert_eq!(last_ofs, ofs);
-    return ofs;
-}
-
-fn gallop_right<T:Clone + Ord>(key: &T,
-                              array: &[T],
-                              hint: uint)
-                           -> uint {
-    let size = array.len();
-    assert!(size != 0 && hint < size);
-
-    let mut last_ofs = 0;
-    let mut ofs = 1;
-
-    if *key >= array[hint] {
-        // Gallop right until array[hint+last_ofs] <= key < array[hint+ofs]
-        let max_ofs = size - hint;
-        while ofs < max_ofs && *key >= array[hint+ofs] {
-            last_ofs = ofs;
-            ofs = (ofs << 1) + 1;
-            if ofs < last_ofs { ofs = max_ofs; }
-        }
-        if ofs > max_ofs { ofs = max_ofs; }
-
-        last_ofs += hint;
-        ofs += hint;
-    } else {
-        // Gallop left until array[hint-ofs] <= key < array[hint-last_ofs]
-        let max_ofs = hint + 1;
-        while ofs < max_ofs && *key < array[hint-ofs] {
-            last_ofs = ofs;
-            ofs = (ofs << 1) + 1;
-            if ofs < last_ofs { ofs = max_ofs; }
-        }
-        if ofs > max_ofs { ofs = max_ofs; }
-
-        let tmp = last_ofs;
-        last_ofs = hint - ofs;
-        ofs = hint - tmp;
-    }
-
-    assert!((last_ofs < ofs || last_ofs+1 < ofs+1) && ofs <= size);
-
-    last_ofs += 1;
-    while last_ofs < ofs {
-        let m = last_ofs + ((ofs - last_ofs) >> 1);
-
-        if *key >= array[m] {
-            last_ofs = m + 1;
-        } else {
-            ofs = m;
-        }
-    }
-    assert_eq!(last_ofs, ofs);
-    return ofs;
-}
-
-struct RunState {
-    base: uint,
-    len: uint,
-}
-
-struct MergeState<T> {
-    min_gallop: uint,
-    runs: ~[RunState],
-}
-
-// Fixme (#3853) Move into MergeState
-fn MergeState<T>() -> MergeState<T> {
-    MergeState {
-        min_gallop: MIN_GALLOP,
-        runs: ~[],
-    }
-}
-
-impl<T:Clone + Ord> MergeState<T> {
-    fn push_run(&mut self, run_base: uint, run_len: uint) {
-        let tmp = RunState{base: run_base, len: run_len};
-        self.runs.push(tmp);
-    }
-
-    fn merge_at(&mut self, n: uint, array: &mut [T]) {
-        let size = self.runs.len();
-        assert!(size >= 2);
-        assert!(n == size-2 || n == size-3);
-
-        let mut b1 = self.runs[n].base;
-        let mut l1 = self.runs[n].len;
-        let b2 = self.runs[n+1].base;
-        let l2 = self.runs[n+1].len;
-
-        assert!(l1 > 0 && l2 > 0);
-        assert_eq!(b1 + l1, b2);
-
-        self.runs[n].len = l1 + l2;
-        if n == size-3 {
-            self.runs[n+1].base = self.runs[n+2].base;
-            self.runs[n+1].len = self.runs[n+2].len;
-        }
-
-        let k = { // constrain lifetime of slice below
-            let slice = array.slice(b1, b1+l1);
-            gallop_right(&array[b2], slice, 0)
-        };
-        b1 += k;
-        l1 -= k;
-        if l1 != 0 {
-            let l2 = { // constrain lifetime of slice below
-                let slice = array.slice(b2, b2+l2);
-                gallop_left(&array[b1+l1-1],slice,l2-1)
-            };
-            if l2 > 0 {
-                if l1 <= l2 {
-                    self.merge_lo(array, b1, l1, b2, l2);
-                } else {
-                    self.merge_hi(array, b1, l1, b2, l2);
-                }
-            }
-        }
-        self.runs.pop();
-    }
-
-    fn merge_lo(&mut self, array: &mut [T], base1: uint, len1: uint,
-                base2: uint, len2: uint) {
-        assert!(len1 != 0 && len2 != 0 && base1+len1 == base2);
-
-        let mut tmp = array.slice(base1, base1 + len1).to_owned();
-
-        let mut c1 = 0;
-        let mut c2 = base2;
-        let mut dest = base1;
-        let mut len1 = len1;
-        let mut len2 = len2;
-
-        array.swap(dest, c2);
-        dest += 1; c2 += 1; len2 -= 1;
-
-        if len2 == 0 {
-            copy_vec(array, dest, tmp.slice(0, len1));
-            return;
-        }
-        if len1 == 1 {
-            shift_vec(array, dest, c2, len2);
-            swap(&mut tmp[c1], &mut array[dest+len2]);
-            return;
-        }
-
-        let mut min_gallop = self.min_gallop;
-        loop {
-            let mut count1 = 0;
-            let mut count2 = 0;
-            let mut break_outer = false;
-
-            loop {
-                assert!(len1 > 1 && len2 != 0);
-                if array[c2] < tmp[c1] {
-                    array.swap(dest, c2);
-                    dest += 1; c2 += 1; len2 -= 1;
-                    count2 += 1; count1 = 0;
-                    if len2 == 0 {
-                        break_outer = true;
-                    }
-                } else {
-                    swap(&mut array[dest], &mut tmp[c1]);
-                    dest += 1; c1 += 1; len1 -= 1;
-                    count1 += 1; count2 = 0;
-                    if len1 == 1 {
-                        break_outer = true;
-                    }
-                }
-                if break_outer || ((count1 | count2) >= min_gallop) {
-                    break;
-                }
-            }
-            if break_outer { break; }
-
-            // Start to gallop
-            loop {
-                assert!(len1 > 1 && len2 != 0);
-
-                count1 = {
-                    let tmp_view = tmp.slice(c1, c1+len1);
-                    gallop_right(&array[c2], tmp_view, 0)
-                };
-                if count1 != 0 {
-                    copy_vec(array, dest, tmp.slice(c1, c1+count1));
-                    dest += count1; c1 += count1; len1 -= count1;
-                    if len1 <= 1 { break_outer = true; break; }
-                }
-                array.swap(dest, c2);
-                dest += 1; c2 += 1; len2 -= 1;
-                if len2 == 0 { break_outer = true; break; }
-
-                count2 = {
-                    let tmp_view = array.slice(c2, c2+len2);
-                    gallop_left(&tmp[c1], tmp_view, 0)
-                };
-                if count2 != 0 {
-                    shift_vec(array, dest, c2, count2);
-                    dest += count2; c2 += count2; len2 -= count2;
-                    if len2 == 0 { break_outer = true; break; }
-                }
-                swap(&mut array[dest], &mut tmp[c1]);
-                dest += 1; c1 += 1; len1 -= 1;
-                if len1 == 1 { break_outer = true; break; }
-                min_gallop -= 1;
-                if !(count1 >= MIN_GALLOP || count2 >= MIN_GALLOP) {
-                    break;
-                }
-            }
-            if break_outer { break; }
-            if min_gallop < 0 { min_gallop = 0; }
-            min_gallop += 2; // Penalize for leaving gallop
-        }
-        self.min_gallop = if min_gallop < 1 { 1 } else { min_gallop };
-
-        if len1 == 1 {
-            assert!(len2 > 0);
-            shift_vec(array, dest, c2, len2);
-            swap(&mut array[dest+len2], &mut tmp[c1]);
-        } else if len1 == 0 {
-            fail!("Comparison violates its contract!");
-        } else {
-            assert_eq!(len2, 0);
-            assert!(len1 > 1);
-            copy_vec(array, dest, tmp.slice(c1, c1+len1));
-        }
-    }
-
-    fn merge_hi(&mut self, array: &mut [T], base1: uint, len1: uint,
-                base2: uint, len2: uint) {
-        assert!(len1 != 1 && len2 != 0 && base1 + len1 == base2);
-
-        let mut tmp = array.slice(base2, base2 + len2).to_owned();
-
-        let mut c1 = base1 + len1 - 1;
-        let mut c2 = len2 - 1;
-        let mut dest = base2 + len2 - 1;
-        let mut len1 = len1;
-        let mut len2 = len2;
-
-        array.swap(dest, c1);
-        dest -= 1; c1 -= 1; len1 -= 1;
-
-        if len1 == 0 {
-            copy_vec(array, dest-(len2-1), tmp.slice(0, len2));
-            return;
-        }
-        if len2 == 1 {
-            dest -= len1;
-            c1 -= len1;
-            shift_vec(array, dest+1, c1+1, len1);
-            swap(&mut array[dest], &mut tmp[c2]);
-            return;
-        }
-
-        let mut min_gallop = self.min_gallop;
-        loop {
-            let mut count1 = 0;
-            let mut count2 = 0;
-            let mut break_outer = false;
-
-            loop {
-                assert!(len1 != 0 && len2 > 1);
-                if tmp[c2] < array[c1] {
-                    array.swap(dest, c1);
-                    dest -= 1; c1 -= 1; len1 -= 1;
-                    count1 += 1; count2 = 0;
-                    if len1 == 0 {
-                        break_outer = true;
-                    }
-                } else {
-                    swap(&mut array[dest], &mut tmp[c2]);
-                    dest -= 1; c2 -= 1; len2 -= 1;
-                    count2 += 1; count1 = 0;
-                    if len2 == 1 {
-                        break_outer = true;
-                    }
-                }
-                if break_outer || ((count1 | count2) >= min_gallop) {
-                    break;
-                }
-            }
-            if break_outer { break; }
-
-            // Start to gallop
-            loop {
-                assert!(len2 > 1 && len1 != 0);
-
-                { // constrain scope of tmp_view:
-                    let tmp_view = array.mut_slice(base1, base1+len1);
-                    count1 = len1 - gallop_right(
-                        &tmp[c2], tmp_view, len1-1);
-                }
-
-                if count1 != 0 {
-                    dest -= count1; c1 -= count1; len1 -= count1;
-                    shift_vec(array, dest+1, c1+1, count1);
-                    if len1 == 0 { break_outer = true; break; }
-                }
-
-                swap(&mut array[dest], &mut tmp[c2]);
-                dest -= 1; c2 -= 1; len2 -= 1;
-                if len2 == 1 { break_outer = true; break; }
-
-                let count2;
-                { // constrain scope of tmp_view
-                    let tmp_view = tmp.mut_slice(0, len2);
-                    count2 = len2 - gallop_left(&array[c1],
-                                                tmp_view,
-                                                len2-1);
-                }
-
-                if count2 != 0 {
-                    dest -= count2; c2 -= count2; len2 -= count2;
-                    copy_vec(array, dest+1, tmp.slice(c2+1, c2+1+count2));
-                    if len2 <= 1 { break_outer = true; break; }
-                }
-                array.swap(dest, c1);
-                dest -= 1; c1 -= 1; len1 -= 1;
-                if len1 == 0 { break_outer = true; break; }
-                min_gallop -= 1;
-                if !(count1 >= MIN_GALLOP || count2 >= MIN_GALLOP) {
-                    break;
-                }
-            }
-
-            if break_outer { break; }
-            if min_gallop < 0 { min_gallop = 0; }
-            min_gallop += 2; // Penalize for leaving gallop
-        }
-        self.min_gallop = if min_gallop < 1 { 1 } else { min_gallop };
-
-        if len2 == 1 {
-            assert!(len1 > 0);
-            dest -= len1;
-            c1 -= len1;
-            shift_vec(array, dest+1, c1+1, len1);
-            swap(&mut array[dest], &mut tmp[c2]);
-        } else if len2 == 0 {
-            fail!("Comparison violates its contract!");
-        } else {
-            assert_eq!(len1, 0);
-            assert!(len2 != 0);
-            copy_vec(array, dest-(len2-1), tmp.slice(0, len2));
-        }
-    }
-
-    fn merge_collapse(&mut self, array: &mut [T]) {
-        while self.runs.len() > 1 {
-            let mut n = self.runs.len()-2;
-            if n > 0 &&
-                self.runs[n-1].len <= self.runs[n].len + self.runs[n+1].len
-            {
-                if self.runs[n-1].len < self.runs[n+1].len { n -= 1; }
-            } else if self.runs[n].len <= self.runs[n+1].len {
-                /* keep going */
-            } else {
-                break;
-            }
-            self.merge_at(n, array);
-        }
-    }
-
-    fn merge_force_collapse(&mut self, array: &mut [T]) {
-        while self.runs.len() > 1 {
-            let mut n = self.runs.len()-2;
-            if n > 0 {
-                if self.runs[n-1].len < self.runs[n+1].len {
-                    n -= 1;
-                }
-            }
-            self.merge_at(n, array);
-        }
-    }
-}
-
-#[inline]
-fn copy_vec<T:Clone>(dest: &mut [T],
-                    s1: uint,
-                    from: &[T]) {
-    assert!(s1+from.len() <= dest.len());
-
-    for (i, v) in from.iter().enumerate() {
-        dest[s1+i] = (*v).clone();
-    }
-}
-
-#[inline]
-fn shift_vec<T:Clone>(dest: &mut [T], s1: uint, s2: uint, len: uint) {
-    assert!(s1+len <= dest.len());
-
-    let tmp = dest.slice(s2, s2+len).to_owned();
-    copy_vec(dest, s1, tmp);
-}
-
-#[cfg(test)]
-mod test_qsort3 {
-    use sort::*;
-
-
-    fn check_sort(v1: &mut [int], v2: &mut [int]) {
-        let len = v1.len();
-        quick_sort3::<int>(v1);
-        let mut i = 0;
-        while i < len {
-            assert_eq!(v2[i], v1[i]);
-            i += 1;
-        }
-    }
-
-    #[test]
-    fn test() {
-        {
-            let mut v1 = ~[3, 7, 4, 5, 2, 9, 5, 8];
-            let mut v2 = ~[2, 3, 4, 5, 5, 7, 8, 9];
-            check_sort(v1, v2);
-        }
-        {
-            let mut v1 = ~[1, 1, 1];
-            let mut v2 = ~[1, 1, 1];
-            check_sort(v1, v2);
-        }
-        {
-            let mut v1: ~[int] = ~[];
-            let mut v2: ~[int] = ~[];
-            check_sort(v1, v2);
-        }
-        { let mut v1 = ~[9]; let mut v2 = ~[9]; check_sort(v1, v2); }
-        {
-            let mut v1 = ~[9, 3, 3, 3, 9];
-            let mut v2 = ~[3, 3, 3, 9, 9];
-            check_sort(v1, v2);
-        }
-    }
-}
-
-#[cfg(test)]
-mod test_qsort {
-    use sort::*;
-
-    fn check_sort(v1: &mut [int], v2: &mut [int]) {
-        let len = v1.len();
-        fn leual(a: &int, b: &int) -> bool { *a <= *b }
-        quick_sort::<int>(v1, leual);
-        let mut i = 0u;
-        while i < len {
-            // debug!(v2[i]);
-            assert_eq!(v2[i], v1[i]);
-            i += 1;
-        }
-    }
-
-    #[test]
-    fn test() {
-        {
-            let mut v1 = ~[3, 7, 4, 5, 2, 9, 5, 8];
-            let mut v2 = ~[2, 3, 4, 5, 5, 7, 8, 9];
-            check_sort(v1, v2);
-        }
-        {
-            let mut v1 = ~[1, 1, 1];
-            let mut v2 = ~[1, 1, 1];
-            check_sort(v1, v2);
-        }
-        {
-            let mut v1: ~[int] = ~[];
-            let mut v2: ~[int] = ~[];
-            check_sort(v1, v2);
-        }
-        { let mut v1 = ~[9]; let mut v2 = ~[9]; check_sort(v1, v2); }
-        {
-            let mut v1 = ~[9, 3, 3, 3, 9];
-            let mut v2 = ~[3, 3, 3, 9, 9];
-            check_sort(v1, v2);
-        }
-    }
-
-    // Regression test for #750
-    #[test]
-    fn test_simple() {
-        let mut names = ~[2, 1, 3];
-
-        let expected = ~[1, 2, 3];
-
-        quick_sort(names, |x, y| *x < *y);
-
-        let immut_names = names;
-
-        for (&a, &b) in expected.iter().zip(immut_names.iter()) {
-            debug!("{} {}", a, b);
-            assert_eq!(a, b);
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-
-    use sort::*;
-
-    fn check_sort(v1: &[int], v2: &[int]) {
-        let len = v1.len();
-        fn le(a: &int, b: &int) -> bool { *a <= *b }
-        let f = le;
-        let v3 = merge_sort::<int>(v1, f);
-        let mut i = 0u;
-        while i < len {
-            debug!("{:?}", v3[i]);
-            assert_eq!(v3[i], v2[i]);
-            i += 1;
-        }
-    }
-
-    #[test]
-    fn test() {
-        {
-            let v1 = ~[3, 7, 4, 5, 2, 9, 5, 8];
-            let v2 = ~[2, 3, 4, 5, 5, 7, 8, 9];
-            check_sort(v1, v2);
-        }
-        { let v1 = ~[1, 1, 1]; let v2 = ~[1, 1, 1]; check_sort(v1, v2); }
-        { let v1:~[int] = ~[]; let v2:~[int] = ~[]; check_sort(v1, v2); }
-        { let v1 = ~[9]; let v2 = ~[9]; check_sort(v1, v2); }
-        {
-            let v1 = ~[9, 3, 3, 3, 9];
-            let v2 = ~[3, 3, 3, 9, 9];
-            check_sort(v1, v2);
-        }
-    }
-
-    #[test]
-    fn test_merge_sort_mutable() {
-        fn le(a: &int, b: &int) -> bool { *a <= *b }
-        let v1 = ~[3, 2, 1];
-        let v2 = merge_sort(v1, le);
-        assert_eq!(v2, ~[1, 2, 3]);
-    }
-
-    #[test]
-    fn test_merge_sort_stability() {
-        // tjc: funny that we have to use parens
-        fn ile(x: &(&'static str), y: &(&'static str)) -> bool
-        {
-            let x = x.to_ascii().to_lower().into_str();
-            let y = y.to_ascii().to_lower().into_str();
-            x <= y
-        }
-
-        let names1 = ~["joe bob", "Joe Bob", "Jack Brown", "JOE Bob",
-                       "Sally Mae", "JOE BOB", "Alex Andy"];
-        let names2 = ~["Alex Andy", "Jack Brown", "joe bob", "Joe Bob",
-                       "JOE Bob", "JOE BOB", "Sally Mae"];
-        let names3 = merge_sort(names1, ile);
-        assert_eq!(names3, names2);
-    }
-}
-
-#[cfg(test)]
-mod test_tim_sort {
-
-    use sort::tim_sort;
-    use std::rand::Rng;
-    use std::rand;
-    use std::vec;
-
-    #[deriving(Clone)]
-    struct CVal {
-        val: f64,
-    }
-
-    impl Ord for CVal {
-        fn lt(&self, other: &CVal) -> bool {
-            let mut rng = rand::rng();
-            if rng.gen::<f64>() > 0.995 {
-                fail!("It's happening!!!");
-            }
-            (*self).val < other.val
-        }
-        fn le(&self, other: &CVal) -> bool { (*self).val <= other.val }
-        fn gt(&self, other: &CVal) -> bool { (*self).val > other.val }
-        fn ge(&self, other: &CVal) -> bool { (*self).val >= other.val }
-    }
-
-    fn check_sort(v1: &mut [int], v2: &mut [int]) {
-        let len = v1.len();
-        tim_sort::<int>(v1);
-        let mut i = 0u;
-        while i < len {
-            // debug!(v2[i]);
-            assert_eq!(v2[i], v1[i]);
-            i += 1u;
-        }
-    }
-
-    #[test]
-    fn test() {
-        {
-            let mut v1 = ~[3, 7, 4, 5, 2, 9, 5, 8];
-            let mut v2 = ~[2, 3, 4, 5, 5, 7, 8, 9];
-            check_sort(v1, v2);
-        }
-        {
-            let mut v1 = ~[1, 1, 1];
-            let mut v2 = ~[1, 1, 1];
-            check_sort(v1, v2);
-        }
-        {
-            let mut v1: ~[int] = ~[];
-            let mut v2: ~[int] = ~[];
-            check_sort(v1, v2);
-        }
-        { let mut v1 = ~[9]; let mut v2 = ~[9]; check_sort(v1, v2); }
-        {
-            let mut v1 = ~[9, 3, 3, 3, 9];
-            let mut v2 = ~[3, 3, 3, 9, 9];
-            check_sort(v1, v2);
-        }
-    }
-
-    #[test]
-    #[should_fail]
-    #[cfg(unix)]
-    fn crash_test() {
-        let mut rng = rand::rng();
-        let mut arr = vec::from_fn(1000, |_i| {
-            CVal { val: rng.gen() }
-        });
-
-        tim_sort(arr);
-        fail!("Guarantee the fail");
-    }
-
-    #[deriving(Clone)]
-    struct DVal {
-        val: uint,
-    }
-
-    impl Ord for DVal {
-        fn lt(&self, _x: &DVal) -> bool { true }
-        fn le(&self, _x: &DVal) -> bool { true }
-        fn gt(&self, _x: &DVal) -> bool { true }
-        fn ge(&self, _x: &DVal) -> bool { true }
-    }
-
-    #[test]
-    fn test_bad_Ord_impl() {
-        let mut rng = rand::rng();
-        let mut arr = vec::from_fn(500, |_i| {
-            DVal { val: rng.gen() }
-        });
-
-        tim_sort(arr);
-    }
-}
-
-#[cfg(test)]
-mod big_tests {
-
-    use sort::*;
-
-    use std::rand::Rng;
-    use std::rand;
-    use std::vec;
-
-    #[test]
-    fn test_unique() {
-        let low = 5;
-        let high = 10;
-        tabulate_unique(low, high);
-    }
-
-    #[test]
-    fn test_managed() {
-        let low = 5;
-        let high = 10;
-        tabulate_managed(low, high);
-    }
-
-    fn multiplyVec<T:Clone>(arr: &[T], num: uint) -> ~[T] {
-        let size = arr.len();
-        let res = vec::from_fn(num, |i| {
-            arr[i % size].clone()
-        });
-        res
-    }
-
-    fn makeRange(n: uint) -> ~[uint] {
-        let one = vec::from_fn(n, |i| i);
-        let mut two = one.clone();
-        two.reverse();
-        vec::append(two, one)
-    }
-
-    fn tabulate_unique(lo: uint, hi: uint) {
-        fn isSorted<T:Ord>(arr: &[T]) {
-            for i in range(0u, arr.len() - 1) {
-                if arr[i] > arr[i+1] {
-                    fail!("Array not sorted");
-                }
-            }
-        }
-
-        let mut rng = rand::rng();
-
-        for i in range(lo, hi) {
-            let n = 1 << i;
-            let mut arr: ~[f64] = vec::from_fn(n, |_i| {
-                rng.gen()
-            });
-
-            tim_sort(arr); // *sort
-            isSorted(arr);
-
-            arr.reverse();
-            tim_sort(arr); // \sort
-            isSorted(arr);
-
-            tim_sort(arr); // /sort
-            isSorted(arr);
-
-            3.times(|| {
-                let i1 = rng.gen_range(0u, n);
-                let i2 = rng.gen_range(0u, n);
-                arr.swap(i1, i2);
-            });
-            tim_sort(arr); // 3sort
-            isSorted(arr);
-
-            if n >= 10 {
-                let size = arr.len();
-                let mut idx = 1;
-                while idx <= 10 {
-                    arr[size-idx] = rng.gen();
-                    idx += 1;
-                }
-            }
-            tim_sort(arr); // +sort
-            isSorted(arr);
-
-            (n/100).times(|| {
-                let idx = rng.gen_range(0u, n);
-                arr[idx] = rng.gen();
-            });
-            tim_sort(arr);
-            isSorted(arr);
-
-            let mut arr = if n > 4 {
-                let part = arr.slice(0, 4);
-                multiplyVec(part, n)
-            } else { arr };
-            tim_sort(arr); // ~sort
-            isSorted(arr);
-
-            let mut arr = vec::from_elem(n, -0.5);
-            tim_sort(arr); // =sort
-            isSorted(arr);
-
-            let half = n / 2;
-            let mut arr = makeRange(half).map(|i| *i as f64);
-            tim_sort(arr); // !sort
-            isSorted(arr);
-        }
-    }
-
-    fn tabulate_managed(lo: uint, hi: uint) {
-        fn isSorted<T:Ord>(arr: &[@T]) {
-            for i in range(0u, arr.len() - 1) {
-                if arr[i] > arr[i+1] {
-                    fail!("Array not sorted");
-                }
-            }
-        }
-
-        let mut rng = rand::rng();
-
-        for i in range(lo, hi) {
-            let n = 1 << i;
-            let arr: ~[@f64] = vec::from_fn(n, |_i| {
-                @rng.gen()
-            });
-            let mut arr = arr;
-
-            tim_sort(arr); // *sort
-            isSorted(arr);
-
-            arr.reverse();
-            tim_sort(arr); // \sort
-            isSorted(arr);
-
-            tim_sort(arr); // /sort
-            isSorted(arr);
-
-            3.times(|| {
-                let i1 = rng.gen_range(0u, n);
-                let i2 = rng.gen_range(0u, n);
-                arr.swap(i1, i2);
-            });
-            tim_sort(arr); // 3sort
-            isSorted(arr);
-
-            if n >= 10 {
-                let size = arr.len();
-                let mut idx = 1;
-                while idx <= 10 {
-                    arr[size-idx] = @rng.gen();
-                    idx += 1;
-                }
-            }
-            tim_sort(arr); // +sort
-            isSorted(arr);
-
-            (n/100).times(|| {
-                let idx = rng.gen_range(0u, n);
-                arr[idx] = @rng.gen();
-            });
-            tim_sort(arr);
-            isSorted(arr);
-
-            let mut arr = if n > 4 {
-                let part = arr.slice(0, 4);
-                multiplyVec(part, n)
-            } else { arr };
-            tim_sort(arr); // ~sort
-            isSorted(arr);
-
-            let mut arr = vec::from_elem(n, @(-0.5));
-            tim_sort(arr); // =sort
-            isSorted(arr);
-
-            let half = n / 2;
-            let mut arr = makeRange(half).map(|i| @(*i as f64));
-            tim_sort(arr); // !sort
-            isSorted(arr);
-        }
-    }
-}
diff --git a/src/libextra/stats.rs b/src/libextra/stats.rs
index 07fb7ae96c7..e4ef5723dd3 100644
--- a/src/libextra/stats.rs
+++ b/src/libextra/stats.rs
@@ -10,7 +10,6 @@
 
 #[allow(missing_doc)];
 
-use sort;
 use std::cmp;
 use std::hashmap;
 use std::io;
@@ -240,13 +239,13 @@ impl<'a> Stats for &'a [f64] {
 
     fn percentile(self, pct: f64) -> f64 {
         let mut tmp = self.to_owned();
-        sort::tim_sort(tmp);
+        tmp.sort(|a,b| a <= b);
         percentile_of_sorted(tmp, pct)
     }
 
     fn quartiles(self) -> (f64,f64,f64) {
         let mut tmp = self.to_owned();
-        sort::tim_sort(tmp);
+        tmp.sort(|a,b| a <= b);
         let a = percentile_of_sorted(tmp, 25.0);
         let b = percentile_of_sorted(tmp, 50.0);
         let c = percentile_of_sorted(tmp, 75.0);
@@ -291,7 +290,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();
-    sort::tim_sort(tmp);
+    tmp.sort(|a,b| a <= b);
     let lo = percentile_of_sorted(tmp, pct);
     let hi = percentile_of_sorted(tmp, 100.0-pct);
     for samp in samples.mut_iter() {
diff --git a/src/libextra/test.rs b/src/libextra/test.rs
index 8f0c4fe6d23..af22aad7b5e 100644
--- a/src/libextra/test.rs
+++ b/src/libextra/test.rs
@@ -21,7 +21,6 @@ use getopts::groups;
 use json::ToJson;
 use json;
 use serialize::Decodable;
-use sort;
 use stats::Stats;
 use stats;
 use term;
@@ -488,7 +487,7 @@ impl<T: Writer> ConsoleTestState<T> {
         for f in self.failures.iter() {
             failures.push(f.name.to_str());
         }
-        sort::tim_sort(failures);
+        failures.sort(|a,b| a <= b);
         for name in failures.iter() {
             self.write_plain(format!("    {}\n", name.to_str()));
         }
@@ -840,9 +839,9 @@ 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()
+        t1.desc.name.to_str() <= t2.desc.name.to_str()
     }
-    sort::quick_sort(filtered, lteq);
+    filtered.sort(lteq);
 
     // Shard the remaining tests, if sharding requested.
     match opts.test_shard {