auto merge of #7263 : thestinger/rust/iterator, r=graydon

Author: bors

doc/tutorial-tasks.md

@@ -283,7 +283,7 @@ let ports = do vec::from_fn(3) |init_val| {
 };
 
 // Wait on each port, accumulating the results
-let result = ports.foldl(0, |accum, port| *accum + port.recv() );
+let result = ports.iter().fold(0, |accum, port| accum + port.recv() );
 # fn some_expensive_computation(_i: uint) -> int { 42 }
 ~~~
 

src/compiletest/runtest.rs

@@ -358,7 +358,7 @@ fn check_expected_errors(expected_errors: ~[errors::ExpectedError],
     // is the ending point, and * represents ANSI color codes.
     for ProcRes.stderr.line_iter().advance |line| {
         let mut was_expected = false;
-        for vec::eachi(expected_errors) |i, ee| {
+        for expected_errors.iter().enumerate().advance |(i, ee)| {
             if !found_flags[i] {
                 debug!("prefix=%s ee.kind=%s ee.msg=%s line=%s",
                        prefixes[i], ee.kind, ee.msg, line);

src/libextra/bitv.rs

@@ -639,7 +639,7 @@ impl BitvSet {
         if self.capacity() < other.capacity() {
             self.bitv.storage.grow(other.capacity() / uint::bits, &0);
         }
-        for other.bitv.storage.eachi |i, &w| {
+        for other.bitv.storage.iter().enumerate().advance |(i, &w)| {
             let old = self.bitv.storage[i];
             let new = f(old, w);
             self.bitv.storage[i] = new;
@@ -672,7 +672,7 @@ impl BaseIter<uint> for BitvSet {
     fn size_hint(&self) -> Option<uint> { Some(self.len()) }
 
     fn each(&self, blk: &fn(v: &uint) -> bool) -> bool {
-        for self.bitv.storage.eachi |i, &w| {
+        for self.bitv.storage.iter().enumerate().advance |(i, &w)| {
             if !iterate_bits(i * uint::bits, w, |b| blk(&b)) {
                 return false;
             }
@@ -826,7 +826,7 @@ impl BitvSet {
                    f: &fn(uint, uint, uint) -> bool) -> bool {
         let min = uint::min(self.bitv.storage.len(),
                             other.bitv.storage.len());
-        self.bitv.storage.slice(0, min).eachi(|i, &w| {
+        self.bitv.storage.slice(0, min).iter().enumerate().advance(|(i, &w)| {
             f(i * uint::bits, w, other.bitv.storage[i])
         })
     }
@@ -845,12 +845,12 @@ impl BitvSet {
         let min = uint::min(len1, len2);
 
         /* only one of these loops will execute and that's the point */
-        for self.bitv.storage.slice(min, len1).eachi |i, &w| {
+        for self.bitv.storage.slice(min, len1).iter().enumerate().advance |(i, &w)| {
             if !f(true, (i + min) * uint::bits, w) {
                 return false;
             }
         }
-        for other.bitv.storage.slice(min, len2).eachi |i, &w| {
+        for other.bitv.storage.slice(min, len2).iter().enumerate().advance |(i, &w)| {
             if !f(false, (i + min) * uint::bits, w) {
                 return false;
             }

src/libextra/fileinput.rs

@@ -448,7 +448,7 @@ mod test {
             |i| fmt!("tmp/lib-fileinput-test-fileinput-read-byte-%u.tmp", i)), true);
 
         // 3 files containing 0\n, 1\n, and 2\n respectively
-        for filenames.eachi |i, &filename| {
+        for filenames.iter().enumerate().advance |(i, &filename)| {
             make_file(filename.get_ref(), [fmt!("%u", i)]);
         }
 
@@ -478,7 +478,7 @@ mod test {
             |i| fmt!("tmp/lib-fileinput-test-fileinput-read-%u.tmp", i)), true);
 
         // 3 files containing 1\n, 2\n, and 3\n respectively
-        for filenames.eachi |i, &filename| {
+        for filenames.iter().enumerate().advance |(i, &filename)| {
             make_file(filename.get_ref(), [fmt!("%u", i)]);
         }
 
@@ -498,7 +498,7 @@ mod test {
             3,
             |i| fmt!("tmp/lib-fileinput-test-input-vec-%u.tmp", i)), true);
 
-        for filenames.eachi |i, &filename| {
+        for filenames.iter().enumerate().advance |(i, &filename)| {
             let contents =
                 vec::from_fn(3, |j| fmt!("%u %u", i, j));
             make_file(filename.get_ref(), contents);
@@ -518,7 +518,7 @@ mod test {
             3,
             |i| fmt!("tmp/lib-fileinput-test-input-vec-state-%u.tmp", i)),true);
 
-        for filenames.eachi |i, &filename| {
+        for filenames.iter().enumerate().advance |(i, &filename)| {
             let contents =
                 vec::from_fn(3, |j| fmt!("%u %u", i, j + 1));
             make_file(filename.get_ref(), contents);
@@ -582,7 +582,7 @@ mod test {
             3,
             |i| fmt!("tmp/lib-fileinput-test-next-file-%u.tmp", i)),true);
 
-        for filenames.eachi |i, &filename| {
+        for filenames.iter().enumerate().advance |(i, &filename)| {
             let contents =
                 vec::from_fn(3, |j| fmt!("%u %u", i, j + 1));
             make_file(&filename.get(), contents);

src/libextra/flatpipes.rs

@@ -307,11 +307,11 @@ impl<T,U:Unflattener<T>,P:BytePort> GenericPort<T> for FlatPort<T, U, P> {
 
 impl<T,F:Flattener<T>,C:ByteChan> GenericChan<T> for FlatChan<T, F, C> {
     fn send(&self, val: T) {
-        self.byte_chan.send(CONTINUE.to_vec());
+        self.byte_chan.send(CONTINUE.to_owned());
         let bytes = self.flattener.flatten(val);
         let len = bytes.len() as u64;
         do io::u64_to_be_bytes(len, size_of::<u64>()) |len_bytes| {
-            self.byte_chan.send(len_bytes.to_vec());
+            self.byte_chan.send(len_bytes.to_owned());
         }
         self.byte_chan.send(bytes);
     }
@@ -937,7 +937,7 @@ mod test {
         fn test_try_recv_none3<P:BytePort>(loader: PortLoader<P>) {
             static CONTINUE: [u8, ..4] = [0xAA, 0xBB, 0xCC, 0xDD];
             // The control word is followed by garbage
-            let bytes = CONTINUE.to_vec() + [0];
+            let bytes = CONTINUE.to_owned() + [0];
             let port = loader(bytes);
             let res: Option<int> = port.try_recv();
             assert!(res.is_none());
@@ -959,9 +959,9 @@ mod test {
                 // then undeserializable garbage
                 let len_bytes = do io::u64_to_be_bytes(
                     1, sys::size_of::<u64>()) |len_bytes| {
-                    len_bytes.to_vec()
+                    len_bytes.to_owned()
                 };
-                let bytes = CONTINUE.to_vec() + len_bytes + [0, 0, 0, 0];
+                let bytes = CONTINUE.to_owned() + len_bytes + [0, 0, 0, 0];
 
                 let port = loader(bytes);
 

src/libextra/getopts.rs

@@ -177,7 +177,7 @@ fn name_str(nm: &Name) -> ~str {
 }
 
 fn find_opt(opts: &[Opt], nm: Name) -> Option<uint> {
-    vec::position(opts, |opt| opt.name == nm)
+    opts.iter().position_(|opt| opt.name == nm)
 }
 
 /**

src/libextra/json.rs

@@ -950,7 +950,7 @@ impl serialize::Decoder for Decoder {
             }
             ref json => fail!("invalid variant: %?", *json),
         };
-        let idx = match vec::position(names, |n| str::eq_slice(*n, name)) {
+        let idx = match names.iter().position_(|n| str::eq_slice(*n, name)) {
             Some(idx) => idx,
             None => fail!("Unknown variant name: %?", name),
         };

src/libextra/net_ip.rs

@@ -205,7 +205,7 @@ pub mod v4 {
         }).collect();
         if parts.len() != 4 {
             Err(fmt!("'%s' doesn't have 4 parts", ip))
-        } else if parts.contains(&256) {
+        } else if parts.iter().any_(|x| *x == 256u) {
             Err(fmt!("invalid octal in addr '%s'", ip))
         } else {
             Ok(Ipv4Rep {

src/libextra/net_tcp.rs

@@ -978,7 +978,7 @@ impl io::Writer for TcpSocketBuf {
         let w_result = write_common_impl(socket_data_ptr,
                                          vec::slice(data,
                                                     0,
-                                                    data.len()).to_vec());
+                                                    data.len()).to_owned());
         if w_result.is_err() {
             let err_data = w_result.get_err();
             debug!(

src/libextra/net_url.rs

@@ -519,8 +519,9 @@ fn get_authority(rawurl: &str) ->
     let end = end; // make end immutable so it can be captured
 
     let host_is_end_plus_one: &fn() -> bool = || {
+        let xs = ['?', '#', '/'];
         end+1 == len
-            && !['?', '#', '/'].contains(&(rawurl[end] as char))
+            && !xs.iter().any_(|x| *x == (rawurl[end] as char))
     };
 
     // finish up

src/libextra/num/bigint.rs

@@ -1175,8 +1175,8 @@ mod biguint_tests {
     fn test_cmp() {
         let data = [ &[], &[1], &[2], &[-1], &[0, 1], &[2, 1], &[1, 1, 1]  ]
             .map(|v| BigUint::from_slice(*v));
-        for data.eachi |i, ni| {
-            for vec::slice(data, i, data.len()).eachi |j0, nj| {
+        for data.iter().enumerate().advance |(i, ni)| {
+            for vec::slice(data, i, data.len()).iter().enumerate().advance |(j0, nj)| {
                 let j = j0 + i;
                 if i == j {
                     assert_eq!(ni.cmp(nj), Equal);
@@ -1651,8 +1651,8 @@ mod bigint_tests {
         nums.push(Zero::zero());
         nums.push_all_move(vs.map(|s| BigInt::from_slice(Plus, *s)));
 
-        for nums.eachi |i, ni| {
-            for vec::slice(nums, i, nums.len()).eachi |j0, nj| {
+        for nums.iter().enumerate().advance |(i, ni)| {
+            for vec::slice(nums, i, nums.len()).iter().enumerate().advance |(j0, nj)| {
                 let j = i + j0;
                 if i == j {
                     assert_eq!(ni.cmp(nj), Equal);

src/libextra/serialize.rs

@@ -432,7 +432,7 @@ impl<D:Decoder,T:Decodable<D>> Decodable<D> for @T {
 impl<'self, S:Encoder,T:Encodable<S>> Encodable<S> for &'self [T] {
     fn encode(&self, s: &mut S) {
         do s.emit_seq(self.len()) |s| {
-            for self.eachi |i, e| {
+            for self.iter().enumerate().advance |(i, e)| {
                 s.emit_seq_elt(i, |s| e.encode(s))
             }
         }
@@ -442,7 +442,7 @@ impl<'self, S:Encoder,T:Encodable<S>> Encodable<S> for &'self [T] {
 impl<S:Encoder,T:Encodable<S>> Encodable<S> for ~[T] {
     fn encode(&self, s: &mut S) {
         do s.emit_seq(self.len()) |s| {
-            for self.eachi |i, e| {
+            for self.iter().enumerate().advance |(i, e)| {
                 s.emit_seq_elt(i, |s| e.encode(s))
             }
         }
@@ -462,7 +462,7 @@ impl<D:Decoder,T:Decodable<D>> Decodable<D> for ~[T] {
 impl<S:Encoder,T:Encodable<S>> Encodable<S> for @[T] {
     fn encode(&self, s: &mut S) {
         do s.emit_seq(self.len()) |s| {
-            for self.eachi |i, e| {
+            for self.iter().enumerate().advance |(i, e)| {
                 s.emit_seq_elt(i, |s| e.encode(s))
             }
         }
@@ -901,7 +901,7 @@ pub trait EncoderHelpers {
 impl<S:Encoder> EncoderHelpers for S {
     fn emit_from_vec<T>(&mut self, v: &[T], f: &fn(&mut S, &T)) {
         do self.emit_seq(v.len()) |this| {
-            for v.eachi |i, e| {
+            for v.iter().enumerate().advance |(i, e)| {
                 do this.emit_seq_elt(i) |this| {
                     f(this, e)
                 }

src/libextra/sha1.rs

@@ -36,7 +36,7 @@ use core::vec;
 /// The SHA-1 interface
 trait Sha1 {
     /// Provide message input as bytes
-    fn input(&mut self, &const [u8]);
+    fn input(&mut self, &[u8]);
     /// Provide message input as string
     fn input_str(&mut self, &str);
     /**
@@ -74,9 +74,9 @@ pub fn sha1() -> @Sha1 {
           computed: bool,
           work_buf: @mut ~[u32]};
 
-    fn add_input(st: &mut Sha1State, msg: &const [u8]) {
+    fn add_input(st: &mut Sha1State, msg: &[u8]) {
         assert!((!st.computed));
-        for vec::each_const(msg) |element| {
+        for msg.iter().advance |element| {
             st.msg_block[st.msg_block_idx] = *element;
             st.msg_block_idx += 1u;
             st.len_low += 8u32;
@@ -242,7 +242,7 @@ pub fn sha1() -> @Sha1 {
             self.h[4] = 0xC3D2E1F0u32;
             self.computed = false;
         }
-        fn input(&mut self, msg: &const [u8]) { add_input(self, msg); }
+        fn input(&mut self, msg: &[u8]) { add_input(self, msg); }
         fn input_str(&mut self, msg: &str) {
             add_input(self, msg.as_bytes());
         }

src/libextra/sort.rs

@@ -731,7 +731,7 @@ fn copy_vec<T:Copy>(dest: &mut [T],
                     from: &[T]) {
     assert!(s1+from.len() <= dest.len());
 
-    for from.eachi |i, v| {
+    for from.iter().enumerate().advance |(i, v)| {
         dest[s1+i] = copy *v;
     }
 }
@@ -743,7 +743,7 @@ fn shift_vec<T:Copy>(dest: &mut [T],
                      len: uint) {
     assert!(s1+len <= dest.len());
 
-    let tmp = dest.slice(s2, s2+len).to_vec();
+    let tmp = dest.slice(s2, s2+len).to_owned();
     copy_vec(dest, s1, tmp);
 }
 

src/libextra/terminfo/parser/compiled.rs

@@ -271,7 +271,7 @@ pub fn parse(file: @Reader, longnames: bool) -> Result<~TermInfo, ~str> {
             return Err(~"error: hit EOF before end of string table");
         }
 
-        for string_offsets.eachi |i, v| {
+        for string_offsets.iter().enumerate().advance |(i, v)| {
             let offset = *v;
             if offset == 0xFFFF { // non-entry
                 loop;

src/libextra/treemap.rs

@@ -853,7 +853,7 @@ mod test_treemap {
             for 90.times {
                 let k = rng.gen();
                 let v = rng.gen();
-                if !ctrl.contains(&(k, v)) {
+                if !ctrl.iter().any_(|x| x == &(k, v)) {
                     assert!(map.insert(k, v));
                     ctrl.push((k, v));
                     check_structure(&map);

src/librust/rust.rc

@@ -135,9 +135,9 @@ fn rustc_help() {
 }
 
 fn find_cmd(command_string: &str) -> Option<Command> {
-    do commands.find |command| {
+    do commands.iter().find_ |command| {
         command.cmd == command_string
-    }
+    }.map_consume(|x| copy *x)
 }
 
 fn cmd_help(args: &[~str]) -> ValidUsage {

src/librustc/front/config.rs

@@ -197,13 +197,13 @@ pub fn metas_in_cfg(cfg: ast::crate_cfg,
     // which the item is valid
     let cfg_metas = vec::filter_map(cfg_metas, |i| attr::get_meta_item_list(i));
 
-    if cfg_metas.all(|c| c.is_empty()) { return true; }
+    if cfg_metas.iter().all(|c| c.is_empty()) { return true; }
 
-    cfg_metas.any(|cfg_meta| {
-        cfg_meta.all(|cfg_mi| {
+    cfg_metas.iter().any_(|cfg_meta| {
+        cfg_meta.iter().all(|cfg_mi| {
             match cfg_mi.node {
                 ast::meta_list(s, ref it) if "not" == s
-                    => it.all(|mi| !attr::contains(cfg, *mi)),
+                    => it.iter().all(|mi| !attr::contains(cfg, *mi)),
                 _ => attr::contains(cfg, *cfg_mi)
             }
         })

src/librustc/lib/llvm.rs

@@ -2157,7 +2157,7 @@ pub fn type_to_str_inner(names: @TypeNames, outer0: &[TypeRef], ty: TypeRef)
           _ => {}
         }
 
-        let outer = vec::append_one(outer0.to_vec(), ty);
+        let outer = vec::append_one(outer0.to_owned(), ty);
 
         let kind = llvm::LLVMGetTypeKind(ty);
 

src/librustc/metadata/creader.rs

@@ -85,16 +85,16 @@ fn warn_if_multiple_versions(e: @mut Env,
             *crate_cache[crate_cache.len() - 1].metas
         );
 
-        let (matches, non_matches) =
-            partition(crate_cache.map_to_vec(|&entry| {
-                let othername = loader::crate_name_from_metas(
-                    copy *entry.metas);
-                if name == othername {
-                    Left(entry)
-                } else {
-                    Right(entry)
-                }
-            }));
+        let vec: ~[Either<cache_entry, cache_entry>] = crate_cache.iter().transform(|&entry| {
+            let othername = loader::crate_name_from_metas(
+                copy *entry.metas);
+            if name == othername {
+                Left(entry)
+            } else {
+                Right(entry)
+            }
+        }).collect();
+        let (matches, non_matches) = partition(vec);
 
         assert!(!matches.is_empty());
 

src/librustc/metadata/cstore.rs

@@ -104,7 +104,7 @@ pub fn get_used_crate_files(cstore: &CStore) -> ~[Path] {
 pub fn add_used_library(cstore: &mut CStore, lib: @str) -> bool {
     assert!(!lib.is_empty());
 
-    if cstore.used_libraries.contains(&lib) { return false; }
+    if cstore.used_libraries.iter().any_(|x| x == &lib) { return false; }
     cstore.used_libraries.push(lib);
     true
 }

src/librustc/metadata/encoder.rs

@@ -1014,7 +1014,8 @@ fn encode_info_for_item(ecx: &EncodeContext,
         ebml_w.end_tag();
 
         // Now output the method info for each method.
-        for ty::trait_method_def_ids(tcx, local_def(item.id)).eachi |i, &method_def_id| {
+        let r = ty::trait_method_def_ids(tcx, local_def(item.id));
+        for r.iter().enumerate().advance |(i, &method_def_id)| {
             assert_eq!(method_def_id.crate, ast::local_crate);
 
             let method_ty = ty::method(tcx, method_def_id);