---

yaml
---
r: 177999
b: refs/heads/tmp
c: 60ba03d
h: refs/heads/master
i:
  177997: 9caff13
  177995: 7b39336
  177991: b4c8591
  177983: a186320
v: v3

Author: carllerche

[refs]

@@ -34,4 +34,4 @@ refs/heads/building: 126db549b038c84269a1e4fe46f051b2c15d6970
 refs/heads/beta: 44a287e6eb22ec3c2a687fc156813577464017f7
 refs/heads/windistfix: 7608dbad651f02e837ed05eef3d74a6662a6e928
 refs/tags/1.0.0-alpha: e42bd6d93a1d3433c486200587f8f9e12590a4d7
-refs/heads/tmp: a2aee6290a5ab90db7de881cf945840547d565a8
+refs/heads/tmp: 60ba03d81224d415249345fea535ccb7ca746612

branches/tmp/README.md

@@ -110,14 +110,12 @@ There is a lot more documentation in the [wiki].
 
 The Rust community congregates in a few places:
 
-* [StackOverflow] - Direct questions about using the language here.
-* [users.rust-lang.org] - General discussion, broader questions.
+* [StackOverflow] - Get help here.
+* [/r/rust] - General discussion.
 * [internals.rust-lang.org] - For development of the Rust language itself.
-* [/r/rust] - News and general discussion.
 
 [StackOverflow]: http://stackoverflow.com/questions/tagged/rust
 [/r/rust]: http://reddit.com/r/rust
-[users.rust-lang.org]: http://users.rust-lang.org/
 [internals.rust-lang.org]: http://internals.rust-lang.org/
 
 ## License

branches/tmp/src/compiletest/common.rs

@@ -25,18 +25,17 @@ pub enum Mode {
 }
 
 impl FromStr for Mode {
-    type Err = ();
-    fn from_str(s: &str) -> Result<Mode, ()> {
+    fn from_str(s: &str) -> Option<Mode> {
         match s {
-          "compile-fail" => Ok(CompileFail),
-          "run-fail" => Ok(RunFail),
-          "run-pass" => Ok(RunPass),
-          "run-pass-valgrind" => Ok(RunPassValgrind),
-          "pretty" => Ok(Pretty),
-          "debuginfo-lldb" => Ok(DebugInfoLldb),
-          "debuginfo-gdb" => Ok(DebugInfoGdb),
-          "codegen" => Ok(Codegen),
-          _ => Err(()),
+          "compile-fail" => Some(CompileFail),
+          "run-fail" => Some(RunFail),
+          "run-pass" => Some(RunPass),
+          "run-pass-valgrind" => Some(RunPassValgrind),
+          "pretty" => Some(Pretty),
+          "debuginfo-lldb" => Some(DebugInfoLldb),
+          "debuginfo-gdb" => Some(DebugInfoGdb),
+          "codegen" => Some(Codegen),
+          _ => None,
         }
     }
 }

branches/tmp/src/compiletest/compiletest.rs

@@ -9,20 +9,21 @@
 // except according to those terms.
 
 #![crate_type = "bin"]
-
+#![allow(unknown_features)]
+#![feature(slicing_syntax, unboxed_closures)]
 #![feature(box_syntax)]
-#![feature(collections)]
-#![feature(core)]
 #![feature(int_uint)]
-#![feature(io)]
-#![feature(os)]
-#![feature(path)]
+#![feature(test)]
 #![feature(rustc_private)]
-#![feature(slicing_syntax, unboxed_closures)]
 #![feature(std_misc)]
-#![feature(test)]
+#![feature(path)]
+#![feature(io)]
+#![feature(core)]
+#![feature(collections)]
+#![feature(os)]
 #![feature(unicode)]
 
+#![allow(unstable)]
 #![deny(warnings)]
 
 extern crate test;
@@ -34,6 +35,7 @@ extern crate log;
 use std::os;
 use std::old_io;
 use std::old_io::fs;
+use std::str::FromStr;
 use std::thunk::Thunk;
 use getopts::{optopt, optflag, reqopt};
 use common::Config;
@@ -138,7 +140,9 @@ pub fn parse_config(args: Vec<String> ) -> Config {
         build_base: opt_path(matches, "build-base"),
         aux_base: opt_path(matches, "aux-base"),
         stage_id: matches.opt_str("stage-id").unwrap(),
-        mode: matches.opt_str("mode").unwrap().parse().ok().expect("invalid mode"),
+        mode: FromStr::from_str(matches.opt_str("mode")
+                                       .unwrap()
+                                       .as_slice()).expect("invalid mode"),
         run_ignored: matches.opt_present("ignored"),
         filter: filter,
         logfile: matches.opt_str("logfile").map(|s| Path::new(s)),

branches/tmp/src/compiletest/header.rs

@@ -352,8 +352,8 @@ pub fn gdb_version_to_int(version_string: &str) -> int {
         panic!("{}", error_string);
     }
 
-    let major: int = components[0].parse().ok().expect(error_string);
-    let minor: int = components[1].parse().ok().expect(error_string);
+    let major: int = components[0].parse().expect(error_string);
+    let minor: int = components[1].parse().expect(error_string);
 
     return major * 1000 + minor;
 }
@@ -363,6 +363,6 @@ pub fn lldb_version_to_int(version_string: &str) -> int {
         "Encountered LLDB version string with unexpected format: {}",
         version_string);
     let error_string = error_string.as_slice();
-    let major: int = version_string.parse().ok().expect(error_string);
+    let major: int = version_string.parse().expect(error_string);
     return major;
 }

branches/tmp/src/doc/index.md

@@ -39,12 +39,10 @@ Overflow](http://stackoverflow.com/questions/tagged/rust). Searching for your
 problem might reveal someone who has asked it before!
 
 There is an active [subreddit](http://reddit.com/r/rust) with lots of
-discussion and news about Rust.
+discussion about Rust.
 
-There is also a [user forum](http://users.rust-lang.org), for all
-user-oriented discussion, and a [developer
-forum](http://internals.rust-lang.org/), where the development of Rust
-itself is discussed.
+There is also a [developer forum](http://internals.rust-lang.org/), where the
+development of Rust itself is discussed.
 
 # Specification
 

branches/tmp/src/doc/reference.md

@@ -2994,7 +2994,7 @@ Some examples of call expressions:
 # fn add(x: i32, y: i32) -> i32 { 0 }
 
 let x: i32 = add(1i32, 2i32);
-let pi: Option<f32> = "3.14".parse().ok();
+let pi: Option<f32> = "3.14".parse();
 ```
 
 ### Lambda expressions
@@ -3518,7 +3518,7 @@ An example of each kind:
 ```{rust}
 let vec: Vec<i32> = vec![1, 2, 3];
 let arr: [i32; 3] = [1, 2, 3];
-let s: &[i32] = &vec;
+let s: &[i32] = vec.as_slice();
 ```
 
 As you can see, the `vec!` macro allows you to create a `Vec<T>` easily. The

branches/tmp/src/doc/trpl/guessing-game.md

@@ -400,7 +400,7 @@ a function for that:
 let input = old_io::stdin().read_line()
                        .ok()
                        .expect("Failed to read line");
-let input_num: Option<u32> = input.parse().ok();
+let input_num: Option<u32> = input.parse();
 ```
 
 The `parse` function takes in a `&str` value and converts it into something.
@@ -422,13 +422,11 @@ In this case, we say `x` is a `u32` explicitly, so Rust is able to properly
 tell `random()` what to generate. In a similar fashion, both of these work:
 
 ```{rust,ignore}
-let input_num = "5".parse::<u32>().ok(); // input_num: Option<u32>
-let input_num: Option<u32> = "5".parse().ok(); // input_num: Option<u32>
+let input_num = "5".parse::<u32>(); // input_num: Option<u32>
+let input_num: Option<u32> = "5".parse(); // input_num: Option<u32>
 ```
 
-Here we're converting the `Result` returned by `parse` to an `Option` by using
-the `ok` method as well.  Anyway, with us now converting our input to a number,
-our code looks like this:
+Anyway, with us now converting our input to a number, our code looks like this:
 
 ```{rust,ignore}
 use std::old_io;
@@ -447,7 +445,7 @@ fn main() {
     let input = old_io::stdin().read_line()
                            .ok()
                            .expect("Failed to read line");
-    let input_num: Option<u32> = input.parse().ok();
+    let input_num: Option<u32> = input.parse();
 
     println!("You guessed: {}", input_num);
 
@@ -497,7 +495,7 @@ fn main() {
     let input = old_io::stdin().read_line()
                            .ok()
                            .expect("Failed to read line");
-    let input_num: Option<u32> = input.parse().ok();
+    let input_num: Option<u32> = input.parse();
 
     let num = match input_num {
         Some(num) => num,
@@ -564,7 +562,7 @@ fn main() {
     let input = old_io::stdin().read_line()
                            .ok()
                            .expect("Failed to read line");
-    let input_num: Option<u32> = input.trim().parse().ok();
+    let input_num: Option<u32> = input.trim().parse();
 
     let num = match input_num {
         Some(num) => num,
@@ -640,7 +638,7 @@ fn main() {
         let input = old_io::stdin().read_line()
                                .ok()
                                .expect("Failed to read line");
-        let input_num: Option<u32> = input.trim().parse().ok();
+        let input_num: Option<u32> = input.trim().parse();
 
         let num = match input_num {
             Some(num) => num,
@@ -716,7 +714,7 @@ fn main() {
         let input = old_io::stdin().read_line()
                                .ok()
                                .expect("Failed to read line");
-        let input_num: Option<u32> = input.trim().parse().ok();
+        let input_num: Option<u32> = input.trim().parse();
 
         let num = match input_num {
             Some(num) => num,
@@ -772,7 +770,7 @@ fn main() {
         let input = old_io::stdin().read_line()
                                .ok()
                                .expect("Failed to read line");
-        let input_num: Option<u32> = input.trim().parse().ok();
+        let input_num: Option<u32> = input.trim().parse();
 
         let num = match input_num {
             Some(num) => num,
@@ -849,7 +847,7 @@ fn main() {
         let input = old_io::stdin().read_line()
                                .ok()
                                .expect("Failed to read line");
-        let input_num: Option<u32> = input.trim().parse().ok();
+        let input_num: Option<u32> = input.trim().parse();
 
         let num = match input_num {
             Some(num) => num,

branches/tmp/src/doc/trpl/more-strings.md

@@ -100,7 +100,7 @@ To write a function that's generic over types of strings, use `&str`.
 
 ```
 fn some_string_length(x: &str) -> uint {
-    x.len()
+        x.len()
 }
 
 fn main() {
@@ -110,7 +110,7 @@ fn main() {
 
     let s = "Hello, world".to_string();
 
-    println!("{}", some_string_length(&s));
+    println!("{}", some_string_length(s.as_slice()));
 }
 ```
 

branches/tmp/src/doc/trpl/patterns.md

@@ -174,13 +174,13 @@ match origin {
 }
 ```
 
-If you want to match against a slice or array, you can use `&`:
+If you want to match against a slice or array, you can use `[]`:
 
 ```{rust}
 fn main() {
     let v = vec!["match_this", "1"];
 
-    match &v[] {
+    match v.as_slice() {
         ["match_this", second] => println!("The second element is {}", second),
         _ => {},
     }

branches/tmp/src/doc/trpl/plugins.md

@@ -82,7 +82,7 @@ fn expand_rn(cx: &mut ExtCtxt, sp: Span, args: &[TokenTree])
         }
     };
 
-    let mut text = &text;
+    let mut text = text.as_slice();
     let mut total = 0;
     while !text.is_empty() {
         match NUMERALS.iter().find(|&&(rn, _)| text.starts_with(rn)) {

branches/tmp/src/doc/trpl/standard-input.md

@@ -20,7 +20,7 @@ Let's go over these chunks, one by one:
 std::old_io::stdin();
 ```
 
-This calls a function, `stdin()`, that lives inside the `std::old_io` module. As
+This calls a function, `stdin()`, that lives inside the `std::io` module. As
 you can imagine, everything in `std` is provided by Rust, the 'standard
 library.' We'll talk more about the module system later.
 

branches/tmp/src/doc/trpl/strings.md

@@ -36,16 +36,36 @@ s.push_str(", world.");
 println!("{}", s);
 ```
 
-`String`s will coerece into `&str` with an `&`:
+You can get a `&str` view into a `String` with the `as_slice()` method:
 
-```
+```{rust}
 fn takes_slice(slice: &str) {
     println!("Got: {}", slice);
 }
 
 fn main() {
     let s = "Hello".to_string();
-    takes_slice(&s);
+    takes_slice(s.as_slice());
+}
+```
+
+To compare a String to a constant string, prefer `as_slice()`...
+
+```{rust}
+fn compare(string: String) {
+    if string.as_slice() == "Hello" {
+        println!("yes");
+    }
+}
+```
+
+... over `to_string()`:
+
+```{rust}
+fn compare(string: String) {
+    if string == "Hello".to_string() {
+        println!("yes");
+    }
 }
 ```
 

branches/tmp/src/doc/trpl/unsafe.md

@@ -576,10 +576,6 @@ extern fn panic_fmt(args: &core::fmt::Arguments,
 #[lang = "eh_personality"] extern fn eh_personality() {}
 # #[start] fn start(argc: isize, argv: *const *const u8) -> isize { 0 }
 # fn main() {}
-# mod std {  // for-loops
-#     pub use core::iter;
-#     pub use core::option;
-# }
 ```
 
 Note that there is one extra lang item here which differs from the examples

branches/tmp/src/driver/driver.rs

@@ -8,6 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
 #![cfg_attr(rustc, feature(rustc_private))]
 #![cfg_attr(rustdoc, feature(rustdoc))]