---

yaml
---
r: 205806
b: refs/heads/beta
c: 298a6e6
h: refs/heads/master
v: v3

Author: tshepang

[refs]

@@ -29,7 +29,7 @@ refs/tags/0.12.0: f0c419429ef30723ceaf6b42f9b5a2aeb5d2e2d1
 refs/heads/automation-fail: 1bf06495443584539b958873e04cc2f864ab10e4
 refs/heads/batch: b7fd822592a4fb577552d93010c4a4e14f314346
 refs/heads/building: 126db549b038c84269a1e4fe46f051b2c15d6970
-refs/heads/beta: 52ec8bdf731d9d588f98014f70932b37bf8b0b92
+refs/heads/beta: 298a6e66579e5e56fbe2d67f9a4b92f6e1e58ccc
 refs/heads/windistfix: 7608dbad651f02e837ed05eef3d74a6662a6e928
 refs/tags/1.0.0-alpha: e42bd6d93a1d3433c486200587f8f9e12590a4d7
 refs/heads/tmp: 579e31929feff51dcaf8d444648eff8de735f91a

branches/beta/src/doc/reference.md

@@ -973,7 +973,8 @@ Use declarations support a number of convenient shortcuts:
 
 An example of `use` declarations:
 
-```rust
+```
+# #![feature(core)]
 use std::option::Option::{Some, None};
 use std::collections::hash_map::{self, HashMap};
 
@@ -1030,17 +1031,16 @@ declarations.
 An example of what will and will not work for `use` items:
 
 ```
+# #![feature(core)]
 # #![allow(unused_imports)]
+use foo::core::iter;  // good: foo is at the root of the crate
 use foo::baz::foobaz;    // good: foo is at the root of the crate
 
 mod foo {
+    extern crate core;
 
-    mod example {
-        pub mod iter {}
-    }
-
-    use foo::example::iter; // good: foo is at crate root
-//  use example::iter;      // bad:  core is not at the crate root
+    use foo::core::iter; // good: foo is at crate root
+//  use core::iter;      // bad:  core is not at the crate root
     use self::baz::foobaz;  // good: self refers to module 'foo'
     use foo::bar::foobar;   // good: foo is at crate root
 
@@ -1368,14 +1368,17 @@ a = Animal::Cat;
 
 Enumeration constructors can have either named or unnamed fields:
 
-```rust
+```
+# #![feature(struct_variant)]
+# fn main() {
 enum Animal {
     Dog (String, f64),
     Cat { name: String, weight: f64 }
 }
 
 let mut a: Animal = Animal::Dog("Cocoa".to_string(), 37.2);
 a = Animal::Cat { name: "Spotty".to_string(), weight: 2.7 };
+# }
 ```
 
 In this example, `Cat` is a _struct-like enum variant_,
@@ -1715,6 +1718,17 @@ Functions within external blocks are declared in the same way as other Rust
 functions, with the exception that they may not have a body and are instead
 terminated by a semicolon.
 
+```
+# #![feature(libc)]
+extern crate libc;
+use libc::{c_char, FILE};
+
+extern {
+    fn fopen(filename: *const c_char, mode: *const c_char) -> *mut FILE;
+}
+# fn main() {}
+```
+
 Functions within external blocks may be called by Rust code, just like
 functions defined in Rust. The Rust compiler automatically translates between
 the Rust ABI and the foreign ABI.
@@ -1725,7 +1739,7 @@ By default external blocks assume that the library they are calling uses the
 standard C "cdecl" ABI. Other ABIs may be specified using an `abi` string, as
 shown here:
 
-```ignore
+```{.ignore}
 // Interface to the Windows API
 extern "stdcall" { }
 ```
@@ -3217,7 +3231,55 @@ expression.
 
 In a pattern whose head expression has an `enum` type, a placeholder (`_`)
 stands for a *single* data field, whereas a wildcard `..` stands for *all* the
-fields of a particular variant.
+fields of a particular variant. For example:
+
+```
+#![feature(box_patterns)]
+#![feature(box_syntax)]
+enum List<X> { Nil, Cons(X, Box<List<X>>) }
+
+fn main() {
+    let x: List<i32> = List::Cons(10, box List::Cons(11, box List::Nil));
+
+    match x {
+        List::Cons(_, box List::Nil) => panic!("singleton list"),
+        List::Cons(..)               => return,
+        List::Nil                    => panic!("empty list")
+    }
+}
+```
+
+The first pattern matches lists constructed by applying `Cons` to any head
+value, and a tail value of `box Nil`. The second pattern matches _any_ list
+constructed with `Cons`, ignoring the values of its arguments. The difference
+between `_` and `..` is that the pattern `C(_)` is only type-correct if `C` has
+exactly one argument, while the pattern `C(..)` is type-correct for any enum
+variant `C`, regardless of how many arguments `C` has.
+
+Used inside an array pattern, `..` stands for any number of elements, when the
+`advanced_slice_patterns` feature gate is turned on. This wildcard can be used
+at most once for a given array, which implies that it cannot be used to
+specifically match elements that are at an unknown distance from both ends of a
+array, like `[.., 42, ..]`. If preceded by a variable name, it will bind the
+corresponding slice to the variable. Example:
+
+```
+# #![feature(advanced_slice_patterns, slice_patterns)]
+fn is_symmetric(list: &[u32]) -> bool {
+    match list {
+        [] | [_]                   => true,
+        [x, inside.., y] if x == y => is_symmetric(inside),
+        _                          => false
+    }
+}
+
+fn main() {
+    let sym     = &[0, 1, 4, 2, 4, 1, 0];
+    let not_sym = &[0, 1, 7, 2, 4, 1, 0];
+    assert!(is_symmetric(sym));
+    assert!(!is_symmetric(not_sym));
+}
+```
 
 A `match` behaves differently depending on whether or not the head expression
 is an [lvalue or an rvalue](#lvalues,-rvalues-and-temporaries). If the head
@@ -3236,15 +3298,30 @@ the inside of the match.
 An example of a `match` expression:
 
 ```
-let x = 1;
+#![feature(box_patterns)]
+#![feature(box_syntax)]
+# fn process_pair(a: i32, b: i32) { }
+# fn process_ten() { }
+
+enum List<X> { Nil, Cons(X, Box<List<X>>) }
+
+fn main() {
+    let x: List<i32> = List::Cons(10, box List::Cons(11, box List::Nil));
 
-match x {
-    1 => println!("one"),
-    2 => println!("two"),
-    3 => println!("three"),
-    4 => println!("four"),
-    5 => println!("five"),
-    _ => println!("something else"),
+    match x {
+        List::Cons(a, box List::Cons(b, _)) => {
+            process_pair(a, b);
+        }
+        List::Cons(10, _) => {
+            process_ten();
+        }
+        List::Nil => {
+            return;
+        }
+        _ => {
+            panic!();
+        }
+    }
 }
 ```
 
@@ -3257,12 +3334,28 @@ Subpatterns can also be bound to variables by the use of the syntax `variable @
 subpattern`. For example:
 
 ```
-let x = 1;
+#![feature(box_patterns)]
+#![feature(box_syntax)]
+
+enum List { Nil, Cons(u32, Box<List>) }
 
-match x {
-    e @ 1 ... 5 => println!("got a range element {}", e),
-    _ => println!("anything"),
+fn is_sorted(list: &List) -> bool {
+    match *list {
+        List::Nil | List::Cons(_, box List::Nil) => true,
+        List::Cons(x, ref r @ box List::Cons(_, _)) => {
+            match *r {
+                box List::Cons(y, _) => (x <= y) && is_sorted(&**r),
+                _ => panic!()
+            }
+        }
+    }
+}
+
+fn main() {
+    let a = List::Cons(6, box List::Cons(7, box List::Cons(42, box List::Nil)));
+    assert!(is_sorted(&a));
 }
+
 ```
 
 Patterns can also dereference pointers by using the `&`, `&mut` and `box`

branches/beta/src/doc/trpl/README.md

@@ -165,7 +165,7 @@ fn main() {
 
 Rust has [move semantics][move] by default, so if we want to make a copy of some
 data, we call the `clone()` method. In this example, `y` is no longer a reference
-to the vector stored in `x`, but a copy of its first element, `"Hello"`. Now
+to the vector stored in `x`, but a copy of its first element, `"hello"`. Now
 that we don’t have a reference, our `push()` works just fine.
 
 [move]: move-semantics.html

branches/beta/src/doc/trpl/SUMMARY.md

@@ -14,6 +14,7 @@
     * [Concurrency](concurrency.md)
     * [Error Handling](error-handling.md)
     * [FFI](ffi.md)
+    * [Deref coercions](deref-coercions.md)
 * [Syntax and Semantics](syntax-and-semantics.md)
     * [Variable Bindings](variable-bindings.md)
     * [Functions](functions.md)
@@ -29,15 +30,15 @@
     * [Move semantics](move-semantics.md)
     * [Enums](enums.md)
     * [Match](match.md)
-    * [Structs](structs.md)
     * [Patterns](patterns.md)
+    * [Structs](structs.md)
     * [Method Syntax](method-syntax.md)
+    * [Drop](drop.md)
     * [Vectors](vectors.md)
     * [Strings](strings.md)
-    * [Generics](generics.md)
     * [Traits](traits.md)
     * [Operators and Overloading](operators-and-overloading.md)
-    * [Drop](drop.md)
+    * [Generics](generics.md)
     * [if let](if-let.md)
     * [Trait Objects](trait-objects.md)
     * [Closures](closures.md)
@@ -52,9 +53,8 @@
     * [Casting between types](casting-between-types.md)
     * [Associated Types](associated-types.md)
     * [Unsized Types](unsized-types.md)
-    * [Deref coercions](deref-coercions.md)
     * [Macros](macros.md)
-    * [Raw Pointers](raw-pointers.md)
+    * [`unsafe` Code](unsafe-code.md)
 * [Nightly Rust](nightly-rust.md)
     * [Compiler Plugins](compiler-plugins.md)
     * [Inline Assembly](inline-assembly.md)

branches/beta/src/doc/trpl/casting-between-types.md

@@ -1,89 +1,3 @@
 % Casting Between Types
 
-Rust, with its focus on safety, provides two different ways of casting
-different types between each other. The first, `as`, is for safe casts.
-In contrast, `transmute` allows for arbitrary casting, and is one of the
-most dangerous features of Rust!
-
-# `as`
-
-The `as` keyword does basic casting:
-
-```rust
-let x: i32 = 5;
-
-let y = x as i64;
-```
-
-It only allows certain kinds of casting, however:
-
-```rust,ignore
-let a = [0u8, 0u8, 0u8, 0u8];
-
-let b = a as u32; // four eights makes 32
-```
-
-This errors with:
-
-```text
-error: non-scalar cast: `[u8; 4]` as `u32`
-let b = a as u32; // four eights makes 32
-        ^~~~~~~~
-```
-
-It’s a ‘non-scalar cast’ because we have multiple values here: the four
-elements of the array. These kinds of casts are very dangerous, because they
-make assumptions about the way that multiple underlying strucutres are
-implemented. For this, we need something more dangerous.
-
-# `transmute`
-
-The `transmute` function is provided by a [compiler intrinsic][intrinsics], and
-what it does is very simple, but very scary. It tells Rust to treat a value of
-one type as though it were another type. It does this regardless of the
-typechecking system, and just completely trusts you.
-
-[intrinsic]: intrinsics.html
-
-In our previous example, we know that an array of four `u8`s represents a `u32`
-properly, and so we want to do the cast. Using `transmute` instead of `as`,
-Rust lets us:
-
-```rust
-use std::mem;
-
-unsafe {
-    let a = [0u8, 0u8, 0u8, 0u8];
-
-    let b = mem::transmute::<[u8; 4], u32>(a);
-}
-```
-
-We have to wrap the operation in an `unsafe` block, but this will compile
-successfully. Technically, only the `mem::transmute` call itself needs to be in
-the block, but it's nice in this case to enclose everything related, so you
-know where to look. In this case, the details about `a` are also important, and
-so they're in the block. You'll see code in either style, sometimes the context
-is too far away, and wrapping all of the code in `unsafe` isn't a great idea.
-
-While `transmute` does very little checking, it will at least make sure that
-the types are the same size. This errors:
-
-```rust,ignore
-use std::mem;
-
-unsafe {
-    let a = [0u8, 0u8, 0u8, 0u8];
-
-    let b = mem::transmute::<[u8; 4], u64>(a);
-}
-```
-
-with:
-
-```text
-error: transmute called on types with different sizes: [u8; 4] (32 bits) to u64
-(64 bits)
-```
-
-Other than that, you're on your own!
+Coming Soon