From 7625ed52eee77078747f9e9639b89166681abef8 Mon Sep 17 00:00:00 2001
From: Brian Anderson <banderson@mozilla.com>
Date: Thu, 11 Aug 2011 22:48:08 -0700
Subject: [PATCH] Remove vecs from std::sort
---
src/comp/front/attr.rs | 2 +-
src/comp/metadata/encoder.rs | 2 +-
src/comp/middle/trans_objects.rs | 4 +-
src/comp/middle/ty.rs | 2 +-
src/lib/sort.rs | 176 ++++---------------------------
src/lib/test.rs | 1 -
src/test/stdtest/qsort.rs | 24 ++---
src/test/stdtest/qsort3.rs | 22 ++--
src/test/stdtest/sort.rs | 20 ++--
src/test/stdtest/sort_ivec.rs | 28 -----
src/test/stdtest/stdtest.rc | 1 -
11 files changed, 57 insertions(+), 225 deletions(-)
delete mode 100644 src/test/stdtest/sort_ivec.rs
diff --git a/src/comp/front/attr.rs b/src/comp/front/attr.rs
index 061193022cb..3d3a26bc228 100644
--- a/src/comp/front/attr.rs
+++ b/src/comp/front/attr.rs
@@ -155,7 +155,7 @@ fn sort_meta_items(items: &[@ast::meta_item]) -> [@ast::meta_item] {
let v: [mutable @ast::meta_item] = ~[mutable];
for mi: @ast::meta_item in items { v += ~[mutable mi]; }
- std::sort::ivector::quick_sort(lteq, v);
+ std::sort::quick_sort(lteq, v);
let v2: [@ast::meta_item] = ~[];
for mi: @ast::meta_item in v { v2 += ~[mi]; }
diff --git a/src/comp/metadata/encoder.rs b/src/comp/metadata/encoder.rs
index c35da50f965..de06f0114bc 100644
--- a/src/comp/metadata/encoder.rs
+++ b/src/comp/metadata/encoder.rs
@@ -552,7 +552,7 @@ fn encode_crate_deps(ebml_w: &ebmlivec::writer, cstore: &cstore::cstore) {
fn lteq(kv1: &numname, kv2: &numname) -> bool {
kv1.crate <= kv2.crate
}
- std::sort::ivector::quick_sort(lteq, pairs);
+ std::sort::quick_sort(lteq, pairs);
// Sanity-check the crate numbers
let expected_cnum = 1;
diff --git a/src/comp/middle/trans_objects.rs b/src/comp/middle/trans_objects.rs
index d79851813e1..428fb20059e 100644
--- a/src/comp/middle/trans_objects.rs
+++ b/src/comp/middle/trans_objects.rs
@@ -460,7 +460,7 @@ fn create_vtbl(cx: @local_ctxt, sp: &span, outer_obj_ty: ty::t,
// Sort and process all the methods.
let meths =
- std::sort::ivector::merge_sort[@ast::method]
+ std::sort::merge_sort[@ast::method]
(bind ast_mthd_lteq(_, _), ob.methods);
for m: @ast::method in meths {
@@ -504,7 +504,7 @@ fn create_vtbl(cx: @local_ctxt, sp: &span, outer_obj_ty: ty::t,
// Sort all the methods and process them.
meths =
- std::sort::ivector::merge_sort[vtbl_mthd]
+ std::sort::merge_sort[vtbl_mthd]
(bind vtbl_mthd_lteq(_, _), meths);
// To create forwarding methods, we'll need a "backwarding" vtbl. See
diff --git a/src/comp/middle/ty.rs b/src/comp/middle/ty.rs
index 7ab295fd2e1..c631e9bbd4a 100644
--- a/src/comp/middle/ty.rs
+++ b/src/comp/middle/ty.rs
@@ -1991,7 +1991,7 @@ fn sort_methods(meths: &[method]) -> [method] {
fn method_lteq(a: &method, b: &method) -> bool {
ret str::lteq(a.ident, b.ident);
}
- ret std::sort::ivector::merge_sort[method](bind method_lteq(_, _), meths);
+ ret std::sort::merge_sort[method](bind method_lteq(_, _), meths);
}
fn is_lval(expr: &@ast::expr) -> bool {
diff --git a/src/lib/sort.rs b/src/lib/sort.rs
index 825a16cea6d..19242b74c74 100644
--- a/src/lib/sort.rs
+++ b/src/lib/sort.rs
@@ -1,28 +1,25 @@
-import vec::len;
-import vec::slice;
-import ilen = ivec::len;
-import islice = ivec::slice;
-export ivector;
-export lteq;
+import ivec::len;
+import ivec::slice;
+
export merge_sort;
export quick_sort;
export quick_sort3;
type lteq[T] = block(&T, &T) -> bool ;
-fn merge_sort[@T](le: <eq[T], v: vec[T]) -> vec[T] {
- fn merge[@T](le: <eq[T], a: vec[T], b: vec[T]) -> vec[T] {
- let rs: vec[T] = [];
+fn merge_sort[@T](le: <eq[T], v: &[T]) -> [T] {
+ fn merge[@T](le: <eq[T], a: &[T], b: &[T]) -> [T] {
+ let rs: [T] = ~[];
let a_len: uint = len[T](a);
let a_ix: uint = 0u;
let b_len: uint = len[T](b);
let b_ix: uint = 0u;
while a_ix < a_len && b_ix < b_len {
if le(a.(a_ix), b.(b_ix)) {
- rs += [a.(a_ix)];
+ rs += ~[a.(a_ix)];
a_ix += 1u;
- } else { rs += [b.(b_ix)]; b_ix += 1u; }
+ } else { rs += ~[b.(b_ix)]; b_ix += 1u; }
}
rs += slice[T](a, a_ix, a_len);
rs += slice[T](b, b_ix, b_len);
@@ -31,18 +28,18 @@ fn merge_sort[@T](le: <eq[T], v: vec[T]) -> vec[T] {
let v_len: uint = len[T](v);
if v_len <= 1u { ret v; }
let mid: uint = v_len / 2u;
- let a: vec[T] = slice[T](v, 0u, mid);
- let b: vec[T] = slice[T](v, mid, v_len);
+ let a: [T] = slice[T](v, 0u, mid);
+ let b: [T] = slice[T](v, mid, v_len);
ret merge[T](le, merge_sort[T](le, a), merge_sort[T](le, b));
}
-fn swap[@T](arr: vec[mutable T], x: uint, y: uint) {
+fn swap[@T](arr: &[mutable T], x: uint, y: uint) {
let a = arr.(x);
arr.(x) = arr.(y);
arr.(y) = a;
}
-fn part[@T](compare_func: <eq[T], arr: vec[mutable T], left: uint,
+fn part[@T](compare_func: <eq[T], arr: &[mutable T], left: uint,
right: uint, pivot: uint) -> uint {
let pivot_value = arr.(pivot);
swap[T](arr, pivot, right);
@@ -59,7 +56,7 @@ fn part[@T](compare_func: <eq[T], arr: vec[mutable T], left: uint,
ret storage_index;
}
-fn qsort[@T](compare_func: <eq[T], arr: vec[mutable T], left: uint,
+fn qsort[@T](compare_func: <eq[T], arr: &[mutable T], left: uint,
right: uint) {
if right > left {
let pivot = (left + right) / 2u;
@@ -72,7 +69,7 @@ fn qsort[@T](compare_func: <eq[T], arr: vec[mutable T], left: uint,
}
}
-fn quick_sort[@T](compare_func: <eq[T], arr: vec[mutable T]) {
+fn quick_sort[@T](compare_func: <eq[T], arr: &[mutable T]) {
if len[T](arr) == 0u { ret; }
qsort[T](compare_func, arr, 0u, len[T](arr) - 1u);
}
@@ -83,7 +80,7 @@ fn quick_sort[@T](compare_func: <eq[T], arr: vec[mutable T]) {
// According to these slides this is the algorithm of choice for
// 'randomly ordered keys, abstract compare' & 'small number of key values'
fn qsort3[@T](compare_func_lt: <eq[T], compare_func_eq: <eq[T],
- arr: vec[mutable T], left: int, right: int) {
+ arr: &[mutable T], left: int, right: int) {
if right <= left { ret; }
let v: T = arr.(right);
let i: int = left - 1;
@@ -117,7 +114,7 @@ fn qsort3[@T](compare_func_lt: <eq[T], compare_func_eq: <eq[T],
swap[T](arr, k as uint, j as uint);
k += 1;
j -= 1;
- if k == vec::len[T](arr) as int { break; }
+ if k == len[T](arr) as int { break; }
}
k = right - 1;
while k > q {
@@ -131,145 +128,10 @@ fn qsort3[@T](compare_func_lt: <eq[T], compare_func_eq: <eq[T],
}
fn quick_sort3[@T](compare_func_lt: <eq[T], compare_func_eq: <eq[T],
- arr: vec[mutable T]) {
- if vec::len[T](arr) == 0u { ret; }
+ arr: &[mutable T]) {
+ if len[T](arr) == 0u { ret; }
qsort3[T](compare_func_lt, compare_func_eq, arr, 0,
- (vec::len[T](arr) as int) - 1);
-}
-
-mod ivector {
- export merge_sort;
- export quick_sort;
- export quick_sort3;
-
- type lteq[T] = fn(&T, &T) -> bool ;
-
- fn merge_sort[@T](le: <eq[T], v: &[T]) -> [T] {
- fn merge[@T](le: <eq[T], a: &[T], b: &[T]) -> [T] {
- let rs: [T] = ~[];
- let a_len: uint = ilen[T](a);
- let a_ix: uint = 0u;
- let b_len: uint = ilen[T](b);
- let b_ix: uint = 0u;
- while a_ix < a_len && b_ix < b_len {
- if le(a.(a_ix), b.(b_ix)) {
- rs += ~[a.(a_ix)];
- a_ix += 1u;
- } else { rs += ~[b.(b_ix)]; b_ix += 1u; }
- }
- rs += islice[T](a, a_ix, a_len);
- rs += islice[T](b, b_ix, b_len);
- ret rs;
- }
- let v_len: uint = ilen[T](v);
- if v_len <= 1u { ret v; }
- let mid: uint = v_len / 2u;
- let a: [T] = islice[T](v, 0u, mid);
- let b: [T] = islice[T](v, mid, v_len);
- ret merge[T](le, merge_sort[T](le, a), merge_sort[T](le, b));
- }
-
- fn swap[@T](arr: &[mutable T], x: uint, y: uint) {
- let a = arr.(x);
- arr.(x) = arr.(y);
- arr.(y) = a;
- }
-
- fn part[@T](compare_func: <eq[T], arr: &[mutable T], left: uint,
- right: uint, pivot: uint) -> uint {
- let pivot_value = arr.(pivot);
- swap[T](arr, pivot, right);
- let storage_index: uint = left;
- let i: uint = left;
- while i < right {
- if compare_func({ arr.(i) }, pivot_value) {
- swap[T](arr, i, storage_index);
- storage_index += 1u;
- }
- i += 1u;
- }
- swap[T](arr, storage_index, right);
- ret storage_index;
- }
-
- fn qsort[@T](compare_func: <eq[T], arr: &[mutable T], left: uint,
- right: uint) {
- if right > left {
- let pivot = (left + right) / 2u;
- let new_pivot = part[T](compare_func, arr, left, right, pivot);
- if new_pivot != 0u {
- // Need to do this check before recursing due to overflow
- qsort[T](compare_func, arr, left, new_pivot - 1u);
- }
- qsort[T](compare_func, arr, new_pivot + 1u, right);
- }
- }
-
- fn quick_sort[@T](compare_func: <eq[T], arr: &[mutable T]) {
- if ilen[T](arr) == 0u { ret; }
- qsort[T](compare_func, arr, 0u, ilen[T](arr) - 1u);
- }
-
-
- // Based on algorithm presented by Sedgewick and Bentley here:
- // 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'
- fn qsort3[@T](compare_func_lt: <eq[T], compare_func_eq: <eq[T],
- arr: &[mutable T], left: int, right: int) {
- if right <= left { ret; }
- let v: T = arr.(right);
- let i: int = left - 1;
- let j: int = right;
- let p: int = i;
- let q: int = j;
- while true {
- i += 1;
- while compare_func_lt({ arr.(i) }, v) { i += 1; }
- j -= 1;
- while compare_func_lt(v, { arr.(j) }) {
- if j == left { break; }
- j -= 1;
- }
- if i >= j { break; }
- swap[T](arr, i as uint, j as uint);
- if compare_func_eq({ arr.(i) }, v) {
- p += 1;
- swap[T](arr, p as uint, i as uint);
- }
- if compare_func_eq(v, { arr.(j) }) {
- q -= 1;
- swap[T](arr, j as uint, q as uint);
- }
- }
- swap[T](arr, i as uint, right as uint);
- j = i - 1;
- i += 1;
- let k: int = left;
- while k < p {
- swap[T](arr, k as uint, j as uint);
- k += 1;
- j -= 1;
- if k == ilen[T](arr) as int { break; }
- }
- k = right - 1;
- while k > q {
- swap[T](arr, i as uint, k as uint);
- k -= 1;
- i += 1;
- if k == 0 { break; }
- }
- qsort3[T](compare_func_lt, compare_func_eq, arr, left, j);
- qsort3[T](compare_func_lt, compare_func_eq, arr, i, right);
- }
-
- fn quick_sort3[@T](compare_func_lt: <eq[T], compare_func_eq: <eq[T],
- arr: &[mutable T]) {
- if ilen[T](arr) == 0u { ret; }
- qsort3[T](compare_func_lt, compare_func_eq, arr, 0,
- (ilen[T](arr) as int) - 1);
- }
+ (len[T](arr) as int) - 1);
}
// Local Variables:
diff --git a/src/lib/test.rs b/src/lib/test.rs
index 70f9580bf73..de6a4555cf1 100644
--- a/src/lib/test.rs
+++ b/src/lib/test.rs
@@ -3,7 +3,6 @@
// simplest interface possible for representing and running tests
// while providing a base that other test frameworks may build off of.
-import sort = sort::ivector;
import generic_os::getenv;
export test_name;
diff --git a/src/test/stdtest/qsort.rs b/src/test/stdtest/qsort.rs
index c8f19e373b3..0799f505e3c 100644
--- a/src/test/stdtest/qsort.rs
+++ b/src/test/stdtest/qsort.rs
@@ -5,8 +5,8 @@ import std::sort;
import std::ivec;
import std::int;
-fn check_sort(v1: vec[mutable int], v2: vec[mutable int]) {
- let len = std::vec::len[int](v1);
+fn check_sort(v1: &[mutable int], v2: &[mutable int]) {
+ let len = std::ivec::len[int](v1);
fn ltequal(a: &int, b: &int) -> bool { ret a <= b; }
let f = ltequal;
std::sort::quick_sort[int](f, v1);
@@ -17,24 +17,24 @@ fn check_sort(v1: vec[mutable int], v2: vec[mutable int]) {
#[test]
fn test() {
{
- let v1 = [mutable 3, 7, 4, 5, 2, 9, 5, 8];
- let v2 = [mutable 2, 3, 4, 5, 5, 7, 8, 9];
+ let v1 = ~[mutable 3, 7, 4, 5, 2, 9, 5, 8];
+ let v2 = ~[mutable 2, 3, 4, 5, 5, 7, 8, 9];
check_sort(v1, v2);
}
{
- let v1 = [mutable 1, 1, 1];
- let v2 = [mutable 1, 1, 1];
+ let v1 = ~[mutable 1, 1, 1];
+ let v2 = ~[mutable 1, 1, 1];
check_sort(v1, v2);
}
{
- let v1: vec[mutable int] = [mutable ];
- let v2: vec[mutable int] = [mutable ];
+ let v1: [mutable int] = ~[mutable ];
+ let v2: [mutable int] = ~[mutable ];
check_sort(v1, v2);
}
- { let v1 = [mutable 9]; let v2 = [mutable 9]; check_sort(v1, v2); }
+ { let v1 = ~[mutable 9]; let v2 = ~[mutable 9]; check_sort(v1, v2); }
{
- let v1 = [mutable 9, 3, 3, 3, 9];
- let v2 = [mutable 3, 3, 3, 9, 9];
+ let v1 = ~[mutable 9, 3, 3, 3, 9];
+ let v2 = ~[mutable 3, 3, 3, 9, 9];
check_sort(v1, v2);
}
}
@@ -47,7 +47,7 @@ fn test_simple() {
let expected = ~[1, 2, 3];
fn lteq(a: &int, b: &int) -> bool { int::le(a, b) }
- sort::ivector::quick_sort(lteq, names);
+ sort::quick_sort(lteq, names);
let pairs = ivec::zip(expected, ivec::from_mut(names));
for p: {_0: int, _1: int} in pairs {
diff --git a/src/test/stdtest/qsort3.rs b/src/test/stdtest/qsort3.rs
index 79e4c42c590..fe871ceda21 100644
--- a/src/test/stdtest/qsort3.rs
+++ b/src/test/stdtest/qsort3.rs
@@ -1,8 +1,8 @@
use std;
-fn check_sort(v1: vec[mutable int], v2: vec[mutable int]) {
- let len = std::vec::len[int](v1);
+fn check_sort(v1: &[mutable int], v2: &[mutable int]) {
+ let len = std::ivec::len[int](v1);
fn lt(a: &int, b: &int) -> bool { ret a < b; }
fn equal(a: &int, b: &int) -> bool { ret a == b; }
let f1 = lt;
@@ -15,24 +15,24 @@ fn check_sort(v1: vec[mutable int], v2: vec[mutable int]) {
#[test]
fn test() {
{
- let v1 = [mutable 3, 7, 4, 5, 2, 9, 5, 8];
- let v2 = [mutable 2, 3, 4, 5, 5, 7, 8, 9];
+ let v1 = ~[mutable 3, 7, 4, 5, 2, 9, 5, 8];
+ let v2 = ~[mutable 2, 3, 4, 5, 5, 7, 8, 9];
check_sort(v1, v2);
}
{
- let v1 = [mutable 1, 1, 1];
- let v2 = [mutable 1, 1, 1];
+ let v1 = ~[mutable 1, 1, 1];
+ let v2 = ~[mutable 1, 1, 1];
check_sort(v1, v2);
}
{
- let v1: vec[mutable int] = [mutable ];
- let v2: vec[mutable int] = [mutable ];
+ let v1: [mutable int] = ~[mutable ];
+ let v2: [mutable int] = ~[mutable ];
check_sort(v1, v2);
}
- { let v1 = [mutable 9]; let v2 = [mutable 9]; check_sort(v1, v2); }
+ { let v1 = ~[mutable 9]; let v2 = ~[mutable 9]; check_sort(v1, v2); }
{
- let v1 = [mutable 9, 3, 3, 3, 9];
- let v2 = [mutable 3, 3, 3, 9, 9];
+ let v1 = ~[mutable 9, 3, 3, 3, 9];
+ let v2 = ~[mutable 3, 3, 3, 9, 9];
check_sort(v1, v2);
}
}
diff --git a/src/test/stdtest/sort.rs b/src/test/stdtest/sort.rs
index e2ce3f028fb..eac5204cde3 100644
--- a/src/test/stdtest/sort.rs
+++ b/src/test/stdtest/sort.rs
@@ -1,8 +1,8 @@
use std;
-fn check_sort(v1: vec[int], v2: vec[int]) {
- let len = std::vec::len[int](v1);
+fn check_sort(v1: &[int], v2: &[int]) {
+ let len = std::ivec::len[int](v1);
fn lteq(a: &int, b: &int) -> bool { ret a <= b; }
let f = lteq;
let v3 = std::sort::merge_sort[int](f, v1);
@@ -13,16 +13,16 @@ fn check_sort(v1: vec[int], v2: vec[int]) {
#[test]
fn test() {
{
- let v1 = [3, 7, 4, 5, 2, 9, 5, 8];
- let v2 = [2, 3, 4, 5, 5, 7, 8, 9];
+ 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: vec[int] = []; let v2: vec[int] = []; check_sort(v1, v2); }
- { let v1 = [9]; let v2 = [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];
+ let v1 = ~[9, 3, 3, 3, 9];
+ let v2 = ~[3, 3, 3, 9, 9];
check_sort(v1, v2);
}
-}
\ No newline at end of file
+}
diff --git a/src/test/stdtest/sort_ivec.rs b/src/test/stdtest/sort_ivec.rs
deleted file mode 100644
index 3e52de4ad2e..00000000000
--- a/src/test/stdtest/sort_ivec.rs
+++ /dev/null
@@ -1,28 +0,0 @@
-
-use std;
-
-fn check_sort(v1: &[int], v2: &[int]) {
- let len = std::ivec::len[int](v1);
- fn lteq(a: &int, b: &int) -> bool { ret a <= b; }
- let f = lteq;
- let v3 = std::sort::ivector::merge_sort[int](f, v1);
- let i = 0u;
- while i < len { log v3.(i); assert (v3.(i) == v2.(i)); i += 1u; }
-}
-
-#[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);
- }
-}
diff --git a/src/test/stdtest/stdtest.rc b/src/test/stdtest/stdtest.rc
index b8907248cbd..401587ed36e 100644
--- a/src/test/stdtest/stdtest.rc
+++ b/src/test/stdtest/stdtest.rc
@@ -21,7 +21,6 @@ mod qsort;
mod rand;
mod run;
mod sha1;
-mod sort_ivec;
mod sort;
mod str_buf;
mod str;