---

yaml
---
r: 146862
b: refs/heads/try2
c: 1eca34d
h: refs/heads/master
v: v3

Author: pcwalton

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: 6801bc8f552ce740deb60212903ba43de197689c
+refs/heads/try2: 1eca34de7dd55719cd83153994e5caf2027f62a2
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/libstd/ascii.rs

@@ -290,7 +290,7 @@ impl<'self> AsciiStr for &'self [Ascii] {
 
     #[inline]
     fn eq_ignore_case(self, other: &[Ascii]) -> bool {
-        do self.iter().zip(other.iter()).all |(&a, &b)| { a.eq_ignore_case(b) }
+        self.iter().zip(other.iter()).all(|(&a, &b)| a.eq_ignore_case(b))
     }
 }
 

branches/try2/src/libstd/at_vec.rs

@@ -56,24 +56,24 @@ pub fn build<A>(size: Option<uint>, builder: |push: |v: A||) -> @[A] {
 /// `lhs`. Afterwards, the `lhs` is then returned for use again.
 #[inline]
 pub fn append<T:Clone>(lhs: @[T], rhs: &[T]) -> @[T] {
-    do build(Some(lhs.len() + rhs.len())) |push| {
+    build(Some(lhs.len() + rhs.len()), |push| {
         for x in lhs.iter() {
             push((*x).clone());
         }
         for elt in rhs.iter() {
             push(elt.clone());
         }
-    }
+    })
 }
 
 
 /// Apply a function to each element of a vector and return the results
 pub fn map<T, U>(v: &[T], f: |x: &T| -> U) -> @[U] {
-    do build(Some(v.len())) |push| {
+    build(Some(v.len()), |push| {
         for elem in v.iter() {
             push(f(elem));
         }
-    }
+    })
 }
 
 /**
@@ -83,10 +83,10 @@ pub fn map<T, U>(v: &[T], f: |x: &T| -> U) -> @[U] {
  * to the value returned by the function `op`.
  */
 pub fn from_fn<T>(n_elts: uint, op: |uint| -> T) -> @[T] {
-    do build(Some(n_elts)) |push| {
+    build(Some(n_elts), |push| {
         let mut i: uint = 0u;
         while i < n_elts { push(op(i)); i += 1u; }
-    }
+    })
 }
 
 /**
@@ -96,13 +96,13 @@ pub fn from_fn<T>(n_elts: uint, op: |uint| -> T) -> @[T] {
  * to the value `t`.
  */
 pub fn from_elem<T:Clone>(n_elts: uint, t: T) -> @[T] {
-    do build(Some(n_elts)) |push| {
+    build(Some(n_elts), |push| {
         let mut i: uint = 0u;
         while i < n_elts {
             push(t.clone());
             i += 1u;
         }
-    }
+    })
 }
 
 /**
@@ -137,11 +137,11 @@ impl<T> Clone for @[T] {
 impl<A> FromIterator<A> for @[A] {
     fn from_iterator<T: Iterator<A>>(iterator: &mut T) -> @[A] {
         let (lower, _) = iterator.size_hint();
-        do build(Some(lower)) |push| {
+        build(Some(lower), |push| {
             for x in *iterator {
                 push(x);
             }
-        }
+        })
     }
 }
 
@@ -259,9 +259,9 @@ pub mod raw {
             use rt::local::Local;
             use rt::task::Task;
 
-            do Local::borrow |task: &mut Task| {
+            Local::borrow(|task: &mut Task| {
                 task.heap.realloc(ptr as *mut Box<()>, size) as *()
-            }
+            })
         }
     }
 
@@ -295,11 +295,11 @@ mod test {
     fn test() {
         // Some code that could use that, then:
         fn seq_range(lo: uint, hi: uint) -> @[uint] {
-            do build(None) |push| {
+            build(None, |push| {
                 for i in range(lo, hi) {
                     push(i);
                 }
-            }
+            })
         }
 
         assert_eq!(seq_range(10, 15), @[10, 11, 12, 13, 14]);
@@ -333,9 +333,7 @@ mod test {
     #[bench]
     fn bench_capacity(b: &mut bh) {
         let x = @[1, 2, 3];
-        do b.iter {
-            capacity(x);
-        }
+        b.iter(|| capacity(x));
     }
 
     #[bench]
@@ -359,54 +357,42 @@ mod test {
     fn bench_append(b: &mut bh) {
         let lhs = @[7, ..128];
         let rhs = range(0, 256).to_owned_vec();
-        do b.iter {
-            append(lhs, rhs);
-        }
+        b.iter(|| append(lhs, rhs))
     }
 
     #[bench]
     fn bench_map(b: &mut bh) {
         let elts = range(0, 256).to_owned_vec();
-        do b.iter {
-            map(elts, |x| x*2);
-        }
+        b.iter(|| map(elts, |x| x*2))
     }
 
     #[bench]
     fn bench_from_fn(b: &mut bh) {
-        do b.iter {
-            from_fn(1024, |x| x);
-        }
+        b.iter(|| from_fn(1024, |x| x));
     }
 
     #[bench]
     fn bench_from_elem(b: &mut bh) {
-        do b.iter {
-            from_elem(1024, 0u64);
-        }
+        b.iter(|| from_elem(1024, 0u64));
     }
 
     #[bench]
     fn bench_to_managed_move(b: &mut bh) {
-        do b.iter {
+        b.iter(|| {
             let elts = range(0, 1024).to_owned_vec(); // yikes! can't move out of capture, though
             to_managed_move(elts);
-        }
+        })
     }
 
     #[bench]
     fn bench_to_managed(b: &mut bh) {
         let elts = range(0, 1024).to_owned_vec();
-        do b.iter {
-            to_managed(elts);
-        }
+        b.iter(|| to_managed(elts));
     }
 
     #[bench]
     fn bench_clone(b: &mut bh) {
         let elts = to_managed(range(0, 1024).to_owned_vec());
-        do b.iter {
-            elts.clone();
-        }
+        b.iter(|| elts.clone());
     }
 }