---

yaml
---
r: 42845
b: refs/heads/try
c: 767d2c0
h: refs/heads/master
i:
  42843: 0dd9276
v: v3

Author: pcwalton

[refs]

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

branches/try/doc/rust.md

@@ -1234,7 +1234,7 @@ For example:
 
 ~~~~
 trait Num {
-    static pure fn from_int(n: int) -> Self;
+    static pure fn from_int(n: int) -> self;
 }
 impl float: Num {
     static pure fn from_int(n: int) -> float { n as float }
@@ -1716,12 +1716,15 @@ vec_elems : [expr [',' expr]*] | [expr ',' ".." expr]
 
 A [_vector_](#vector-types) _expression_ is written by enclosing zero or
 more comma-separated expressions of uniform type in square brackets.
+The keyword `mut` can be written after the opening bracket to
+indicate that the elements of the resulting vector may be mutated.
+When no mutability is specified, the vector is immutable.
 
 ~~~~
 [1, 2, 3, 4];
 ["a", "b", "c", "d"];
 [0, ..128];             // vector with 128 zeros
-[0u8, 0u8, 0u8, 0u8];
+[mut 0u8, 0u8, 0u8, 0u8];
 ~~~~
 
 ### Index expressions
@@ -1743,6 +1746,7 @@ task in a _failing state_.
 # do task::spawn_unlinked {
 
 ([1, 2, 3, 4])[0];
+([mut 'x', 'y'])[1] = 'z';
 (["a", "b"])[10]; // fails
 
 # }
@@ -1905,8 +1909,8 @@ No allocation or destruction is entailed.
 An example of three different swap expressions:
 
 ~~~~~~~~
-# let mut x = &mut [0];
-# let mut a = &mut [0];
+# let mut x = &[mut 0];
+# let mut a = &[mut 0];
 # let i = 0;
 # let y = {mut z: 0};
 # let b = {mut c: 0};
@@ -2001,11 +2005,11 @@ the unary copy operator is typically only used to cause an argument to a functio
 An example of a copy expression:
 
 ~~~~
-fn mutate(mut vec: ~[int]) {
+fn mutate(vec: ~[mut int]) {
    vec[0] = 10;
 }
 
-let v = ~[1,2,3];
+let v = ~[mut 1,2,3];
 
 mutate(copy v);   // Pass a copy
 

branches/try/doc/tutorial-tasks.md

@@ -440,8 +440,8 @@ Finally, tasks can be configured to not propagate failure to each
 other at all, using `task::spawn_unlinked` for _isolated failure_.
 
 ~~~
-# fn random() -> uint { 100 }
-# fn sleep_for(i: uint) { for i.times { task::yield() } }
+# fn random() -> int { 100 }
+# fn sleep_for(i: int) { for i.times { task::yield() } }
 # do task::try::<()> {
 let (time1, time2) = (random(), random());
 do task::spawn_unlinked {

branches/try/doc/tutorial.md

@@ -1795,7 +1795,7 @@ Generic `type`, `struct`, and `enum` declarations follow the same pattern:
 type Set<T> = HashMap<T, ()>;
 
 struct Stack<T> {
-    elements: ~[T]
+    elements: ~[mut T]
 }
 
 enum Option<T> {

branches/try/src/libfuzzer/cycles.rs

@@ -43,7 +43,7 @@ type pointy = {
     mut g : fn~()->(),
 
     mut m : ~[maybe_pointy],
-    mut n : ~[maybe_pointy],
+    mut n : ~[mut maybe_pointy],
     mut o : {x : int, y : maybe_pointy}
 };
 // To add: objects; traits; anything type-parameterized?
@@ -58,7 +58,7 @@ fn empty_pointy() -> @pointy {
         mut g : fn~()->(){},
 
         mut m : ~[],
-        mut n : ~[],
+        mut n : ~[mut],
         mut o : {x : 0, y : none}
     }
 }
@@ -68,7 +68,7 @@ fn nop<T>(_x: T) { }
 
 fn test_cycles(r : rand::rng, k: uint, n: uint)
 {
-    let mut v : ~[@pointy] = ~[];
+    let v : ~[mut @pointy] = ~[mut];
 
     // Create a graph with no edges
     range(0u, vlen) {|_i|

branches/try/src/libfuzzer/rand_util.rs

@@ -25,7 +25,7 @@ fn choice<T: copy>(r : rand::rng, v : ~[T]) -> T {
 fn unlikely(r : rand::rng, n : uint) -> bool { under(r, n) == 0u }
 
 // shuffle a vec in place
-fn shuffle<T>(r : rand::rng, &v : ~[T]) {
+fn shuffle<T>(r : rand::rng, &v : ~[mut T]) {
     let i = vec::len(v);
     while i >= 2u {
         // Loop invariant: elements with index >= i have been locked in place.
@@ -86,7 +86,7 @@ fn main()
     log(error, choice(r, ~[10, 20, 30]));
     log(error, if unlikely(r, 5u) { "unlikely" } else { "likely" });
 
-    let mut a = ~[1, 2, 3];
+    let a = ~[mut 1, 2, 3];
     shuffle(r, a);
     log(error, a);
 

branches/try/src/librustdoc/markdown_writer.rs

@@ -156,7 +156,7 @@ fn readclose(fd: libc::c_int) -> ~str {
         let file = os::fdopen(fd);
         let reader = io::FILE_reader(file, false);
         let buf = io::with_bytes_writer(|writer| {
-            let mut bytes = [0, ..4096];
+            let mut bytes = [mut 0, ..4096];
             while !reader.eof() {
                 let nread = reader.read(bytes, bytes.len());
                 writer.write(bytes.view(0, nread));

branches/try/src/libstd/bitv.rs

@@ -106,10 +106,10 @@ impl SmallBitv {
 
 struct BigBitv {
     // only mut b/c of clone and lack of other constructor
-    mut storage: ~[uint]
+    mut storage: ~[mut uint]
 }
 
-fn BigBitv(storage: ~[uint]) -> BigBitv {
+fn BigBitv(storage: ~[mut uint]) -> BigBitv {
     BigBitv {storage: move storage}
 }
 
@@ -233,7 +233,7 @@ pub fn Bitv (nbits: uint, init: bool) -> Bitv {
         let nelems = nbits/uint_bits +
                      if nbits % uint_bits == 0 {0} else {1};
         let elem = if init {!0} else {0};
-        let s = from_elem(nelems, elem);
+        let s = cast_to_mut(from_elem(nelems, elem));
         Big(~BigBitv(move s))
     };
     Bitv {rep: move rep, nbits: nbits}
@@ -518,7 +518,7 @@ impl Bitv: Clone {
             Bitv{nbits: self.nbits, rep: Small(~SmallBitv{bits: b.bits})}
           }
           Big(ref b) => {
-            let mut st = from_elem(self.nbits / uint_bits + 1, 0);
+            let st = cast_to_mut(from_elem(self.nbits / uint_bits + 1, 0));
             let len = st.len();
             for uint::range(0, len) |i| { st[i] = b.storage[i]; };
             Bitv{nbits: self.nbits, rep: Big(~BigBitv{storage: move st})}

branches/try/src/libstd/io_util.rs

@@ -43,7 +43,7 @@ pub impl BufReader {
 }
 
 impl BufReader: Reader {
-    fn read(&self, bytes: &mut [u8], len: uint) -> uint {
+    fn read(&self, bytes: &[mut u8], len: uint) -> uint {
         self.as_bytes_reader(|r| r.read(bytes, len) )
     }
     fn read_byte(&self) -> int {

branches/try/src/libstd/map.rs

@@ -144,7 +144,7 @@ pub mod chained {
 
     struct HashMap_<K, V> {
         mut count: uint,
-        mut chains: ~[Option<@Entry<K,V>>]
+        mut chains: ~[mut Option<@Entry<K,V>>]
     }
 
     pub type T<K, V> = @HashMap_<K, V>;
@@ -209,7 +209,7 @@ pub mod chained {
         fn rehash() {
             let n_old_chains = self.chains.len();
             let n_new_chains: uint = uint::next_power_of_two(n_old_chains+1u);
-            let mut new_chains = chains(n_new_chains);
+            let new_chains = chains(n_new_chains);
             for self.each_entry |entry| {
                 let idx = entry.hash % n_new_chains;
                 entry.next = new_chains[idx];
@@ -458,8 +458,8 @@ pub mod chained {
         }
     }
 
-    fn chains<K,V>(nchains: uint) -> ~[Option<@Entry<K,V>>] {
-        vec::from_elem(nchains, None)
+    fn chains<K,V>(nchains: uint) -> ~[mut Option<@Entry<K,V>>] {
+        vec::cast_to_mut(vec::from_elem(nchains, None))
     }
 
     pub fn mk<K:Eq IterBytes Hash, V: Copy>() -> T<K,V> {

branches/try/src/libstd/net_tcp.rs

@@ -863,7 +863,7 @@ impl TcpSocket {
 
 /// Implementation of `io::reader` trait for a buffered `net::tcp::tcp_socket`
 impl TcpSocketBuf: io::Reader {
-    fn read(&self, buf: &mut [u8], len: uint) -> uint {
+    fn read(&self, buf: &[mut u8], len: uint) -> uint {
         if len == 0 { return 0 }
         let mut count: uint = 0;
 

branches/try/src/libstd/rope.rs

@@ -788,7 +788,7 @@ pub mod node {
      * * forest - The forest. This vector is progressively rewritten during
      *            execution and should be discarded as meaningless afterwards.
      */
-    pub fn tree_from_forest_destructive(forest: &mut [@Node]) -> @Node {
+    pub fn tree_from_forest_destructive(forest: &[mut @Node]) -> @Node {
         let mut i;
         let mut len = vec::len(forest);
         while len > 1u {
@@ -1158,17 +1158,18 @@ pub mod node {
         use core::vec;
 
         pub struct T {
-            mut stack: ~[@Node],
+            stack: ~[mut @Node],
             mut stackpos: int,
         }
 
         pub fn empty() -> T {
-            let mut stack : ~[@Node] = ~[];
+            let stack : ~[mut @Node] = ~[mut];
             T { stack: stack, stackpos: -1 }
         }
 
         pub fn start(node: @Node) -> T {
-            let stack = vec::from_elem(height(node)+1u, node);
+            let stack = vec::cast_to_mut(
+                vec::from_elem(height(node)+1u, node));
             T {
                 stack: stack,
                 stackpos:  0,