---

yaml
---
r: 42964
b: refs/heads/try
c: 73a7672
h: refs/heads/master
v: v3

Author: catamorphism

[refs]

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

branches/try/doc/rust.md

@@ -1719,12 +1719,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
@@ -1746,6 +1749,7 @@ task in a _failing state_.
 # do task::spawn_unlinked {
 
 ([1, 2, 3, 4])[0];
+([mut 'x', 'y'])[1] = 'z';
 (["a", "b"])[10]; // fails
 
 # }
@@ -1908,8 +1912,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};
@@ -2004,11 +2008,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.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/libcore/either.rs

@@ -150,23 +150,6 @@ pub pure fn unwrap_right<T,U>(eith: Either<T,U>) -> U {
 }
 
 impl<T, U> Either<T, U> {
-    #[inline(always)]
-    fn either<V>(&self, f_left: fn(&T) -> V, f_right: fn(&U) -> V) -> V {
-        either(f_left, f_right, self)
-    }
-
-    #[inline(always)]
-    fn flip(self) -> Either<U, T> { flip(self) }
-
-    #[inline(always)]
-    fn to_result(self) -> Result<U, T> { to_result(self) }
-
-    #[inline(always)]
-    fn is_left(&self) -> bool { is_left(self) }
-
-    #[inline(always)]
-    fn is_right(&self) -> bool { is_right(self) }
-
     #[inline(always)]
     fn unwrap_left(self) -> T { unwrap_left(self) }
 

branches/try/src/libcore/prelude.rs

@@ -12,37 +12,40 @@
 
 /* Reexported core operators */
 
-pub use either::{Either, Left, Right};
 pub use kinds::{Const, Copy, Owned, Durable};
+pub use ops::{Drop};
 pub use ops::{Add, Sub, Mul, Div, Modulo, Neg, Not};
 pub use ops::{BitAnd, BitOr, BitXor};
-pub use ops::{Drop};
 pub use ops::{Shl, Shr, Index};
 pub use option::{Option, Some, None};
 pub use result::{Result, Ok, Err};
 
 /* Reexported types and traits */
 
-pub use clone::Clone;
-pub use cmp::{Eq, Ord};
-pub use container::{Container, Mutable, Map, Set};
-pub use hash::Hash;
-pub use iter::{BaseIter, ExtendedIter, EqIter, CopyableIter};
-pub use iter::{CopyableOrderedIter, CopyableNonstrictIter, Times};
-pub use num::Num;
-pub use path::GenericPath;
 pub use path::Path;
-pub use path::PosixPath;
+pub use path::GenericPath;
 pub use path::WindowsPath;
-pub use pipes::{GenericChan, GenericPort};
-pub use ptr::Ptr;
-pub use str::{StrSlice, Trimmable};
-pub use to_bytes::IterBytes;
-pub use to_str::ToStr;
+pub use path::PosixPath;
+
 pub use tuple::{CopyableTuple, ImmutableTuple, ExtendedTupleOps};
+pub use str::{StrSlice, Trimmable};
+pub use container::{Container, Mutable};
 pub use vec::{CopyableVector, ImmutableVector};
 pub use vec::{ImmutableEqVector, ImmutableCopyableVector};
 pub use vec::{OwnedVector, OwnedCopyableVector};
+pub use iter::{BaseIter, ExtendedIter, EqIter, CopyableIter};
+pub use iter::{CopyableOrderedIter, CopyableNonstrictIter, Times};
+pub use container::{Container, Mutable, Map, Set};
+pub use pipes::{GenericChan, GenericPort};
+
+pub use num::Num;
+pub use ptr::Ptr;
+pub use to_str::ToStr;
+pub use clone::Clone;
+
+pub use cmp::{Eq, Ord};
+pub use hash::Hash;
+pub use to_bytes::IterBytes;
 
 /* Reexported modules */
 

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/librustc/middle/trans/foreign.rs

@@ -42,7 +42,7 @@ use syntax::parse::token::special_idents;
 
 fn abi_info(arch: session::arch) -> cabi::ABIInfo {
     return match arch {
-        arch_x86_64 | arch_arm => x86_64_abi_info(),
+        arch_x86_64 => x86_64_abi_info(),
         _ => cabi::llvm_abi_info()
     }
 }

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/c_vec.rs

@@ -46,11 +46,11 @@ use core::task;
 /**
  * The type representing a foreign chunk of memory
  *
- * Wrapped in a enum for opacity; FIXME #818 when it is possible to have
- * truly opaque types, this should be revisited.
  */
-pub enum CVec<T> {
-    CVecCtor({ base: *mut T, len: uint, rsrc: @DtorRes})
+pub struct CVec<T> {
+    priv base: *mut T,
+    priv len: uint,
+    priv rsrc: @DtorRes
 }
 
 struct DtorRes {
@@ -85,11 +85,11 @@ fn DtorRes(dtor: Option<fn@()>) -> DtorRes {
  * * len - The number of elements in the buffer
  */
 pub unsafe fn CVec<T>(base: *mut T, len: uint) -> CVec<T> {
-    return CVecCtor({
+    return CVec{
         base: base,
         len: len,
         rsrc: @DtorRes(option::None)
-    });
+    };
 }
 
 /**
@@ -105,11 +105,11 @@ pub unsafe fn CVec<T>(base: *mut T, len: uint) -> CVec<T> {
  */
 pub unsafe fn c_vec_with_dtor<T>(base: *mut T, len: uint, dtor: fn@())
   -> CVec<T> {
-    return CVecCtor({
+    return CVec{
         base: base,
         len: len,
         rsrc: @DtorRes(option::Some(dtor))
-    });
+    };
 }
 
 /*
@@ -123,7 +123,7 @@ pub unsafe fn c_vec_with_dtor<T>(base: *mut T, len: uint, dtor: fn@())
  */
 pub fn get<T: Copy>(t: CVec<T>, ofs: uint) -> T {
     assert ofs < len(t);
-    return unsafe { *ptr::mut_offset((*t).base, ofs) };
+    return unsafe { *ptr::mut_offset(t.base, ofs) };
 }
 
 /**
@@ -133,22 +133,18 @@ pub fn get<T: Copy>(t: CVec<T>, ofs: uint) -> T {
  */
 pub fn set<T: Copy>(t: CVec<T>, ofs: uint, v: T) {
     assert ofs < len(t);
-    unsafe { *ptr::mut_offset((*t).base, ofs) = v };
+    unsafe { *ptr::mut_offset(t.base, ofs) = v };
 }
 
 /*
  Section: Elimination forms
  */
 
 /// Returns the length of the vector
-pub pure fn len<T>(t: CVec<T>) -> uint {
-    return (*t).len;
-}
+pub pure fn len<T>(t: CVec<T>) -> uint { t.len }
 
 /// Returns a pointer to the first element of the vector
-pub unsafe fn ptr<T>(t: CVec<T>) -> *mut T {
-    return (*t).base;
-}
+pub unsafe fn ptr<T>(t: CVec<T>) -> *mut T { t.base }
 
 #[cfg(test)]
 mod tests {

branches/try/src/libstd/ebml.rs

@@ -84,22 +84,27 @@ pub mod reader {
         }
     }
 
-    fn vuint_at(data: &[u8], start: uint) -> {val: uint, next: uint} {
+    struct Res {
+        val: uint,
+        next: uint
+    }
+
+    fn vuint_at(data: &[u8], start: uint) -> Res {
         let a = data[start];
         if a & 0x80u8 != 0u8 {
-            return {val: (a & 0x7fu8) as uint, next: start + 1u};
+            return Res {val: (a & 0x7fu8) as uint, next: start + 1u};
         }
         if a & 0x40u8 != 0u8 {
-            return {val: ((a & 0x3fu8) as uint) << 8u |
+            return Res {val: ((a & 0x3fu8) as uint) << 8u |
                         (data[start + 1u] as uint),
                     next: start + 2u};
         } else if a & 0x20u8 != 0u8 {
-            return {val: ((a & 0x1fu8) as uint) << 16u |
+            return Res {val: ((a & 0x1fu8) as uint) << 16u |
                         (data[start + 1u] as uint) << 8u |
                         (data[start + 2u] as uint),
                     next: start + 3u};
         } else if a & 0x10u8 != 0u8 {
-            return {val: ((a & 0x0fu8) as uint) << 24u |
+            return Res {val: ((a & 0x0fu8) as uint) << 24u |
                         (data[start + 1u] as uint) << 16u |
                         (data[start + 2u] as uint) << 8u |
                         (data[start + 3u] as uint),

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/md4.rs

@@ -14,7 +14,14 @@ use core::str;
 use core::uint;
 use core::vec;
 
-pub pure fn md4(msg: &[u8]) -> {a: u32, b: u32, c: u32, d: u32} {
+struct Quad {
+    a: u32,
+    b: u32,
+    c: u32,
+    d: u32
+}
+
+pub pure fn md4(msg: &[u8]) -> Quad {
     // subtle: if orig_len is merely uint, then the code below
     // which performs shifts by 32 bits or more has undefined
     // results.
@@ -95,11 +102,11 @@ pub pure fn md4(msg: &[u8]) -> {a: u32, b: u32, c: u32, d: u32} {
         a += aa; b += bb; c += cc; d += dd;
         i += 64u;
     }
-    return {a: a, b: b, c: c, d: d};
+    return Quad {a: a, b: b, c: c, d: d};
 }
 
 pub pure fn md4_str(msg: &[u8]) -> ~str {
-    let {a, b, c, d} = md4(msg);
+    let Quad {a, b, c, d} = md4(msg);
     pure fn app(a: u32, b: u32, c: u32, d: u32, f: fn(u32)) {
         f(a); f(b); f(c); f(d);
     }