diff --git a/src/bench/matrix.rs b/src/bench/matrix.rs
index 7f36dc7..7545aaa 100644
--- a/src/bench/matrix.rs
+++ b/src/bench/matrix.rs
@@ -62,420 +62,420 @@ pub mod mat4 {
 #[bench]
 fn bench_mat2_mul_m(b: &mut extra::test::BenchHarness) {
     let mut mat_a = mat2::A.clone();
-    do b.iter {
+    b.iter(|| {
         for _ in range(0, 1000) {
             mat_a = mat_a.mul_m(&mat2::B);
         }
-    }
+    })
 }
 
 #[bench]
 fn bench_mat3_mul_m(b: &mut extra::test::BenchHarness) {
     let mut mat_a = mat3::A.clone();
-    do b.iter {
+    b.iter(|| {
         for _ in range(0, 1000) {
             mat_a = mat_a.mul_m(&mat3::B);
         }
-    }
+    })
 }
 
 #[bench]
 fn bench_mat4_mul_m(b: &mut extra::test::BenchHarness) {
     let mut mat_a = mat4::A.clone();
-    do b.iter {
+    b.iter(|| {
         for _ in range(0, 1000) {
             mat_a = mat_a.mul_m(&mat4::B);
         }
-    }
+    })
 }
 
 #[bench]
 fn bench_mat2_add_m(b: &mut extra::test::BenchHarness) {
     let mut mat_a = mat2::A.clone();
-    do b.iter {
+    b.iter(|| {
         for _ in range(0, 1000) {
             mat_a = mat_a.add_m(&mat2::B);
         }
-    }
+    })
 }
 
 #[bench]
 fn bench_mat3_add_m(b: &mut extra::test::BenchHarness) {
     let mut mat_a = mat3::A.clone();
-    do b.iter {
+    b.iter(|| {
         for _ in range(0, 1000) {
             mat_a = mat_a.add_m(&mat3::B);
         }
-    }
+    })
 }
 
 #[bench]
 fn bench_mat4_add_m(b: &mut extra::test::BenchHarness) {
     let mut mat_a = mat4::A.clone();
-    do b.iter {
+    b.iter(|| {
         for _ in range(0, 1000) {
             mat_a = mat_a.add_m(&mat4::B);
         }
-    }
+    })
 }
 
 #[bench]
 fn bench_mat2_sub_m(b: &mut extra::test::BenchHarness) {
     let mut mat_a = mat2::A.clone();
-    do b.iter {
+    b.iter(|| {
         for _ in range(0, 1000) {
             mat_a = mat_a.sub_m(&mat2::B);
         }
-    }
+    })
 }
 
 #[bench]
 fn bench_mat3_sub_m(b: &mut extra::test::BenchHarness) {
     let mut mat_a = mat3::A.clone();
-    do b.iter {
+    b.iter(|| {
         for _ in range(0, 1000) {
             mat_a = mat_a.sub_m(&mat3::B);
         }
-    }
+    })
 }
 
 #[bench]
 fn bench_mat4_sub_m(b: &mut extra::test::BenchHarness) {
     let mut mat_a = mat4::A.clone();
-    do b.iter {
+    b.iter(|| {
         for _ in range(0, 1000) {
             mat_a = mat_a.sub_m(&mat4::B);
         }
-    }
+    })
 }
 
 #[bench]
 fn bench_mat2_mul_s(b: &mut extra::test::BenchHarness) {
     let mut mat_a = mat2::A.clone();
-    do b.iter {
+    b.iter(|| {
         for _ in range(0, 1000) {
             mat_a = mat_a.mul_s(2.0);
         }
-    }
+    })
 }
 
 #[bench]
 fn bench_mat3_mul_s(b: &mut extra::test::BenchHarness) {
     let mut mat_a = mat3::A.clone();
-    do b.iter {
+    b.iter(|| {
         for _ in range(0, 1000) {
             mat_a = mat_a.mul_s(2.0);
         }
-    }
+    })
 }
 
 #[bench]
 fn bench_mat4_mul_s(b: &mut extra::test::BenchHarness) {
     let mut mat_a = mat4::A.clone();
-    do b.iter {
+    b.iter(|| {
         for _ in range(0, 1000) {
             mat_a = mat_a.mul_s(2.0);
         }
-    }
+    })
 }
 
 #[bench]
 fn bench_mat2_div_s(b: &mut extra::test::BenchHarness) {
     let mut mat_a = mat2::A.clone();
-    do b.iter {
+    b.iter(|| {
         for _ in range(0, 1000) {
             mat_a = mat_a.div_s(2.);
         }
-    }
+    })
 }
 
 #[bench]
 fn bench_mat3_div_s(b: &mut extra::test::BenchHarness) {
     let mut mat_a = mat3::A.clone();
-    do b.iter {
+    b.iter(|| {
         for _ in range(0, 1000) {
             mat_a = mat_a.div_s(2.);
         }
-    }
+    })
 }
 
 #[bench]
 fn bench_mat4_div_s(b: &mut extra::test::BenchHarness) {
     let mut mat_a = mat4::A.clone();
-    do b.iter {
+    b.iter(|| {
         for _ in range(0, 1000) {
             mat_a = mat_a.div_s(2.);
         }
-    }
+    })
 }
 
 #[bench]
 fn bench_mat2_rem_s(b: &mut extra::test::BenchHarness) {
     let mut mat_a = mat2::A.clone();
-    do b.iter {
+    b.iter(|| {
         for _ in range(0, 1000) {
             mat_a = mat_a.rem_s(2.);
         }
-    }
+    })
 }
 
 #[bench]
 fn bench_mat3_rem_s(b: &mut extra::test::BenchHarness) {
     let mut mat_a = mat3::A.clone();
-    do b.iter {
+    b.iter(|| {
         for _ in range(0, 1000) {
             mat_a = mat_a.rem_s(2.);
         }
-    }
+    })
 }
 
 #[bench]
 fn bench_mat4_rem_s(b: &mut extra::test::BenchHarness) {
     let mut mat_a = mat4::A.clone();
-    do b.iter {
+    b.iter(|| {
         for _ in range(0, 1000) {
             mat_a = mat_a.rem_s(2.);
         }
-    }
+    })
 }
 
 #[bench]
 fn bench_mat2_neg_self(b: &mut extra::test::BenchHarness) {
     let mut mat_a = mat2::A.clone();
-    do b.iter {
+    b.iter(|| {
         for _ in range(0, 1000) {
             mat_a.neg_self();
         }
-    }
+    })
 }
 
 #[bench]
 fn bench_mat3_neg_self(b: &mut extra::test::BenchHarness) {
     let mut mat_a = mat3::A.clone();
-    do b.iter {
+    b.iter(|| {
         for _ in range(0, 1000) {
             mat_a.neg_self();
         }
-    }
+    })
 }
 
 #[bench]
 fn bench_mat4_neg_self(b: &mut extra::test::BenchHarness) {
     let mut mat_a = mat4::A.clone();
-    do b.iter {
+    b.iter(|| {
         for _ in range(0, 1000) {
             mat_a.neg_self();
         }
-    }
+    })
 }
 
 #[bench]
 fn bench_mat2_div_self_s(b: &mut extra::test::BenchHarness) {
     let mut mat_a = mat2::A.clone();
-    do b.iter {
+    b.iter(|| {
         for _ in range(0, 1000) {
             mat_a.div_self_s(2.);
         }
-    }
+    })
 }
 
 #[bench]
 fn bench_mat3_div_self_s(b: &mut extra::test::BenchHarness) {
     let mut mat_a = mat3::A.clone();
-    do b.iter {
+    b.iter(|| {
         for _ in range(0, 1000) {
             mat_a.div_self_s(2.);
         }
-    }
+    })
 }
 
 #[bench]
 fn bench_mat4_div_self_s(b: &mut extra::test::BenchHarness) {
     let mut mat_a = mat4::A.clone();
-    do b.iter {
+    b.iter(|| {
         for _ in range(0, 1000) {
             mat_a.div_self_s(2.);
         }
-    }
+    })
 }
 
 #[bench]
 fn bench_mat2_rem_self_s(b: &mut extra::test::BenchHarness) {
     let mut mat_a = mat2::A.clone();
-    do b.iter {
+    b.iter(|| {
         for _ in range(0, 1000) {
             mat_a.rem_self_s(2.);
         }
-    }
+    })
 }
 
 #[bench]
 fn bench_mat3_rem_self_s(b: &mut extra::test::BenchHarness) {
     let mut mat_a = mat3::A.clone();
-    do b.iter {
+    b.iter(|| {
         for _ in range(0, 1000) {
             mat_a.rem_self_s(2.);
         }
-    }
+    })
 }
 
 #[bench]
 fn bench_mat4_rem_self_s(b: &mut extra::test::BenchHarness) {
     let mut mat_a = mat4::A.clone();
-    do b.iter {
+    b.iter(|| {
         for _ in range(0, 1000) {
             mat_a.rem_self_s(2.);
         }
-    }
+    })
 }
 
 #[bench]
 fn bench_mat2_mul_self_m(b: &mut extra::test::BenchHarness) {
     let mut mat_a = mat2::A.clone();
-    do b.iter {
+    b.iter(|| {
         for _ in range(0, 1000) {
             mat_a.mul_self_m(&mat2::B);
         }
-    }
+    })
 }
 
 #[bench]
 fn bench_mat3_mul_self_m(b: &mut extra::test::BenchHarness) {
     let mut mat_a = mat3::A.clone();
-    do b.iter {
+    b.iter(|| {
         for _ in range(0, 1000) {
             mat_a.mul_self_m(&mat3::B);
         }
-    }
+    })
 }
 
 #[bench]
 fn bench_mat4_mul_self_m(b: &mut extra::test::BenchHarness) {
     let mut mat_a = mat4::A.clone();
-    do b.iter {
+    b.iter(|| {
         for _ in range(0, 1000) {
             mat_a.mul_self_m(&mat4::B);
         }
-    }
+    })
 }
 
 #[bench]
 fn bench_mat2_add_self_m(b: &mut extra::test::BenchHarness) {
     let mut mat_a = mat2::A.clone();
-    do b.iter {
+    b.iter(|| {
         for _ in range(0, 1000) {
             mat_a.add_self_m(&mat2::B);
         }
-    }
+    })
 }
 
 #[bench]
 fn bench_mat3_add_self_m(b: &mut extra::test::BenchHarness) {
     let mut mat_a = mat3::A.clone();
-    do b.iter {
+    b.iter(|| {
         for _ in range(0, 1000) {
             mat_a.add_self_m(&mat3::B);
         }
-    }
+    })
 }
 
 #[bench]
 fn bench_mat4_add_self_m(b: &mut extra::test::BenchHarness) {
     let mut mat_a = mat4::A.clone();
-    do b.iter {
+    b.iter(|| {
         for _ in range(0, 1000) {
             mat_a.add_self_m(&mat4::B);
         }
-    }
+    })
 }
 
 #[bench]
 fn bench_mat2_sub_self_m(b: &mut extra::test::BenchHarness) {
     let mut mat_a = mat2::A.clone();
-    do b.iter {
+    b.iter(|| {
         for _ in range(0, 1000) {
             mat_a.sub_self_m(&mat2::B);
         }
-    }
+    })
 }
 
 #[bench]
 fn bench_mat3_sub_self_m(b: &mut extra::test::BenchHarness) {
     let mut mat_a = mat3::A.clone();
-    do b.iter {
+    b.iter(|| {
         for _ in range(0, 1000) {
             mat_a.sub_self_m(&mat3::B);
         }
-    }
+    })
 }
 
 #[bench]
 fn bench_mat4_sub_self_m(b: &mut extra::test::BenchHarness) {
     let mut mat_a = mat4::A.clone();
-    do b.iter {
+    b.iter(|| {
         for _ in range(0, 1000) {
             mat_a.add_self_m(&mat4::B);
         }
-    }
+    })
 }
 
 
 #[bench]
 fn bench_mat2_transpose(b: &mut extra::test::BenchHarness) {
     let mut mat_a = mat2::A.clone();
-    do b.iter {
+    b.iter(|| {
         for _ in range(0, 1000) {
             mat_a = mat_a.transpose();
         }
-    }
+    })
 }
 
 #[bench]
 fn bench_mat3_transpose(b: &mut extra::test::BenchHarness) {
     let mut mat_a = mat3::A.clone();
-    do b.iter {
+    b.iter(|| {
         for _ in range(0, 1000) {
             mat_a = mat_a.transpose();
         }
-    }
+    })
 }
 
 #[bench]
 fn bench_mat4_transpose(b: &mut extra::test::BenchHarness) {
     let mut mat_a = mat4::A.clone();
-    do b.iter {
+    b.iter(|| {
         for _ in range(0, 1000) {
             mat_a = mat_a.transpose();
         }
-    }
+    })
 }
 
 #[bench]
 fn bench_mat2_transpose_self(b: &mut extra::test::BenchHarness) {
     let mut mat_a = mat2::A.clone();
-    do b.iter {
+    b.iter(|| {
         for _ in range(0, 1000) {
             mat_a.transpose_self();
         }
-    }
+    })
 }
 
 #[bench]
 fn bench_mat3_transpose_self(b: &mut extra::test::BenchHarness) {
     let mut mat_a = mat3::A.clone();
-    do b.iter {
+    b.iter(|| {
         for _ in range(0, 1000) {
             mat_a.transpose_self();
         }
-    }
+    })
 }
 
 #[bench]
 fn bench_mat4_transpose_self(b: &mut extra::test::BenchHarness) {
     let mut mat_a = mat4::A.clone();
-    do b.iter {
+    b.iter(|| {
         for _ in range(0, 1000) {
             mat_a.transpose_self();
         }
-    }
+    })
 }
diff --git a/src/cgmath/array.rs b/src/cgmath/array.rs
index 6e06df9..0bae131 100644
--- a/src/cgmath/array.rs
+++ b/src/cgmath/array.rs
@@ -28,7 +28,7 @@ pub trait Array
     fn as_slice<'a>(&'a self) -> &'a Slice;
     fn as_mut_slice<'a>(&'a mut self) -> &'a mut Slice;
     fn from_slice(slice: Slice) -> Self;
-    fn build(builder: &fn(i: uint) -> T) -> Self;
+    fn build(builder: |i: uint| -> T) -> Self;
     fn iter<'a>(&'a self) -> VecIterator<'a, T>;
     fn mut_iter<'a>(&'a mut self) -> VecMutIterator<'a, T>;
 
@@ -40,8 +40,8 @@ pub trait Array
         *self.mut_i(b) = tmp;
     }
 
-    fn fold(&self, f: &fn(&T, &T) -> T) -> T;
-    fn each_mut(&mut self, f: &fn(i: uint, x: &mut T));
+    fn fold(&self, f: |&T, &T| -> T) -> T;
+    fn each_mut(&mut self, f: |i: uint, x: &mut T|);
 }
 
 macro_rules! array(
@@ -73,7 +73,7 @@ macro_rules! array(
             }
 
             #[inline]
-            fn build(builder: &fn(i: uint) -> $T) -> $Self {
+            fn build(builder: |i: uint| -> $T) -> $Self {
                 Array::from_slice(gen_builder!($_n))
             }
 
@@ -88,12 +88,12 @@ macro_rules! array(
             }
 
             #[inline]
-            fn fold(&self, f: &fn(&$T, &$T) -> $T) -> $T {
+            fn fold(&self, f: |&$T, &$T| -> $T) -> $T {
                 gen_fold!($_n)
             }
 
             #[inline]
-            fn each_mut(&mut self, f: &fn(i: uint, x: &mut $T)) {
+            fn each_mut(&mut self, f: |i: uint, x: &mut $T|) {
                 gen_each_mut!($_n)
             }
         }
@@ -101,7 +101,7 @@ macro_rules! array(
 )
 
 #[inline]
-pub fn build<T: Clone, Slice, A: Array<T, Slice>>(builder: &fn(i: uint) -> T) -> A {
+pub fn build<T: Clone, Slice, A: Array<T, Slice>>(builder: |i: uint| -> T) -> A {
     Array::build(builder)
 }