---

yaml
---
r: 128734
b: refs/heads/try
c: 06d44aa
h: refs/heads/master
v: v3

Author: vadimcn

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 07d86b46a949a94223da714e35b343243e4ecce4
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: a86d9ad15e339ab343a12513f9c90556f677b9ca
-refs/heads/try: c1eaafe8ab2114dd10d87a4983e1263c844f782f
+refs/heads/try: 06d44aaad34a8599e398b5586cdf7d9ab449a7c9
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/CONTRIBUTING.md

@@ -16,8 +16,7 @@ please do two things:
 
 2. Run the full Rust test suite with the `make check` command.  You're
    not off the hook even if you just stick to documentation; code
-   examples in the docs are tested as well! Although for simple
-   wording or grammar fixes, this is probably unnecessary.
+   examples in the docs are tested as well!
 
 Pull requests will be treated as "review requests", and we will give
 feedback we expect to see corrected on

branches/try/README.md

@@ -32,7 +32,7 @@ documentation.
 
     To build from the [tarball] do:
 
-        $ curl -O https://static.rust-lang.org/dist/rust-nightly.tar.gz
+        $ curl -O http://static.rust-lang.org/dist/rust-nightly.tar.gz
         $ tar -xzf rust-nightly.tar.gz
         $ cd rust-nightly
 
@@ -75,7 +75,7 @@ To easily build on windows we can use [MSYS2](http://sourceforge.net/projects/ms
         $ make && make install
 
 [repo]: https://github.com/rust-lang/rust
-[tarball]: https://static.rust-lang.org/dist/rust-nightly.tar.gz
+[tarball]: http://static.rust-lang.org/dist/rust-nightly.tar.gz
 [tutorial]: http://doc.rust-lang.org/tutorial.html
 
 ## Notes

branches/try/mk/main.mk

@@ -139,10 +139,6 @@ endif
 RUSTFLAGS_STAGE0 += -C prefer-dynamic
 RUSTFLAGS_STAGE1 += -C prefer-dynamic
 
-# Landing pads require a lot of codegen. We can get through bootstrapping faster
-# by not emitting them.
-RUSTFLAGS_STAGE0 += -Z no-landing-pads
-
 # platform-specific auto-configuration
 include $(CFG_SRC_DIR)mk/platform.mk
 

branches/try/src/doc/guide-pointers.md

@@ -655,7 +655,7 @@ This part is coming soon.
 # Returning Pointers
 
 In many languages with pointers, you'd return a pointer from a function
-so as to avoid copying a large data structure. For example:
+so as to avoid a copying a large data structure. For example:
 
 ```{rust}
 struct BigStruct {

branches/try/src/doc/guide.md

@@ -27,26 +27,26 @@ Sound good? Let's go!
 # Installing Rust
 
 The first step to using Rust is to install it! There are a number of ways to
-install Rust, but the easiest is to use the `rustup` script. If you're on
+install Rust, but the easiest is to use the the `rustup` script. If you're on
 Linux or a Mac, all you need to do is this (note that you don't need to type
 in the `$`s, they just indicate the start of each command):
 
 ```{ignore}
-$ curl -s https://static.rust-lang.org/rustup.sh | sudo sh
+$ curl -s http://www.rust-lang.org/rustup.sh | sudo sh
 ```
 
 (If you're concerned about `curl | sudo sh`, please keep reading. Disclaimer
 below.)
 
 If you're on Windows, please [download this .exe and run
-it](https://static.rust-lang.org/dist/rust-nightly-install.exe).
+it](http://static.rust-lang.org/dist/rust-nightly-install.exe).
 
 If you decide you don't want Rust anymore, we'll be a bit sad, but that's okay.
 Not every programming language is great for everyone. Just pass an argument to
 the script:
 
 ```{ignore}
-$ curl -s https://static.rust-lang.org/rustup.sh | sudo sh -s -- --uninstall
+$ curl -s http://www.rust-lang.org/rustup.sh | sudo sh -s -- --uninstall
 ```
 
 If you used the Windows installer, just re-run the `.exe` and it will give you
@@ -120,7 +120,7 @@ to make a projects directory in my home directory, and keep all my projects
 there. Rust does not care where your code lives.
 
 This actually leads to one other concern we should address: this tutorial will
-assume that you have basic familiarity with the command line. Rust does not
+assume that you have basic familiarity with the command-line. Rust does not
 require that you know a whole ton about the command line, but until the
 language is in a more finished state, IDE support is spotty. Rust makes no
 specific demands on your editing tooling, or where your code lives.
@@ -452,7 +452,7 @@ what you need, so it's not verboten.
 
 Let's get back to bindings. Rust variable bindings have one more aspect that
 differs from other languages: bindings are required to be initialized with a
-value before you're allowed to use them. If we try...
+value before you're allowed to use it. If we try...
 
 ```{ignore}
 let x;
@@ -1341,7 +1341,7 @@ computer science: naming things, cache invalidation, and off-by-one errors."
 The joke, of course, being that the setup says "two hard problems" but then
 lists three things. This happens quite a bit with "C style" `for` loops.
 
-We'll talk more about `for` when we cover **iterator**s, later in the Guide.
+We'll talk more about `for` when we cover **vector**s, later in the Guide.
 
 ## `while`
 
@@ -1427,6 +1427,11 @@ for x in range(0i, 10i) {
 
 Both `continue` and `break` are valid in both kinds of loops.
 
+We have now learned all of the most basic Rust concepts. We're ready to start
+building our guessing game, but we need to know how to do one last thing first:
+get input from the keyboard. You can't have a guessing game without the ability
+to guess!
+
 # Strings
 
 Strings are an important concept for any programmer to master. Rust's string
@@ -1507,76 +1512,6 @@ low-level details matter, they really matter. Just remember that `String`s
 allocate memory and control their data, while `&str`s are a reference to
 another string, and you'll be all set.
 
-# Vectors
-
-Like many programming languages, Rust has a list type for when you want a list
-of things. But similar to strings, Rust has different types to represent this
-idea: `Vec<T>` (a 'vector'), `[T, .. N]` (an 'array'), and `&[T]` (a 'slice').
-Whew!
-
-Vectors are similar to `String`s: they have a dynamic length, and they
-allocate enough memory to fit. You can create a vector with the `vec!` macro:
-
-```{rust}
-let nums = vec![1i, 2i, 3i];
-```
-
-Notice that unlike the `println!` macro we've used in the past, we use square
-brackets (`[]`) with `vec!`. Rust allows you to use either in either situation,
-this is just convention.
-
-You can create an array with just square brackets:
-
-```{rust}
-let nums = [1i, 2i, 3i];
-```
-
-So what's the difference? An array has a fixed size, so you can't add or
-subtract elements:
-
-```{rust,ignore}
-let mut nums = vec![1i, 2i, 3i];
-nums.push(4i); // works
-
-let mut nums = [1i, 2i, 3i];
-nums.push(4i); //  error: type `[int, .. 3]` does not implement any method
-               // in scope named `push`
-```
-
-The `push()` method lets you append a value to the end of the vector. But
-since arrays have fixed sizes, adding an element doesn't make any sense.
-You can see how it has the exact type in the error message: `[int, .. 3]`.
-An array of `int`s, with length 3.
-
-Similar to `&str`, a slice is a reference to another array. We can get a
-slice from a vector by using the `as_slice()` method:
-
-```{rust}
-let vec = vec![1i, 2i, 3i];
-let slice = vec.as_slice();
-```
-
-All three types implement an `iter()` method, which returns an iterator. We'll
-talk more about the details of iterators later, but for now, the `iter()` method
-allows you to write a `for` loop that prints out the contents of a vector, array,
-or slice:
-
-```{rust}
-let vec = vec![1i, 2i, 3i];
-
-for i in vec.iter() {
-    println!("{}", i);
-}
-```
-
-This code will print each number in order, on its own line.
-
-There's a whole lot more to vectors, but that's enough to get started. We have
-now learned all of the most basic Rust concepts. We're ready to start building
-our guessing game, but we need to know how to do one last thing first: get
-input from the keyboard. You can't have a guessing game without the ability to
-guess!
-
 # Standard Input
 
 Getting input from the keyboard is pretty easy, but uses some things
@@ -2155,7 +2090,7 @@ In this case, I happen to prefer the latter, and in the `random()` case, I prefe
 the former. I think the nested `<>`s make the first option especially ugly and
 a bit harder to read.
 
-Anyway, with us now converting our input to a number, our code looks like this:
+Anyway, with us now convering our input to a number, our code looks like this:
 
 ```{rust,ignore}
 use std::io;
@@ -2346,7 +2281,7 @@ change that by adding loops!
 
 ## Looping
 
-As we already discussed, the `loop` keyword gives us an infinite loop. So
+As we already discussed, the `loop` key word gives us an infinite loop. So
 let's add that in:
 
 ```{rust,no_run}
@@ -4164,7 +4099,7 @@ fn inverse(x: f64) -> Result<f64, String> {
 ```
 
 We don't want to take the inverse of zero, so we check to make sure that we
-weren't passed zero. If we were, then we return an `Err`, with a message. If
+weren't passed one. If we weren't, then we return an `Err`, with a message. If
 it's okay, we return an `Ok`, with the answer.
 
 Why does this matter? Well, remember how `match` does exhaustive matches?

branches/try/src/doc/tutorial.md

@@ -114,7 +114,7 @@ If you've fulfilled those prerequisites, something along these lines
 should work.
 
 ~~~~console
-$ curl -O https://static.rust-lang.org/dist/rust-nightly.tar.gz
+$ curl -O http://static.rust-lang.org/dist/rust-nightly.tar.gz
 $ tar -xzf rust-nightly.tar.gz
 $ cd rust-nightly
 $ ./configure
@@ -131,8 +131,8 @@ When complete, `make install` will place several programs into
 `/usr/local/bin`: `rustc`, the Rust compiler, and `rustdoc`, the
 API-documentation tool.
 
-[tarball]: https://static.rust-lang.org/dist/rust-nightly.tar.gz
-[win-exe]: https://static.rust-lang.org/dist/rust-nightly-install.exe
+[tarball]: http://static.rust-lang.org/dist/rust-nightly.tar.gz
+[win-exe]: http://static.rust-lang.org/dist/rust-nightly-install.exe
 
 ## Compiling your first program
 
@@ -1133,16 +1133,6 @@ let xs = Cons(1, box Cons(2, box Cons(3, box Nil)));
 let ys = xs; // copies `Cons(u32, pointer)` shallowly
 ~~~
 
-> *Note:* Names like `xs` and `ys` are a naming
-> convention for collection-like data structures
-> (like our `List`). These collections are given 
-> names appended with 's' to signify plurality, 
-> i.e. that the data structure stores multiple 
-> elements.  For example, `xs` in this case can 
-> be read as "a list of ex-es", where "x" here 
-> are elements of type `u32`.
-
-
 Rust will consider a shallow copy of a type with a destructor like `List` to
 *move ownership* of the value. After a value has been moved, the source
 location cannot be used unless it is reinitialized.

branches/try/src/etc/snapshot.py

@@ -28,7 +28,7 @@ def scrub(b):
   raise Exception("missing env var CFG_SRC_DIR")
 
 snapshotfile = os.path.join(src_dir, "src", "snapshots.txt")
-download_url_base = "https://static.rust-lang.org/stage0-snapshots"
+download_url_base = "http://static.rust-lang.org/stage0-snapshots"
 download_dir_base = "dl"
 download_unpack_base = os.path.join(download_dir_base, "unpack")
 

branches/try/src/libcollections/ringbuf.rs

@@ -139,8 +139,6 @@ impl<T> RingBuf<T> {
     /// # Example
     ///
     /// ```rust
-    /// #![allow(deprecated)]
-    ///
     /// use std::collections::RingBuf;
     ///
     /// let mut buf = RingBuf::new();
@@ -149,7 +147,6 @@ impl<T> RingBuf<T> {
     /// buf.push(5);
     /// assert_eq!(buf.get(1), &4);
     /// ```
-    #[deprecated = "prefer using indexing, e.g., ringbuf[0]"]
     pub fn get<'a>(&'a self, i: uint) -> &'a T {
         let idx = self.raw_index(i);
         match *self.elts.get(idx) {
@@ -172,7 +169,7 @@ impl<T> RingBuf<T> {
     /// buf.push(4);
     /// buf.push(5);
     /// *buf.get_mut(1) = 7;
-    /// assert_eq!(buf[1], 7);
+    /// assert_eq!(buf.get(1), &7);
     /// ```
     pub fn get_mut<'a>(&'a mut self, i: uint) -> &'a mut T {
         let idx = self.raw_index(i);
@@ -198,8 +195,8 @@ impl<T> RingBuf<T> {
     /// buf.push(4);
     /// buf.push(5);
     /// buf.swap(0, 2);
-    /// assert_eq!(buf[0], 5);
-    /// assert_eq!(buf[2], 3);
+    /// assert_eq!(buf.get(0), &5);
+    /// assert_eq!(buf.get(2), &3);
     /// ```
     pub fn swap(&mut self, i: uint, j: uint) {
         assert!(i < self.len());
@@ -479,21 +476,6 @@ impl<S: Writer, A: Hash<S>> Hash<S> for RingBuf<A> {
     }
 }
 
-impl<A> Index<uint, A> for RingBuf<A> {
-    #[inline]
-    fn index<'a>(&'a self, i: &uint) -> &'a A {
-        self.get(*i)
-    }
-}
-
-// FIXME(#12825) Indexing will always try IndexMut first and that causes issues.
-/*impl<A> IndexMut<uint, A> for RingBuf<A> {
-    #[inline]
-    fn index_mut<'a>(&'a mut self, index: &uint) -> &'a mut A {
-        self.get_mut(*index)
-    }
-}*/
-
 impl<A> FromIterator<A> for RingBuf<A> {
     fn from_iter<T: Iterator<A>>(iterator: T) -> RingBuf<A> {
         let (lower, _) = iterator.size_hint();
@@ -671,25 +653,6 @@ mod tests {
         }
     }
 
-    #[test]
-    fn test_index() {
-        let mut deq = RingBuf::new();
-        for i in range(1u, 4) {
-            deq.push_front(i);
-        }
-        assert_eq!(deq[1], 2);
-    }
-
-    #[test]
-    #[should_fail]
-    fn test_index_out_of_bounds() {
-        let mut deq = RingBuf::new();
-        for i in range(1u, 4) {
-            deq.push_front(i);
-        }
-        deq[3];
-    }
-
     #[bench]
     fn bench_new(b: &mut test::Bencher) {
         b.iter(|| {