---

yaml
---
r: 28668
b: refs/heads/try
c: 3d59ac3
h: refs/heads/master
v: v3

Author: nikomatsakis

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: cd6f24f9d14ac90d167386a56e7a6ac1f0318195
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: cd6f24f9d14ac90d167386a56e7a6ac1f0318195
-refs/heads/try: f3c31a07d742478babfc7cda9d21ea6173ac2f6d
+refs/heads/try: 3d59ac3a1989c2d233b04cc8adc9b058690c2544
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: d0c6ce338884ee21843f4b40bf6bf18d222ce5df

branches/try/doc/tutorial.md

@@ -426,7 +426,7 @@ annotation:
 ~~~~
 // The type of this vector will be inferred based on its use.
 let x = [];
-# vec::map(x, fn&(&&_y:int) -> int { _y });
+# vec::map(x, fn&(_y: &int) -> int { *_y });
 // Explicitly say this is a vector of zero integers.
 let y: [int * 0] = [];
 ~~~~
@@ -1242,7 +1242,7 @@ for crayons.each |crayon| {
 }
 
 // Map vector elements
-let crayon_names = crayons.map(|v| crayon_to_str(v));
+let crayon_names = crayons.map(|v| crayon_to_str(*v));
 let favorite_crayon_name = crayon_names[0];
 
 // Remove whitespace from before and after the string
@@ -1298,7 +1298,7 @@ access local variables in the enclosing scope.
 
 ~~~~
 let mut max = 0;
-(~[1, 2, 3]).map(|x| if x > max { max = x });
+(~[1, 2, 3]).map(|x| if *x > max { max = *x });
 ~~~~
 
 Stack closures are very efficient because their environment is

branches/try/src/cargo/cargo.rs

@@ -195,17 +195,17 @@ fn is_uuid(id: ~str) -> bool {
 
             match i {
                 0u => {
-                    if str::len(part) == 8u {
+                    if part.len() == 8u {
                         correct += 1u;
                     }
                 }
                 1u | 2u | 3u => {
-                    if str::len(part) == 4u {
+                    if part.len() == 4u {
                         correct += 1u;
                     }
                 }
                 4u => {
-                    if str::len(part) == 12u {
+                    if part.len() == 12u {
                         correct += 1u;
                     }
                 }

branches/try/src/libcore/dlist.rs

@@ -437,13 +437,12 @@ impl<T: Copy> DList<T> {
     /// Get data at the list's tail, failing if empty. O(1).
     pure fn tail() -> T { self.tail_n().data }
     /// Get the elements of the list as a vector. O(n).
-    pure fn to_vec() -> ~[mut T] {
-        let mut v = ~[mut];
+    pure fn to_vec() -> ~[T] {
+        let mut v = vec::with_capacity(self.size);
         unsafe {
-            vec::reserve(v, self.size);
             // Take this out of the unchecked when iter's functions are pure
             for self.eachi |index,data| {
-                v[index] = data;
+                v[index] = *data;
             }
         }
         move v

branches/try/src/libcore/dvec.rs

@@ -117,7 +117,7 @@ priv impl<A> DVec<A> {
 impl<A> DVec<A> {
     /// Reserves space for N elements
     fn reserve(count: uint) {
-        vec::reserve(self.data, count)
+        vec::reserve(&mut self.data, count)
     }
 
     /**
@@ -243,7 +243,7 @@ impl<A: Copy> DVec<A> {
         do self.swap |v| {
             let mut v <- v;
             let new_len = vec::len(v) + to_idx - from_idx;
-            vec::reserve(v, new_len);
+            vec::reserve(&mut v, new_len);
             let mut i = from_idx;
             while i < to_idx {
                 vec::push(v, ts[i]);
@@ -313,9 +313,9 @@ impl<A: Copy> DVec<A> {
      */
     fn grow_set_elt(idx: uint, initval: A, val: A) {
         do self.swap |v| {
-            let mut v = vec::to_mut(move v);
+            let mut v = move v;
             vec::grow_set(v, idx, initval, val);
-            move vec::from_mut(v)
+            move v
         }
     }
 
@@ -334,14 +334,28 @@ impl<A: Copy> DVec<A> {
 
     /// Iterates over the elements in reverse order
     #[inline(always)]
-    fn reach(f: fn(A) -> bool) {
-        do self.swap |v| { vec::reach(v, f); move v }
+    fn rev_each(f: fn(v: &A) -> bool) {
+        do self.swap |v| {
+            // FIXME(#2263)---we should be able to write
+            // `vec::rev_each(v, f);` but we cannot write now
+            for vec::rev_each(v) |e| {
+                if !f(e) { break; }
+            }
+            move v
+        }
     }
 
     /// Iterates over the elements and indices in reverse order
     #[inline(always)]
-    fn reachi(f: fn(uint, A) -> bool) {
-        do self.swap |v| { vec::reachi(v, f); move v }
+    fn rev_eachi(f: fn(uint, v: &A) -> bool) {
+        do self.swap |v| {
+            // FIXME(#2263)---we should be able to write
+            // `vec::rev_eachi(v, f);` but we cannot write now
+            for vec::rev_eachi(v) |i, e| {
+                if !f(i, e) { break; }
+            }
+            move v
+        }
     }
 }
 

branches/try/src/libcore/io.rs

@@ -52,14 +52,13 @@ trait ReaderUtil {
 
 impl<T: Reader> T : ReaderUtil {
     fn read_bytes(len: uint) -> ~[u8] {
-        let mut buf = ~[mut];
-        vec::reserve(buf, len);
+        let mut buf = vec::with_capacity(len);
         unsafe { vec::raw::set_len(buf, len); }
 
         let count = self.read(buf, len);
 
         unsafe { vec::raw::set_len(buf, count); }
-        vec::from_mut(move buf)
+        move buf
     }
     fn read_line() -> ~str {
         let mut buf = ~[];
@@ -696,7 +695,7 @@ impl BytesWriter: Writer {
             let buf_len = buf.len();
 
             let count = uint::max(buf_len, self.pos + v_len);
-            vec::reserve(buf, count);
+            vec::reserve(&mut buf, count);
             unsafe { vec::raw::set_len(buf, count); }
 
             let view = vec::mut_view(buf, self.pos, count);
@@ -910,7 +909,7 @@ mod tests {
                     assert(vec::len(res) == len);
                 }
                 assert(vec::slice(ivals, 0u, vec::len(res)) ==
-                       vec::map(res, |x| x as int));
+                       vec::map(res, |x| *x as int));
             }
         }
         let mut i = 0u;

branches/try/src/libcore/iter-trait.rs

@@ -12,7 +12,7 @@ impl<A> IMPL_T<A>: iter::BaseIter<A> {
 }
 
 impl<A> IMPL_T<A>: iter::ExtendedIter<A> {
-    pure fn eachi(blk: fn(uint, A) -> bool) { iter::eachi(self, blk) }
+    pure fn eachi(blk: fn(uint, v: &A) -> bool) { iter::eachi(self, blk) }
     pure fn all(blk: fn(A) -> bool) -> bool { iter::all(self, blk) }
     pure fn any(blk: fn(A) -> bool) -> bool { iter::any(self, blk) }
     pure fn foldl<B>(+b0: B, blk: fn(B, A) -> B) -> B {
@@ -32,7 +32,7 @@ impl<A: Copy> IMPL_T<A>: iter::CopyableIter<A> {
     pure fn filter_to_vec(pred: fn(A) -> bool) -> ~[A] {
         iter::filter_to_vec(self, pred)
     }
-    pure fn map_to_vec<B>(op: fn(A) -> B) -> ~[B] {
+    pure fn map_to_vec<B>(op: fn(v: &A) -> B) -> ~[B] {
         iter::map_to_vec(self, op)
     }
     pure fn to_vec() -> ~[A] { iter::to_vec(self) }

branches/try/src/libcore/iter.rs

@@ -15,7 +15,7 @@ trait BaseIter<A> {
 }
 
 trait ExtendedIter<A> {
-    pure fn eachi(blk: fn(uint, A) -> bool);
+    pure fn eachi(blk: fn(uint, v: &A) -> bool);
     pure fn all(blk: fn(A) -> bool) -> bool;
     pure fn any(blk: fn(A) -> bool) -> bool;
     pure fn foldl<B>(+b0: B, blk: fn(B, A) -> B) -> B;
@@ -36,7 +36,7 @@ trait TimesIx{
 
 trait CopyableIter<A:Copy> {
     pure fn filter_to_vec(pred: fn(A) -> bool) -> ~[A];
-    pure fn map_to_vec<B>(op: fn(A) -> B) -> ~[B];
+    pure fn map_to_vec<B>(op: fn(v: &A) -> B) -> ~[B];
     pure fn to_vec() -> ~[A];
     pure fn find(p: fn(A) -> bool) -> Option<A>;
 }
@@ -66,10 +66,10 @@ trait Buildable<A> {
                                 builder: fn(push: pure fn(+A))) -> self;
 }
 
-pure fn eachi<A,IA:BaseIter<A>>(self: IA, blk: fn(uint, A) -> bool) {
+pure fn eachi<A,IA:BaseIter<A>>(self: IA, blk: fn(uint, v: &A) -> bool) {
     let mut i = 0u;
     for self.each |a| {
-        if !blk(i, *a) { break; }
+        if !blk(i, a) { break; }
         i += 1u;
     }
 }
@@ -97,11 +97,11 @@ pure fn filter_to_vec<A:Copy,IA:BaseIter<A>>(self: IA,
     }
 }
 
-pure fn map_to_vec<A:Copy,B,IA:BaseIter<A>>(self: IA, op: fn(A) -> B)
+pure fn map_to_vec<A:Copy,B,IA:BaseIter<A>>(self: IA, op: fn(v: &A) -> B)
     -> ~[B] {
     do vec::build_sized_opt(self.size_hint()) |push| {
         for self.each |a| {
-            push(op(*a));
+            push(op(a));
         }
     }
 }

branches/try/src/libcore/os.rs

@@ -637,7 +637,7 @@ fn list_dir(p: &Path) -> ~[~str] {
  * This version prepends each entry with the directory.
  */
 fn list_dir_path(p: &Path) -> ~[~Path] {
-    os::list_dir(p).map(|f| ~p.push(f))
+    os::list_dir(p).map(|f| ~p.push(*f))
 }
 
 /// Removes a directory at the specified path
@@ -721,9 +721,8 @@ fn copy_file(from: &Path, to: &Path) -> bool {
             fclose(istream);
             return false;
         }
-        let mut buf : ~[mut u8] = ~[mut];
         let bufsize = 8192u;
-        vec::reserve(buf, bufsize);
+        let mut buf = vec::with_capacity::<u8>(bufsize);
         let mut done = false;
         let mut ok = true;
         while !done {

branches/try/src/libcore/result.rs

@@ -269,8 +269,7 @@ impl<T: Copy, E: Copy> Result<T, E> {
 fn map_vec<T,U:Copy,V:Copy>(
     ts: &[T], op: fn((&T)) -> Result<V,U>) -> Result<~[V],U> {
 
-    let mut vs: ~[V] = ~[];
-    vec::reserve(vs, vec::len(ts));
+    let mut vs: ~[V] = vec::with_capacity(vec::len(ts));
     for vec::each(ts) |t| {
         match op(t) {
           Ok(v) => vec::push(vs, v),
@@ -306,8 +305,7 @@ fn map_vec2<S,T,U:Copy,V:Copy>(ss: &[S], ts: &[T],
 
     assert vec::same_length(ss, ts);
     let n = vec::len(ts);
-    let mut vs = ~[];
-    vec::reserve(vs, n);
+    let mut vs = vec::with_capacity(n);
     let mut i = 0u;
     while i < n {
         match op(ss[i],ts[i]) {

branches/try/src/libcore/str.rs

@@ -669,8 +669,8 @@ pure fn lines(s: &str) -> ~[~str] { split_char(s, '\n') }
  */
 pure fn lines_any(s: &str) -> ~[~str] {
     vec::map(lines(s), |s| {
-        let l = len(s);
-        let mut cp = copy s;
+        let l = len(*s);
+        let mut cp = copy *s;
         if l > 0u && s[l - 1u] == '\r' as u8 {
             unsafe { raw::set_len(&mut cp, l - 1u); }
         }
@@ -1984,7 +1984,7 @@ pure fn as_buf<T>(s: &str, f: fn(*u8, uint) -> T) -> T {
 fn reserve(s: &const ~str, n: uint) {
     unsafe {
         let v: *mut ~[u8] = cast::transmute(copy s);
-        vec::reserve(*v, n + 1);
+        vec::reserve(&mut *v, n + 1);
     }
 }
 
@@ -2077,10 +2077,8 @@ mod raw {
 
     /// Create a Rust string from a *u8 buffer of the given length
     unsafe fn from_buf_len(buf: *const u8, len: uint) -> ~str {
-        let mut v: ~[mut u8] = ~[mut];
-        vec::reserve(v, len + 1u);
-        vec::as_imm_buf(v, |vbuf, _len| {
-            let vbuf = ::cast::transmute_mut_unsafe(vbuf);
+        let mut v: ~[u8] = vec::with_capacity(len + 1);
+        vec::as_mut_buf(v, |vbuf, _len| {
             ptr::memcpy(vbuf, buf as *u8, len)
         });
         vec::raw::set_len(v, len);
@@ -2132,8 +2130,7 @@ mod raw {
             assert (begin <= end);
             assert (end <= n);
 
-            let mut v = ~[];
-            vec::reserve(v, end - begin + 1u);
+            let mut v = vec::with_capacity(end - begin + 1u);
             unsafe {
                 do vec::as_imm_buf(v) |vbuf, _vlen| {
                     let vbuf = ::cast::transmute_mut_unsafe(vbuf);