user0/rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Port the stdlib to the expr foo::<T> syntax.

Browse source
This commit is contained in:
Erick Tryzelaar 2011-08-12 10:56:57 -07:00 • committed by Graydon Hoare
parent 3520499544
commit d9327a61bb
20 changed files with 147 additions and 141 deletions
Download patch file Download diff file Expand all files Collapse all files

56
src/lib/sort.rs
View file

@ -11,9 +11,9 @@ type lteq<T> = block(&T, &T) -> bool ;
fn merge_sort<@T>(le: &lteq<T>, v: &[T]) -> [T] {
fn merge<@T>(le: &lteq<T>, a: &[T], b: &[T]) -> [T] {
let rs: [T] = ~[];
let a_len: uint = len[T](a);
let a_len: uint = len::<T>(a);
let a_ix: uint = 0u;
let b_len: uint = len[T](b);
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)) {
@ -21,16 +21,16 @@ fn merge_sort<@T>(le: &lteq<T>, v: &[T]) -> [T] {
a_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);
rs += slice::<T>(a, a_ix, a_len);
rs += slice::<T>(b, b_ix, b_len);
ret rs;
}
let v_len: uint = len[T](v);
let v_len: uint = len::<T>(v);
if v_len <= 1u { ret v; }
let mid: uint = v_len / 2u;
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));
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: &[mutable T], x: uint, y: uint) {
@ -42,17 +42,17 @@ fn swap<@T>(arr: &[mutable T], x: uint, y: uint) {
fn part<@T>(compare_func: &lteq<T>, arr: &[mutable T], left: uint,
right: uint, pivot: uint) -> uint {
let pivot_value = arr.(pivot);
swap[T](arr, pivot, right);
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);
swap::<T>(arr, i, storage_index);
storage_index += 1u;
}
i += 1u;
}
swap[T](arr, storage_index, right);
swap::<T>(arr, storage_index, right);
ret storage_index;
}
@ -60,18 +60,18 @@ fn qsort<@T>(compare_func: &lteq<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);
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, left, new_pivot - 1u);
}
qsort[T](compare_func, arr, new_pivot + 1u, right);
qsort::<T>(compare_func, arr, new_pivot + 1u, right);
}
}
fn quick_sort<@T>(compare_func: &lteq<T>, arr: &[mutable T]) {
if len[T](arr) == 0u { ret; }
qsort[T](compare_func, arr, 0u, len[T](arr) - 1u);
if len::<T>(arr) == 0u { ret; }
qsort::<T>(compare_func, arr, 0u, len::<T>(arr) - 1u);
}
@ -96,42 +96,42 @@ fn qsort3<@T>(compare_func_lt: &lteq<T>, compare_func_eq: &lteq<T>,
j -= 1;
}
if i >= j { break; }
swap[T](arr, i as uint, j as uint);
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);
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, j as uint, q as uint);
}
}
swap[T](arr, i as uint, right 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);
swap::<T>(arr, k as uint, j as uint);
k += 1;
j -= 1;
if k == len[T](arr) as int { break; }
if k == len::<T>(arr) as int { break; }
}
k = right - 1;
while k > q {
swap[T](arr, i as uint, k as uint);
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);
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: &lteq<T>, compare_func_eq: &lteq<T>,
arr: &[mutable T]) {
if len[T](arr) == 0u { ret; }
qsort3[T](compare_func_lt, compare_func_eq, arr, 0,
(len[T](arr) as int) - 1);
if len::<T>(arr) == 0u { ret; }
qsort3::<T>(compare_func_lt, compare_func_eq, arr, 0,
(len::<T>(arr) as int) - 1);
}
// Local Variables: