---

yaml
---
r: 42850
b: refs/heads/try
c: 72454f4
h: refs/heads/master
v: v3

Author: dforsyth

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 19dfec2aaf746535de1521f68421f9980dbf25de
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 2f46b763da2c098913884f101b6d71d69af41b49
-refs/heads/try: 7b268e83167a9dc914dfea9ec4d0448cce8ee6e2
+refs/heads/try: 72454f401e3547468819f4dfb67d23f4056aefe1
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: a810c03263670238bccd64cabb12a23a46e3a278

branches/try/doc/tutorial-borrowed-ptr.md

@@ -50,7 +50,7 @@ Suppose we wanted to write a procedure that computed the distance between any
 two points, no matter where they were stored. For example, we might like to
 compute the distance between `on_the_stack` and `shared_box`, or between
 `shared_box` and `unique_box`. One option is to define a function that takes
-two arguments of type `Point`—that is, it takes the points by value. But we
+two arguments of type `Point`—that is, it takes the points by value. But if we
 define it this way, calling the function will cause the points to be
 copied. For points, this is probably not so bad, but often copies are
 expensive. Worse, if the data type contains mutable fields, copying can change

branches/try/src/libcore/vec.rs

@@ -541,8 +541,10 @@ pub fn remove<T>(v: &mut ~[T], i: uint) -> T {
     v.pop()
 }
 
-pub fn consume<T>(mut v: ~[T], f: fn(uint, v: T)) {
+pub fn consume<T>(v: ~[T], f: fn(uint, v: T)) {
     unsafe {
+        let mut v = v; // FIXME(#3488)
+
         do as_mut_buf(v) |p, ln| {
             for uint::range(0, ln) |i| {
                 // NB: This unsafe operation counts on init writing 0s to the
@@ -639,7 +641,8 @@ pub fn push_all<T: Copy>(v: &mut ~[T], rhs: &[const T]) {
 }
 
 #[inline(always)]
-pub fn push_all_move<T>(v: &mut ~[T], mut rhs: ~[T]) {
+pub fn push_all_move<T>(v: &mut ~[T], rhs: ~[T]) {
+    let mut rhs = rhs; // FIXME(#3488)
     reserve(&mut *v, v.len() + rhs.len());
     unsafe {
         do as_mut_buf(rhs) |p, len| {
@@ -1238,7 +1241,8 @@ pub pure fn zip_slice<T: Copy, U: Copy>(v: &[const T], u: &[const U])
  * Returns a vector of tuples, where the i-th tuple contains contains the
  * i-th elements from each of the input vectors.
  */
-pub pure fn zip<T, U>(mut v: ~[T], mut u: ~[U]) -> ~[(T, U)] {
+pub pure fn zip<T, U>(v: ~[T], u: ~[U]) -> ~[(T, U)] {
+    let mut v = v, u = u; // FIXME(#3488)
     let mut i = len(v);
     assert i == len(u);
     let mut w = with_capacity(i);