---

yaml
---
r: 195343
b: refs/heads/snap-stage3
c: 8fe7f1f
h: refs/heads/master
i:
  195341: 6309165
  195339: 86f8ad1
  195335: 71ae3cb
  195327: fd732d2
v: v3

Author: frewsxcv

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 14192d6df5cc714e5c9a3ca70b08f2514d977be2
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: b27ba527c5cee06f43967daf3a0dd01a2258a0fa
+refs/heads/snap-stage3: 8fe7f1fa97884c233eb4b8128197431a9b1506ed
 refs/heads/try: 961e0358e1a5c0faaef606e31e9965742c1643bf
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d

branches/snap-stage3/AUTHORS.txt

@@ -606,7 +606,7 @@ Peter Schuller <[email protected]>
 Peter Williams <[email protected]>
 Peter Zotov <[email protected]>
 Petter Remen <[email protected]>
-Phil Dawes <[email protected]>
+Phil Dawes <[email protected]>
 Phil Ruffwind <[email protected]>
 Philip Munksgaard <[email protected]>
 Philipp Brüschweiler <[email protected]>

branches/snap-stage3/src/doc/trpl/SUMMARY.md

@@ -13,6 +13,7 @@
     * [Looping](looping.md)
     * [Strings](strings.md)
     * [Arrays, Vectors, and Slices](arrays-vectors-and-slices.md)
+    * [Standard Input](standard-input.md)
 * [Intermediate Rust](intermediate.md)
     * [Crates and Modules](crates-and-modules.md)
     * [Testing](testing.md)

branches/snap-stage3/src/doc/trpl/documentation.md

@@ -517,7 +517,7 @@ can be useful when changing some options, or when writing a macro.
 
 ### Re-exports
 
-`rustdoc` will show the documentation for a public re-export in both places:
+`rustdoc` will show the documentation for a publc re-export in both places:
 
 ```ignore
 extern crate foo;

branches/snap-stage3/src/doc/trpl/standard-input.md

@@ -0,0 +1,166 @@
+% Standard Input
+
+Getting input from the keyboard is pretty easy, but uses some things
+we haven't seen before. Here's a simple program that reads some input,
+and then prints it back out:
+
+```{rust,ignore}
+# #![feature(old_io)]
+fn main() {
+    println!("Type something!");
+
+    let input = std::old_io::stdin().read_line().ok().expect("Failed to read line");
+
+    println!("{}", input);
+}
+```
+
+Let's go over these chunks, one by one:
+
+```{rust,ignore}
+std::old_io::stdin();
+```
+
+This calls a function, `stdin()`, that lives inside the `std::old_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.
+
+Since writing the fully qualified name all the time is annoying, we can use
+the `use` statement to import it in:
+
+```{rust}
+# #![feature(old_io)]
+use std::old_io::stdin;
+
+stdin();
+```
+
+However, it's considered better practice to not import individual functions, but
+to import the module, and only use one level of qualification:
+
+```{rust}
+# #![feature(old_io)]
+use std::old_io;
+
+old_io::stdin();
+```
+
+Let's update our example to use this style:
+
+```{rust,ignore}
+use std::old_io;
+
+fn main() {
+    println!("Type something!");
+
+    let input = old_io::stdin().read_line().ok().expect("Failed to read line");
+
+    println!("{}", input);
+}
+```
+
+Next up:
+
+```{rust,ignore}
+.read_line()
+```
+
+The `read_line()` method can be called on the result of `stdin()` to return
+a full line of input. Nice and easy.
+
+```{rust,ignore}
+.ok().expect("Failed to read line");
+```
+
+Do you remember this code?
+
+```{rust}
+enum OptionalInt {
+    Value(i32),
+    Missing,
+}
+
+fn main() {
+    let x = OptionalInt::Value(5);
+    let y = OptionalInt::Missing;
+
+    match x {
+        OptionalInt::Value(n) => println!("x is {}", n),
+        OptionalInt::Missing => println!("x is missing!"),
+    }
+
+    match y {
+        OptionalInt::Value(n) => println!("y is {}", n),
+        OptionalInt::Missing => println!("y is missing!"),
+    }
+}
+```
+
+We had to match each time to see if we had a value or not. In this case,
+though, we _know_ that `x` has a `Value`, but `match` forces us to handle
+the `missing` case. This is what we want 99% of the time, but sometimes, we
+know better than the compiler.
+
+Likewise, `read_line()` does not return a line of input. It _might_ return a
+line of input, though it might also fail to do so. This could happen if our program
+isn't running in a terminal, but as part of a cron job, or some other context
+where there's no standard input. Because of this, `read_line` returns a type
+very similar to our `OptionalInt`: an `IoResult<T>`. We haven't talked about
+`IoResult<T>` yet because it is the *generic* form of our `OptionalInt`.
+Until then, you can think of it as being the same thing, just for any type –
+not just `i32`s.
+
+Rust provides a method on these `IoResult<T>`s called `ok()`, which does the
+same thing as our `match` statement but assumes that we have a valid value.
+We then call `expect()` on the result, which will terminate our program if we
+don't have a valid value. In this case, if we can't get input, our program
+doesn't work, so we're okay with that. In most cases, we would want to handle
+the error case explicitly. `expect()` allows us to give an error message if
+this crash happens.
+
+We will cover the exact details of how all of this works later in the Guide in
+[Error Handling]. For now, this gives you enough of a basic understanding to
+work with.
+
+Back to the code we were working on! Here's a refresher:
+
+```{rust,ignore}
+use std::old_io;
+
+fn main() {
+    println!("Type something!");
+
+    let input = old_io::stdin().read_line().ok().expect("Failed to read line");
+
+    println!("{}", input);
+}
+```
+
+With long lines like this, Rust gives you some flexibility with the whitespace.
+We _could_ write the example like this:
+
+```{rust,ignore}
+use std::old_io;
+
+fn main() {
+    println!("Type something!");
+
+    // here, we'll show the types at each step
+
+    let input = old_io::stdin() // std::old_io::stdio::StdinReader
+                  .read_line() // IoResult<String>
+                  .ok() // Option<String>
+                  .expect("Failed to read line"); // String
+
+    println!("{}", input);
+}
+```
+
+Sometimes, this makes things more readable – sometimes, less. Use your judgement
+here.
+
+That's all you need to get basic input from the standard input! It's not too
+complicated, but there are a number of small parts.
+
+
+[Error Handling]: ./error-handling.html

branches/snap-stage3/src/libcollections/btree/map.rs

@@ -904,7 +904,14 @@ impl<K: Ord, V: Ord> Ord for BTreeMap<K, V> {
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<K: Debug, V: Debug> Debug for BTreeMap<K, V> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        self.iter().fold(f.debug_map(), |b, (k, v)| b.entry(k, v)).finish()
+        try!(write!(f, "{{"));
+
+        for (i, (k, v)) in self.iter().enumerate() {
+            if i != 0 { try!(write!(f, ", ")); }
+            try!(write!(f, "{:?}: {:?}", *k, *v));
+        }
+
+        write!(f, "}}")
     }
 }
 

branches/snap-stage3/src/libcollections/btree/set.rs

@@ -628,7 +628,14 @@ impl<'a, 'b, T: Ord + Clone> BitOr<&'b BTreeSet<T>> for &'a BTreeSet<T> {
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<T: Debug> Debug for BTreeSet<T> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        self.iter().fold(f.debug_set(), |b, e| b.entry(e)).finish()
+        try!(write!(f, "{{"));
+
+        for (i, x) in self.iter().enumerate() {
+            if i != 0 { try!(write!(f, ", ")); }
+            try!(write!(f, "{:?}", *x));
+        }
+
+        write!(f, "}}")
     }
 }
 

branches/snap-stage3/src/libcollections/lib.rs

@@ -40,7 +40,6 @@
 #![feature(str_char)]
 #![feature(convert)]
 #![feature(slice_patterns)]
-#![feature(debug_builders)]
 #![cfg_attr(test, feature(rand, rustc_private, test, hash, collections))]
 #![cfg_attr(test, allow(deprecated))] // rand
 

branches/snap-stage3/src/libcollections/linked_list.rs

@@ -927,7 +927,14 @@ impl<A: Clone> Clone for LinkedList<A> {
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<A: fmt::Debug> fmt::Debug for LinkedList<A> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        self.iter().fold(f.debug_list(), |b, e| b.entry(e)).finish()
+        try!(write!(f, "["));
+
+        for (i, e) in self.iter().enumerate() {
+            if i != 0 { try!(write!(f, ", ")); }
+            try!(write!(f, "{:?}", *e));
+        }
+
+        write!(f, "]")
     }
 }
 

branches/snap-stage3/src/libcollections/slice.rs

@@ -50,8 +50,8 @@
 //!
 //! ## Iteration
 //!
-//! The slices implement `IntoIterator`. The iterator yields references to the
-//! slice elements.
+//! The slices implement `IntoIterator`. The iterators of yield references
+//! to the slice elements.
 //!
 //! ```
 //! let numbers = &[0, 1, 2];