fn fill_concat(v: &[BigDigit], radix: uint, l: uint) -> ~str {
if v.is_empty() { return ~"0" }
- let s = vec::reversed(v).map(|n| {
- let s = uint::to_str_radix(*n as uint, radix);
- str::from_chars(vec::from_elem(l - s.len(), '0')) + s
- }).concat();
+ let mut s = str::with_capacity(v.len() * l);
+ for v.rev_iter().advance |n| {
+ let ss = uint::to_str_radix(*n as uint, radix);
+ s.push_str("0".repeat(l - ss.len()));
+ s.push_str(ss);
+ }
s.trim_left_chars(&'0').to_owned()
}
}
use std::int;
use std::num::{IntConvertible, Zero, One, FromStrRadix};
use std::uint;
- use std::vec;
#[test]
fn test_from_biguint() {
#[test]
fn test_cmp() {
- let vs = [ &[2], &[1, 1], &[2, 1], &[1, 1, 1] ];
- let mut nums = vec::reversed(vs)
- .map(|s| BigInt::from_slice(Minus, *s));
+ let vs = [ &[2 as BigDigit], &[1, 1], &[2, 1], &[1, 1, 1] ];
+ let mut nums = ~[];
+ for vs.rev_iter().advance |s| {
+ nums.push(BigInt::from_slice(Minus, *s));
+ }
nums.push(Zero::zero());
nums.push_all_move(vs.map(|s| BigInt::from_slice(Plus, *s)));
use std::str;
use std::uint;
-use std::vec;
use std::hashmap::{HashMap, HashSet};
use std::util;
if idents.len() == 0 {
return ~"???";
}
- return self.idents_to_str(vec::reversed(idents));
+ return self.idents_to_str(idents.consume_rev_iter().collect::<~[ast::ident]>());
}
pub fn dump_module(@mut self, module_: @mut Module) {
w
}
-/// Returns a vector with the order of elements reversed
-pub fn reversed<T:Copy>(v: &[T]) -> ~[T] {
- let mut rs: ~[T] = ~[];
- let mut i = v.len();
- if i == 0 { return (rs); } else { i -= 1; }
- while i != 0 { rs.push(copy v[i]); i -= 1; }
- rs.push(copy v[0]);
- rs
-}
-
/**
* Iterate over all permutations of vector `v`.
*
}
#[test]
- fn reverse_and_reversed() {
+ fn test_reverse() {
let mut v: ~[int] = ~[10, 20];
assert_eq!(v[0], 10);
assert_eq!(v[1], 20);
v.reverse();
assert_eq!(v[0], 20);
assert_eq!(v[1], 10);
- let v2 = reversed::<int>([10, 20]);
- assert_eq!(v2[0], 20);
- assert_eq!(v2[1], 10);
- v[0] = 30;
- assert_eq!(v2[0], 20);
- // Make sure they work with 0-length vectors too.
-
- let v4 = reversed::<int>([]);
- assert_eq!(v4, ~[]);
+
let mut v3: ~[int] = ~[];
v3.reverse();
- }
-
- #[test]
- fn reversed_mut() {
- let v2 = reversed::<int>([10, 20]);
- assert_eq!(v2[0], 20);
- assert_eq!(v2[1], 10);
+ assert!(v3.is_empty());
}
#[test]