---

yaml
---
r: 63691
b: refs/heads/snap-stage3
c: ca2966c
h: refs/heads/master
i:
  63689: 705e341
  63687: d472828
v: v3

Author: luqmana

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 2d28d645422c1617be58c8ca7ad9a457264ca850
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: e9ac7194ff31792e2eca2c745fbef309a2daba86
+refs/heads/snap-stage3: ca2966c6d04958241f13e61310298a5ff69061e2
 refs/heads/try: 7b78b52e602bb3ea8174f9b2006bff3315f03ef9
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/doc/tutorial-ffi.md

@@ -183,7 +183,7 @@ impl<T: Owned> Unique<T> {
 
 #[unsafe_destructor]
 impl<T: Owned> Drop for Unique<T> {
-    fn finalize(&self) {
+    fn drop(&self) {
         unsafe {
             let x = intrinsics::init(); // dummy value to swap in
             // moving the object out is needed to call the destructor

branches/snap-stage3/doc/tutorial.md

@@ -1552,6 +1552,13 @@ fn each(v: &[int], op: &fn(v: &int)) {
 }
 ~~~~
 
+As an aside, the reason we pass in a *pointer* to an integer rather
+than the integer itself is that this is how the actual `each()`
+function for vectors works. `vec::each` though is a
+[generic](#generics) function, so must be efficient to use for all
+types. Passing the elements by pointer avoids copying potentially
+large objects.
+
 As a caller, if we use a closure to provide the final operator
 argument, we can write it in a way that has a pleasant, block-like
 structure.
@@ -1609,9 +1616,6 @@ To enable `debug!` logging, set the RUST_LOG environment variable to the name of
 
 ## For loops
 
-> ***Note:*** The closure-based protocol used `for` loop is on the way out. The `for` loop will
-> use iterator objects in the future instead.
-
 The most common way to express iteration in Rust is with a `for`
 loop. Like `do`, `for` is a nice syntax for describing control flow
 with closures.  Additionally, within a `for` loop, `break`, `loop`,
@@ -1636,16 +1640,7 @@ fn each(v: &[int], op: &fn(v: &int) -> bool) -> bool {
 And using this function to iterate over a vector:
 
 ~~~~
-# fn each(v: &[int], op: &fn(v: &int) -> bool) -> bool {
-#    let mut n = 0;
-#    while n < v.len() {
-#        if !op(&v[n]) {
-#            return false;
-#        }
-#        n += 1;
-#    }
-#    return true;
-# }
+# use each = std::vec::each;
 each([2, 4, 8, 5, 16], |n| {
     if *n % 2 != 0 {
         println("found odd number!");
@@ -1661,16 +1656,7 @@ out of the loop, you just write `break`. To skip ahead
 to the next iteration, write `loop`.
 
 ~~~~
-# fn each(v: &[int], op: &fn(v: &int) -> bool) -> bool {
-#    let mut n = 0;
-#    while n < v.len() {
-#        if !op(&v[n]) {
-#            return false;
-#        }
-#        n += 1;
-#    }
-#    return true;
-# }
+# use each = std::vec::each;
 for each([2, 4, 8, 5, 16]) |n| {
     if *n % 2 != 0 {
         println("found odd number!");
@@ -1685,16 +1671,7 @@ normally allowed in closures, in a block that appears as the body of a
 the enclosing function, not just the loop body.
 
 ~~~~
-# fn each(v: &[int], op: &fn(v: &int) -> bool) -> bool {
-#    let mut n = 0;
-#    while n < v.len() {
-#        if !op(&v[n]) {
-#            return false;
-#        }
-#        n += 1;
-#    }
-#    return true;
-# }
+# use each = std::vec::each;
 fn contains(v: &[int], elt: int) -> bool {
     for each(v) |x| {
         if (*x == elt) { return true; }
@@ -1709,16 +1686,7 @@ In these situations it can be convenient to lean on Rust's
 argument patterns to bind `x` to the actual value, not the pointer.
 
 ~~~~
-# fn each(v: &[int], op: &fn(v: &int) -> bool) -> bool {
-#    let mut n = 0;
-#    while n < v.len() {
-#        if !op(&v[n]) {
-#            return false;
-#        }
-#        n += 1;
-#    }
-#    return true;
-# }
+# use each = std::vec::each;
 # fn contains(v: &[int], elt: int) -> bool {
     for each(v) |&x| {
         if (x == elt) { return true; }
@@ -1873,9 +1841,10 @@ vector consisting of the result of applying `function` to each element
 of `vector`:
 
 ~~~~
+# use std::vec;
 fn map<T, U>(vector: &[T], function: &fn(v: &T) -> U) -> ~[U] {
     let mut accumulator = ~[];
-    for vector.iter().advance |element| {
+    for vec::each(vector) |element| {
         accumulator.push(function(element));
     }
     return accumulator;
@@ -2010,7 +1979,7 @@ types by the compiler, and may not be overridden:
 > iterations of the language, and often still are.
 
 Additionally, the `Drop` trait is used to define destructors. This
-trait defines one method called `finalize`, which is automatically
+trait defines one method called `drop`, which is automatically
 called when a value of the type that implements this trait is
 destroyed, either because the value went out of scope or because the
 garbage collector reclaimed it.
@@ -2021,15 +1990,15 @@ struct TimeBomb {
 }
 
 impl Drop for TimeBomb {
-    fn finalize(&self) {
+    fn drop(&self) {
         for self.explosivity.times {
             println("blam!");
         }
     }
 }
 ~~~
 
-It is illegal to call `finalize` directly. Only code inserted by the compiler
+It is illegal to call `drop` directly. Only code inserted by the compiler
 may call it.
 
 ## Declaring and implementing traits

branches/snap-stage3/src/compiletest/runtest.rs

@@ -529,7 +529,7 @@ fn compose_and_run_compiler(
     let extra_link_args = ~[~"-L",
                             aux_output_dir_name(config, testfile).to_str()];
 
-    for props.aux_builds.iter().advance |rel_ab| {
+    for vec::each(props.aux_builds) |rel_ab| {
         let abs_ab = config.aux_base.push_rel(&Path(*rel_ab));
         let aux_args =
             make_compile_args(config, props, ~[~"--lib"] + extra_link_args,

branches/snap-stage3/src/etc/vim/syntax/rust.vim

@@ -15,7 +15,7 @@ syn keyword   rustOperator    as
 
 syn match     rustAssert      "\<assert\(\w\)*!"
 syn match     rustFail        "\<fail\(\w\)*!"
-syn keyword   rustKeyword     break copy do drop extern
+syn keyword   rustKeyword     break copy do extern
 syn keyword   rustKeyword     for if impl let log
 syn keyword   rustKeyword     copy do extern
 syn keyword   rustKeyword     for impl let log

branches/snap-stage3/src/libextra/arc.rs

@@ -247,7 +247,7 @@ struct PoisonOnFail {
 }
 
 impl Drop for PoisonOnFail {
-    fn finalize(&self) {
+    fn drop(&self) {
         unsafe {
             /* assert!(!*self.failed);
                -- might be false in case of cond.wait() */
@@ -521,7 +521,6 @@ mod tests {
     use core::cell::Cell;
     use core::comm;
     use core::task;
-    use core::uint;
 
     #[test]
     fn manually_share_arc() {
@@ -791,20 +790,18 @@ mod tests {
                 }
                 assert_eq!(*state, 42);
                 *state = 31337;
-                // FIXME: #7372: hits type inference bug with iterators
                 // send to other readers
-                for uint::range(0, reader_convos.len()) |i| {
-                    match reader_convos[i] {
+                for vec::each(reader_convos) |x| {
+                    match *x {
                         (ref rc, _) => rc.send(()),
                     }
                 }
             }
             let read_mode = arc.downgrade(write_mode);
             do (&read_mode).read |state| {
-                // FIXME: #7372: hits type inference bug with iterators
                 // complete handshake with other readers
-                for uint::range(0, reader_convos.len()) |i| {
-                    match reader_convos[i] {
+                for vec::each(reader_convos) |x| {
+                    match *x {
                         (_, ref rp) => rp.recv(),
                     }
                 }

branches/snap-stage3/src/libextra/arena.rs

@@ -77,7 +77,7 @@ pub struct Arena {
 
 #[unsafe_destructor]
 impl Drop for Arena {
-    fn finalize(&self) {
+    fn drop(&self) {
         unsafe {
             destroy_chunk(&self.head);
             for self.chunks.each |chunk| {

branches/snap-stage3/src/libextra/c_vec.rs

@@ -57,7 +57,7 @@ struct DtorRes {
 
 #[unsafe_destructor]
 impl Drop for DtorRes {
-    fn finalize(&self) {
+    fn drop(&self) {
         match self.dtor {
             option::None => (),
             option::Some(f) => f()

branches/snap-stage3/src/libextra/future.rs

@@ -44,7 +44,7 @@ pub struct Future<A> {
 // over ~fn's that have pipes and so forth within!
 #[unsafe_destructor]
 impl<A> Drop for Future<A> {
-    fn finalize(&self) {}
+    fn drop(&self) {}
 }
 
 priv enum FutureState<A> {

branches/snap-stage3/src/libextra/getopts.rs

@@ -418,11 +418,10 @@ pub fn opts_str(mm: &Matches, names: &[~str]) -> ~str {
  */
 pub fn opt_strs(mm: &Matches, nm: &str) -> ~[~str] {
     let mut acc: ~[~str] = ~[];
-    let r = opt_vals(mm, nm);
-    for r.iter().advance |v| {
+    for vec::each(opt_vals(mm, nm)) |v| {
         match *v { Val(ref s) => acc.push(copy *s), _ => () }
     }
-    acc
+    return acc;
 }
 
 /// Returns the string argument supplied to a matching option or none

branches/snap-stage3/src/libextra/json.rs

@@ -1123,7 +1123,7 @@ impl Eq for Json {
                     &Object(ref d1) => {
                         if d0.len() == d1.len() {
                             let mut equal = true;
-                            for d0.iter().advance |(k, v0)| {
+                            for d0.each |k, v0| {
                                 match d1.find(k) {
                                     Some(v1) if v0 == v1 => { },
                                     _ => { equal = false; break }
@@ -1186,12 +1186,12 @@ impl Ord for Json {
                         let mut d1_flat = ~[];
 
                         // FIXME #4430: this is horribly inefficient...
-                        for d0.iter().advance |(k, v)| {
+                        for d0.each |k, v| {
                              d0_flat.push((@copy *k, @copy *v));
                         }
                         d0_flat.qsort();
 
-                        for d1.iter().advance |(k, v)| {
+                        for d1.each |k, v| {
                             d1_flat.push((@copy *k, @copy *v));
                         }
                         d1_flat.qsort();
@@ -1326,7 +1326,7 @@ impl<A:ToJson> ToJson for ~[A] {
 impl<A:ToJson + Copy> ToJson for HashMap<~str, A> {
     fn to_json(&self) -> Json {
         let mut d = HashMap::new();
-        for self.iter().advance |(key, value)| {
+        for self.each |key, value| {
             d.insert(copy *key, value.to_json());
         }
         Object(~d)

branches/snap-stage3/src/libextra/net_tcp.rs

@@ -57,7 +57,7 @@ pub struct TcpSocket {
 
 #[unsafe_destructor]
 impl Drop for TcpSocket {
-    fn finalize(&self) {
+    fn drop(&self) {
         tear_down_socket_data(self.socket_data)
     }
 }

branches/snap-stage3/src/libextra/net_url.rs

@@ -207,7 +207,7 @@ pub fn encode_form_urlencoded(m: &HashMap<~str, ~[~str]>) -> ~str {
     let mut out = ~"";
     let mut first = true;
 
-    for m.iter().advance |(key, values)| {
+    for m.each |key, values| {
         let key = encode_plus(*key);
 
         for values.iter().advance |value| {

branches/snap-stage3/src/libextra/rc.rs

@@ -68,7 +68,7 @@ impl<T> Rc<T> {
 
 #[unsafe_destructor]
 impl<T> Drop for Rc<T> {
-    fn finalize(&self) {
+    fn drop(&self) {
         unsafe {
             if self.ptr.is_not_null() {
                 (*self.ptr).count -= 1;
@@ -220,7 +220,7 @@ impl<T> RcMut<T> {
 
 #[unsafe_destructor]
 impl<T> Drop for RcMut<T> {
-    fn finalize(&self) {
+    fn drop(&self) {
         unsafe {
             if self.ptr.is_not_null() {
                 (*self.ptr).count -= 1;

branches/snap-stage3/src/libextra/serialize.rs

@@ -710,7 +710,7 @@ impl<
     fn encode(&self, e: &mut E) {
         do e.emit_map(self.len()) |e| {
             let mut i = 0;
-            for self.iter().advance |(key, val)| {
+            for self.each |key, val| {
                 e.emit_map_elt_key(i, |e| key.encode(e));
                 e.emit_map_elt_val(i, |e| val.encode(e));
                 i += 1;
@@ -744,7 +744,7 @@ impl<
     fn encode(&self, s: &mut S) {
         do s.emit_seq(self.len()) |s| {
             let mut i = 0;
-            for self.iter().advance |e| {
+            for self.each |e| {
                 s.emit_seq_elt(i, |s| e.encode(s));
                 i += 1;
             }