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

vec: remove BaseIter implementation

Browse source 
I removed the `static-method-test.rs` test because it was heavily based
on `BaseIter` and there are plenty of other more complex uses of static
methods anyway.
This commit is contained in:
Daniel Micay 2013-06-21 08:29:53 -04:00
parent c9342663df
commit d2e9912aea
181 changed files with 796 additions and 876 deletions
Download patch file Download diff file Expand all files Collapse all files

7
src/libstd/at_vec.rs
View file

@ -12,13 +12,14 @@
use cast::transmute;
use container::Container;
use iterator::IteratorUtil;
use kinds::Copy;
use old_iter;
use old_iter::BaseIter;
use option::Option;
use sys;
use uint;
use vec;
use vec::ImmutableVector;
/// Code for dealing with @-vectors. This is pretty incomplete, and
/// contains a bunch of duplication from the code for ~-vectors.
@ -107,7 +108,7 @@ pub fn build_sized_opt<A>(size: Option<uint>,
#[inline]
pub fn append<T:Copy>(lhs: @[T], rhs: &const [T]) -> @[T] {
do build_sized(lhs.len() + rhs.len()) |push| {
for lhs.each |x| { push(copy *x); }
for lhs.iter().advance |x| { push(copy *x); }
for uint::range(0, rhs.len()) |i| { push(copy rhs[i]); }
}
}
@ -116,7 +117,7 @@ pub fn append<T:Copy>(lhs: @[T], rhs: &const [T]) -> @[T] {
/// Apply a function to each element of a vector and return the results
pub fn map<T, U>(v: &[T], f: &fn(x: &T) -> U) -> @[U] {
do build_sized(v.len()) |push| {
for v.each |elem| {
for v.iter().advance |elem| {
push(f(elem));
}
}

8
src/libstd/either.rs
View file

@ -15,11 +15,11 @@
use container::Container;
use cmp::Eq;
use kinds::Copy;
use old_iter::BaseIter;
use iterator::IteratorUtil;
use result::Result;
use result;
use vec;
use vec::OwnedVector;
use vec::{OwnedVector, ImmutableVector};
/// The either type
#[deriving(Clone, Eq)]
@ -45,7 +45,7 @@ pub fn either<T, U, V>(f_left: &fn(&T) -> V,
/// Extracts from a vector of either all the left values
pub fn lefts<T:Copy,U>(eithers: &[Either<T, U>]) -> ~[T] {
do vec::build_sized(eithers.len()) |push| {
for eithers.each |elt| {
for eithers.iter().advance |elt| {
match *elt {
Left(ref l) => { push(copy *l); }
_ => { /* fallthrough */ }
@ -57,7 +57,7 @@ pub fn lefts<T:Copy,U>(eithers: &[Either<T, U>]) -> ~[T] {
/// Extracts from a vector of either all the right values
pub fn rights<T, U: Copy>(eithers: &[Either<T, U>]) -> ~[U] {
do vec::build_sized(eithers.len()) |push| {
for eithers.each |elt| {
for eithers.iter().advance |elt| {
match *elt {
Right(ref r) => { push(copy *r); }
_ => { /* fallthrough */ }

7
src/libstd/hash.rs
View file

@ -22,10 +22,11 @@
#[allow(missing_doc)];
use container::Container;
use old_iter::BaseIter;
use iterator::IteratorUtil;
use rt::io::Writer;
use to_bytes::IterBytes;
use uint;
use vec::ImmutableVector;
// Alias `SipState` to `State`.
pub use State = hash::SipState;
@ -367,7 +368,7 @@ impl Streaming for SipState {
fn result_str(&mut self) -> ~str {
let r = self.result_bytes();
let mut s = ~"";
for r.each |b| {
for r.iter().advance |b| {
s += uint::to_str_radix(*b as uint, 16u);
}
s
@ -469,7 +470,7 @@ mod tests {
fn to_hex_str(r: &[u8, ..8]) -> ~str {
let mut s = ~"";
for (*r).each |b| {
for r.iter().advance |b| {
s += uint::to_str_radix(*b as uint, 16u);
}
s

5
src/libstd/hashmap.rs
View file

@ -20,12 +20,13 @@ use cmp::{Eq, Equiv};
use hash::Hash;
use old_iter::BaseIter;
use old_iter;
use iterator::{IteratorUtil};
use iterator::IteratorUtil;
use option::{None, Option, Some};
use rand::RngUtil;
use rand;
use uint;
use vec;
use vec::ImmutableVector;
use kinds::Copy;
use util::{replace, unreachable};
@ -310,7 +311,7 @@ impl<K:Hash + Eq,V> Map<K, V> for HashMap<K, V> {
/// Visit all key-value pairs
fn each<'a>(&'a self, blk: &fn(&K, &'a V) -> bool) -> bool {
for self.buckets.each |bucket| {
for self.buckets.iter().advance |bucket| {
for bucket.iter().advance |pair| {
if !blk(&pair.key, &pair.value) {
return false;

18
src/libstd/io.rs
View file

@ -57,7 +57,7 @@ use os;
use cast;
use path::Path;
use ops::Drop;
use old_iter::{BaseIter, CopyableIter};
use iterator::IteratorUtil;
use ptr;
use result;
use str;
@ -65,7 +65,7 @@ use str::StrSlice;
use to_str::ToStr;
use uint;
use vec;
use vec::{OwnedVector, OwnedCopyableVector, CopyableVector};
use vec::{ImmutableVector, OwnedVector, OwnedCopyableVector, CopyableVector};
#[allow(non_camel_case_types)] // not sure what to do about this
pub type fd_t = c_int;
@ -1261,7 +1261,7 @@ pub fn mk_file_writer(path: &Path, flags: &[FileFlag])
fn wb() -> c_int { O_WRONLY as c_int }
let mut fflags: c_int = wb();
for flags.each |f| {
for flags.iter().advance |f| {
match *f {
Append => fflags |= O_APPEND as c_int,
Create => fflags |= O_CREAT as c_int,
@ -2015,7 +2015,7 @@ mod tests {
// write the ints to the file
{
let file = io::file_writer(&path, [io::Create]).get();
for uints.each |i| {
for uints.iter().advance |i| {
file.write_le_u64(*i);
}
}
@ -2023,7 +2023,7 @@ mod tests {
// then read them back and check that they are the same
{
let file = io::file_reader(&path).get();
for uints.each |i| {
for uints.iter().advance |i| {
assert_eq!(file.read_le_u64(), *i);
}
}
@ -2037,7 +2037,7 @@ mod tests {
// write the ints to the file
{
let file = io::file_writer(&path, [io::Create]).get();
for uints.each |i| {
for uints.iter().advance |i| {
file.write_be_u64(*i);
}
}
@ -2045,7 +2045,7 @@ mod tests {
// then read them back and check that they are the same
{
let file = io::file_reader(&path).get();
for uints.each |i| {
for uints.iter().advance |i| {
assert_eq!(file.read_be_u64(), *i);
}
}
@ -2059,7 +2059,7 @@ mod tests {
// write the ints to the file
{
let file = io::file_writer(&path, [io::Create]).get();
for ints.each |i| {
for ints.iter().advance |i| {
file.write_be_i32(*i);
}
}
@ -2067,7 +2067,7 @@ mod tests {
// then read them back and check that they are the same
{
let file = io::file_reader(&path).get();
for ints.each |i| {
for ints.iter().advance |i| {
// this tests that the sign extension is working
// (comparing the values as i32 would not test this)
assert_eq!(file.read_be_int_n(4), *i as i64);

36
src/libstd/iter.rs
View file

@ -56,7 +56,7 @@ pub trait FromIter<T> {
///
/// ~~~ {.rust}
/// let xs = ~[1, 2, 3];
/// let ys: ~[int] = do FromIter::from_iter |f| { xs.each(|x| f(*x)) };
/// let ys: ~[int] = do FromIter::from_iter |f| { xs.iter().advance(|x| f(*x)) };
/// assert_eq!(xs, ys);
/// ~~~
pub fn from_iter(iter: &fn(f: &fn(T) -> bool) -> bool) -> Self;
@ -69,8 +69,8 @@ pub trait FromIter<T> {
*
* ~~~ {.rust}
* let xs = ~[1u, 2, 3, 4, 5];
* assert!(any(|&x: &uint| x > 2, |f| xs.each(f)));
* assert!(!any(|&x: &uint| x > 5, |f| xs.each(f)));
* assert!(any(|&x: &uint| x > 2, |f| xs.iter().advance(f)));
* assert!(!any(|&x: &uint| x > 5, |f| xs.iter().advance(f)));
* ~~~
*/
#[inline]
@ -109,7 +109,7 @@ pub fn all<T>(predicate: &fn(T) -> bool,
*
* ~~~ {.rust}
* let xs = ~[1u, 2, 3, 4, 5, 6];
* assert_eq!(*find(|& &x: & &uint| x > 3, |f| xs.each(f)).unwrap(), 4);
* assert_eq!(*find(|& &x: & &uint| x > 3, |f| xs.iter().advance(f)).unwrap(), 4);
* ~~~
*/
#[inline]
@ -130,7 +130,7 @@ pub fn find<T>(predicate: &fn(&T) -> bool,
*
* ~~~ {.rust}
* let xs = ~[8, 2, 3, 1, -5, 9, 11, 15];
* assert_eq!(max(|f| xs.each(f)).unwrap(), &15);
* assert_eq!(max(|f| xs.iter().advance(f)).unwrap(), &15);
* ~~~
*/
#[inline]
@ -156,7 +156,7 @@ pub fn max<T: Ord>(iter: &fn(f: &fn(T) -> bool) -> bool) -> Option<T> {
*
* ~~~ {.rust}
* let xs = ~[8, 2, 3, 1, -5, 9, 11, 15];
* assert_eq!(max(|f| xs.each(f)).unwrap(), &-5);
* assert_eq!(max(|f| xs.iter().advance(f)).unwrap(), &-5);
* ~~~
*/
#[inline]
@ -223,7 +223,7 @@ pub fn fold_ref<T, U>(start: T, iter: &fn(f: &fn(&U) -> bool) -> bool, f: &fn(&m
*
* ~~~ {.rust}
* let xs: ~[int] = ~[1, 2, 3, 4];
* assert_eq!(do sum |f| { xs.each(f) }, 10);
* assert_eq!(do sum |f| { xs.iter().advance(f) }, 10);
* ~~~
*/
#[inline]
@ -238,7 +238,7 @@ pub fn sum<T: Zero + Add<T, T>>(iter: &fn(f: &fn(&T) -> bool) -> bool) -> T {
*
* ~~~ {.rust}
* let xs: ~[int] = ~[1, 2, 3, 4];
* assert_eq!(do product |f| { xs.each(f) }, 24);
* assert_eq!(do product |f| { xs.iter().advance(f) }, 24);
* ~~~
*/
#[inline]
@ -257,15 +257,15 @@ mod tests {
#[test]
fn test_from_iter() {
let xs = ~[1, 2, 3];
let ys: ~[int] = do FromIter::from_iter |f| { xs.each(|x| f(*x)) };
let ys: ~[int] = do FromIter::from_iter |f| { xs.iter().advance(|x| f(*x)) };
assert_eq!(xs, ys);
}
#[test]
fn test_any() {
let xs = ~[1u, 2, 3, 4, 5];
assert!(any(|&x: &uint| x > 2, |f| xs.each(f)));
assert!(!any(|&x: &uint| x > 5, |f| xs.each(f)));
assert!(any(|&x: &uint| x > 2, |f| xs.iter().advance(f)));
assert!(!any(|&x: &uint| x > 5, |f| xs.iter().advance(f)));
}
#[test]
@ -277,19 +277,19 @@ mod tests {
#[test]
fn test_find() {
let xs = ~[1u, 2, 3, 4, 5, 6];
assert_eq!(*find(|& &x: & &uint| x > 3, |f| xs.each(f)).unwrap(), 4);
assert_eq!(*find(|& &x: & &uint| x > 3, |f| xs.iter().advance(f)).unwrap(), 4);
}
#[test]
fn test_max() {
let xs = ~[8, 2, 3, 1, -5, 9, 11, 15];
assert_eq!(max(|f| xs.each(f)).unwrap(), &15);
assert_eq!(max(|f| xs.iter().advance(f)).unwrap(), &15);
}
#[test]
fn test_min() {
let xs = ~[8, 2, 3, 1, -5, 9, 11, 15];
assert_eq!(min(|f| xs.each(f)).unwrap(), &-5);
assert_eq!(min(|f| xs.iter().advance(f)).unwrap(), &-5);
}
#[test]
@ -300,24 +300,24 @@ mod tests {
#[test]
fn test_sum() {
let xs: ~[int] = ~[1, 2, 3, 4];
assert_eq!(do sum |f| { xs.each(f) }, 10);
assert_eq!(do sum |f| { xs.iter().advance(f) }, 10);
}
#[test]
fn test_empty_sum() {
let xs: ~[int] = ~[];
assert_eq!(do sum |f| { xs.each(f) }, 0);
assert_eq!(do sum |f| { xs.iter().advance(f) }, 0);
}
#[test]
fn test_product() {
let xs: ~[int] = ~[1, 2, 3, 4];
assert_eq!(do product |f| { xs.each(f) }, 24);
assert_eq!(do product |f| { xs.iter().advance(f) }, 24);
}
#[test]
fn test_empty_product() {
let xs: ~[int] = ~[];
assert_eq!(do product |f| { xs.each(f) }, 1);
assert_eq!(do product |f| { xs.iter().advance(f) }, 1);
}
}

13
src/libstd/os.rs
View file

@ -224,7 +224,7 @@ pub fn env() -> ~[(~str,~str)] {
fn env_convert(input: ~[~str]) -> ~[(~str, ~str)] {
let mut pairs = ~[];
for input.each |p| {
for input.iter().advance |p| {
let vs: ~[&str] = p.splitn_iter('=', 1).collect();
debug!("splitting: len: %u",
vs.len());
@ -593,7 +593,8 @@ pub fn tmpdir() -> Path {
/// Recursively walk a directory structure
pub fn walk_dir(p: &Path, f: &fn(&Path) -> bool) -> bool {
list_dir(p).each(|q| {
let r = list_dir(p);
r.iter().advance(|q| {
let path = &p.push(*q);
f(path) && (!path_is_dir(path) || walk_dir(path, f))
})
@ -1528,7 +1529,7 @@ mod tests {
fn test_env_getenv() {
let e = env();
assert!(e.len() > 0u);
for e.each |p| {
for e.iter().advance |p| {
let (n, v) = copy *p;
debug!(copy n);
let v2 = getenv(n);
@ -1599,8 +1600,8 @@ mod tests {
setenv("USERPROFILE", "/home/PaloAlto");
assert_eq!(os::homedir(), Some(Path("/home/MountainView")));
oldhome.each(|s| { setenv("HOME", *s); true });
olduserprofile.each(|s| { setenv("USERPROFILE", *s); true });
oldhome.iter().advance(|s| { setenv("HOME", *s); true });
olduserprofile.iter().advance(|s| { setenv("USERPROFILE", *s); true });
}
#[test]
@ -1620,7 +1621,7 @@ mod tests {
// Just assuming that we've got some contents in the current directory
assert!(dirs.len() > 0u);
for dirs.each |dir| {
for dirs.iter().advance |dir| {
debug!(copy *dir);
}
}

9
src/libstd/path.rs
View file

@ -25,8 +25,7 @@ use str;
use str::{Str, StrSlice, StrVector};
use to_str::ToStr;
use ascii::{AsciiCast, AsciiStr};
use old_iter::BaseIter;
use vec::OwnedVector;
use vec::{OwnedVector, ImmutableVector};
#[cfg(windows)]
pub use Path = self::WindowsPath;
@ -596,7 +595,7 @@ impl GenericPath for PosixPath {
fn push_many<S: Str>(&self, cs: &[S]) -> PosixPath {
let mut v = copy self.components;
for cs.each |e| {
for cs.iter().advance |e| {
for e.as_slice().split_iter(windows::is_sep).advance |s| {
if !s.is_empty() {
v.push(s.to_owned())
@ -853,7 +852,7 @@ impl GenericPath for WindowsPath {
fn push_many<S: Str>(&self, cs: &[S]) -> WindowsPath {
let mut v = copy self.components;
for cs.each |e| {
for cs.iter().advance |e| {
for e.as_slice().split_iter(windows::is_sep).advance |s| {
if !s.is_empty() {
v.push(s.to_owned())
@ -915,7 +914,7 @@ impl GenericPath for WindowsPath {
pub fn normalize(components: &[~str]) -> ~[~str] {
let mut cs = ~[];
for components.each |c| {
for components.iter().advance |c| {
if *c == ~"." && components.len() > 1 { loop; }
if *c == ~"" { loop; }
if *c == ~".." && cs.len() != 0 {

9
src/libstd/rand.rs
View file

@ -544,7 +544,7 @@ impl<R: Rng> RngUtil for R {
fn choose_weighted_option<T:Copy>(&mut self, v: &[Weighted<T>])
-> Option<T> {
let mut total = 0u;
for v.each |item| {
for v.iter().advance |item| {
total += item.weight;
}
if total == 0u {
@ -552,7 +552,7 @@ impl<R: Rng> RngUtil for R {
}
let chosen = self.gen_uint_range(0u, total);
let mut so_far = 0u;
for v.each |item| {
for v.iter().advance |item| {
so_far += item.weight;
if so_far > chosen {
return Some(copy item.item);
@ -567,7 +567,7 @@ impl<R: Rng> RngUtil for R {
*/
fn weighted_vec<T:Copy>(&mut self, v: &[Weighted<T>]) -> ~[T] {
let mut r = ~[];
for v.each |item| {
for v.iter().advance |item| {
for uint::range(0u, item.weight) |_i| {
r.push(copy item.item);
}
@ -746,7 +746,8 @@ impl IsaacRng {
}}
);
for [(0, midpoint), (midpoint, 0)].each |&(mr_offset, m2_offset)| {
let r = [(0, midpoint), (midpoint, 0)];
for r.iter().advance |&(mr_offset, m2_offset)| {
for uint::range_step(0, midpoint, 4) |base| {
rngstep!(0, 13);
rngstep!(1, -6);

6
src/libstd/result.rs
View file

@ -16,10 +16,10 @@ use cmp::Eq;
use either;
use either::Either;
use kinds::Copy;
use iterator::IteratorUtil;
use option::{None, Option, Some};
use old_iter::BaseIter;
use vec;
use vec::OwnedVector;
use vec::{OwnedVector, ImmutableVector};
use container::Container;
/// The result type
@ -303,7 +303,7 @@ pub fn map_vec<T,U:Copy,V:Copy>(
ts: &[T], op: &fn(&T) -> Result<V,U>) -> Result<~[V],U> {
let mut vs: ~[V] = vec::with_capacity(ts.len());
for ts.each |t| {
for ts.iter().advance |t| {
match op(t) {
Ok(v) => vs.push(v),
Err(u) => return Err(u)

3
src/libstd/rt/uv/net.rs
View file

@ -389,7 +389,8 @@ mod test {
if status.is_none() {
rtdebug!("got %d bytes", nread);
let buf = buf.unwrap();
for buf.slice(0, nread as uint).each |byte| {
let r = buf.slice(0, nread as uint);
for r.iter().advance |byte| {
assert!(*byte == count as u8);
rtdebug!("%u", *byte as uint);
count += 1;

11
src/libstd/run.rs
View file

@ -582,7 +582,7 @@ pub fn make_command_line(prog: &str, args: &[~str]) -> ~str {
let mut cmd = ~"";
append_arg(&mut cmd, prog);
for args.each |arg| {
for args.iter().advance |arg| {
cmd.push_char(' ');
append_arg(&mut cmd, *arg);
}
@ -698,7 +698,7 @@ fn with_argv<T>(prog: &str, args: &[~str],
cb: &fn(**libc::c_char) -> T) -> T {
let mut argptrs = ~[str::as_c_str(prog, |b| b)];
let mut tmps = ~[];
for args.each |arg| {
for args.iter().advance |arg| {
let t = @copy *arg;
tmps.push(t);
argptrs.push(str::as_c_str(*t, |b| b));
@ -716,7 +716,7 @@ fn with_envp<T>(env: Option<&[(~str, ~str)]>, cb: &fn(*c_void) -> T) -> T {
let mut tmps = ~[];
let mut ptrs = ~[];
for es.each |&(k, v)| {
for es.iter().advance |&(k, v)| {
let kv = @fmt!("%s=%s", k, v);
tmps.push(kv);
ptrs.push(str::as_c_str(*kv, |b| b));
@ -739,7 +739,7 @@ fn with_envp<T>(env: Option<&[(~str, ~str)]>, cb: &fn(*mut c_void) -> T) -> T {
match env {
Some(es) => {
let mut blk = ~[];
for es.each |&(k, v)| {
for es.iter().advance |&(k, v)| {
let kv = fmt!("%s=%s", k, v);
blk.push_all(kv.as_bytes_with_null_consume());
}
@ -1165,7 +1165,8 @@ mod tests {
let mut prog = run_env(None);
let output = str::from_bytes(prog.finish_with_output().output);
for os::env().each |&(k, v)| {
let r = os::env();
for r.iter().advance |&(k, v)| {
// don't check windows magical empty-named variables
assert!(k.is_empty() || output.contains(fmt!("%s=%s", k, v)));
}

10
src/libstd/str.rs
View file

@ -29,7 +29,7 @@ use iterator::{Iterator, IteratorUtil, FilterIterator, AdditiveIterator, MapIter
use libc;
use num::Zero;
use option::{None, Option, Some};
use old_iter::{BaseIter, EqIter};
use old_iter::EqIter;
use ptr;
use ptr::RawPtr;
use to_str::ToStr;
@ -147,7 +147,7 @@ pub fn from_char(ch: char) -> ~str {
pub fn from_chars(chs: &[char]) -> ~str {
let mut buf = ~"";
buf.reserve(chs.len());
for chs.each |ch| {
for chs.iter().advance |ch| {
buf.push_char(*ch)
}
buf
@ -864,7 +864,7 @@ pub mod raw {
unsafe fn push_bytes(s: &mut ~str, bytes: &[u8]) {
let new_len = s.len() + bytes.len();
s.reserve_at_least(new_len);
for bytes.each |byte| { push_byte(&mut *s, *byte); }
for bytes.iter().advance |byte| { push_byte(&mut *s, *byte); }
}
/// Removes the last byte from a string and returns it. (Not UTF-8 safe).
@ -3080,7 +3080,7 @@ mod tests {
0xd801_u16, 0xdc95_u16, 0xd801_u16, 0xdc86_u16,
0x000a_u16 ]) ];
for pairs.each |p| {
for pairs.iter().advance |p| {
let (s, u) = copy *p;
assert!(s.to_utf16() == u);
assert!(from_utf16(u) == s);
@ -3094,7 +3094,7 @@ mod tests {
let s = ~"ศไทย中华Việt Nam";
let v = ~['ศ','ไ','ท','ย','中','华','V','i','ệ','t',' ','N','a','m'];
let mut pos = 0;
for v.each |ch| {
for v.iter().advance |ch| {
assert!(s.char_at(pos) == *ch);
pos += from_char(*ch).len();
}

3
src/libstd/str/ascii.rs
View file

@ -14,7 +14,6 @@ use to_str::{ToStr,ToStrConsume};
use str;
use str::StrSlice;
use cast;
use old_iter::BaseIter;
use iterator::IteratorUtil;
use vec::{CopyableVector, ImmutableVector, OwnedVector};
use to_bytes::IterBytes;
@ -94,7 +93,7 @@ impl<'self> AsciiCast<&'self[Ascii]> for &'self [u8] {
#[inline]
fn is_ascii(&self) -> bool {
for self.each |b| {
for self.iter().advance |b| {
if !b.is_ascii() { return false; }
}
true

5
src/libstd/to_bytes.rs
View file

@ -17,9 +17,10 @@ The `ToBytes` and `IterBytes` traits
use cast;
use io;
use io::Writer;
use iterator::IteratorUtil;
use option::{None, Option, Some};
use old_iter::BaseIter;
use str::StrSlice;
use vec::ImmutableVector;
pub type Cb<'self> = &'self fn(buf: &[u8]) -> bool;
@ -223,7 +224,7 @@ impl IterBytes for f64 {
impl<'self,A:IterBytes> IterBytes for &'self [A] {
#[inline]
fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool {
self.each(|elt| elt.iter_bytes(lsb0, |b| f(b)))
self.iter().advance(|elt| elt.iter_bytes(lsb0, |b| f(b)))
}
}

8
src/libstd/to_str.rs
View file

@ -17,10 +17,12 @@ The `ToStr` trait for converting to strings
use str::OwnedStr;
use hashmap::HashMap;
use hashmap::HashSet;
use iterator::IteratorUtil;
use container::Map;
use hash::Hash;
use cmp::Eq;
use old_iter::BaseIter;
use vec::ImmutableVector;
/// A generic trait for converting a value to a string
pub trait ToStr {
@ -122,7 +124,7 @@ impl<'self,A:ToStr> ToStr for &'self [A] {
#[inline]
fn to_str(&self) -> ~str {
let mut (acc, first) = (~"[", true);
for self.each |elt| {
for self.iter().advance |elt| {
if first {
first = false;
}
@ -140,7 +142,7 @@ impl<A:ToStr> ToStr for ~[A] {
#[inline]
fn to_str(&self) -> ~str {
let mut (acc, first) = (~"[", true);
for self.each |elt| {
for self.iter().advance |elt| {
if first {
first = false;
}
@ -158,7 +160,7 @@ impl<A:ToStr> ToStr for @[A] {
#[inline]
fn to_str(&self) -> ~str {
let mut (acc, first) = (~"[", true);
for self.each |elt| {
for self.iter().advance |elt| {
if first {
first = false;
}

2
src/libstd/trie.rs
View file

@ -373,7 +373,7 @@ pub fn check_integrity<T>(trie: &TrieNode<T>) {
let mut sum = 0;
for trie.children.each |x| {
for trie.children.iter().advance |x| {
match *x {
Nothing => (),
Internal(ref y) => {

2
src/libstd/unstable/sync.rs
View file

@ -237,7 +237,7 @@ mod tests {
}
};
for futures.each |f| { f.recv() }
for futures.iter().advance |f| { f.recv() }
do total.with |total| {
assert!(**total == num_tasks * count)

16
src/libstd/vec.rs
View file

@ -17,7 +17,6 @@ use cast;
use container::{Container, Mutable};
use cmp::{Eq, Ord, TotalEq, TotalOrd, Ordering, Less, Equal, Greater};
use clone::Clone;
use old_iter::BaseIter;
use old_iter;
use iterator::{FromIterator, Iterator, IteratorUtil};
use iter::FromIter;
@ -1025,7 +1024,7 @@ impl<'self, T:Copy> VectorVector<T> for &'self [~[T]] {
pub fn connect_vec(&self, sep: &T) -> ~[T] {
let mut r = ~[];
let mut first = true;
for self.each |&inner| {
for self.iter().advance |&inner| {
if first { first = false; } else { r.push(copy *sep); }
r.push_all(inner);
}
@ -1043,7 +1042,7 @@ impl<'self, T:Copy> VectorVector<T> for &'self [&'self [T]] {
pub fn connect_vec(&self, sep: &T) -> ~[T] {
let mut r = ~[];
let mut first = true;
for self.each |&inner| {
for self.iter().advance |&inner| {
if first { first = false; } else { r.push(copy *sep); }
r.push_all(inner);
}
@ -1749,7 +1748,7 @@ impl<'self,T:Copy> CopyableVector<T> for &'self [T] {
fn to_owned(&self) -> ~[T] {
let mut result = ~[];
reserve(&mut result, self.len());
for self.each |e| {
for self.iter().advance |e| {
result.push(copy *e);
}
result
@ -2399,15 +2398,6 @@ pub mod bytes {
}
}
impl<'self,A> old_iter::BaseIter<A> for &'self [A] {
#[inline]
fn each<'a>(&'a self, blk: &fn(v: &'a A) -> bool) -> bool {
each(*self, blk)
}
#[inline]
fn size_hint(&self) -> Option<uint> { Some(self.len()) }
}
impl<A:Clone> Clone for ~[A] {
#[inline]
fn clone(&self) -> ~[A] {