---

yaml
---
r: 156638
b: refs/heads/try
c: f358407
h: refs/heads/master
v: v3

Author: steveklabnik

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: a34b8dec697014f15e725215e17ea8d956c0ab1a
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: d44ea720fa9dfe062ef06d0eb49a58d4e7e92344
-refs/heads/try: b2e577365512433d17e68107a068fb82af88a67b
+refs/heads/try: f358407dcfe4cb50a65110aad31bf88c87e72d39
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 6601b0501e31d08d3892a2d5a7d8a57ab120bf75

branches/try/mk/crates.mk

@@ -49,11 +49,11 @@
 # automatically generated for all stage/host/target combinations.
 ################################################################################
 
-TARGET_CRATES := libc std green native flate arena term \
-                 serialize sync getopts collections test time rand \
-                 log regex graphviz core rbml rlibc alloc rustrt \
+TARGET_CRATES := libc std green native flate arena glob term semver \
+                 uuid serialize sync getopts collections num test time rand \
+                 url log regex graphviz core rbml rlibc alloc rustrt \
                  unicode
-HOST_CRATES := syntax rustc rustdoc regex_macros fmt_macros \
+HOST_CRATES := syntax rustc rustdoc fourcc hexfloat regex_macros fmt_macros \
 	       rustc_llvm rustc_back
 CRATES := $(TARGET_CRATES) $(HOST_CRATES)
 TOOLS := compiletest rustdoc rustc
@@ -83,13 +83,18 @@ DEPS_glob := std
 DEPS_serialize := std log
 DEPS_rbml := std log serialize
 DEPS_term := std log
+DEPS_semver := std
+DEPS_uuid := std serialize
 DEPS_sync := core alloc rustrt collections
 DEPS_getopts := std
 DEPS_collections := core alloc unicode
+DEPS_fourcc := rustc syntax std
+DEPS_hexfloat := rustc syntax std
 DEPS_num := std
 DEPS_test := std getopts serialize rbml term time regex native:rust_test_helpers
 DEPS_time := std serialize
 DEPS_rand := core
+DEPS_url := std
 DEPS_log := std regex
 DEPS_regex := std
 DEPS_regex_macros = rustc syntax std regex

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

@@ -96,12 +96,11 @@ need, and it can make your lifetimes more complex.
 
 ## Generic functions
 
-To write a function that's generic over types of strings, use [the `Str`
-trait](http://doc.rust-lang.org/std/str/trait.Str.html):
+To write a function that's generic over types of strings, use `&str`.
 
 ```{rust}
-fn some_string_length<T: Str>(x: T) -> uint {
-        x.as_slice().len()
+fn some_string_length(x: &str) -> uint {
+        x.len()
 }
 
 fn main() {
@@ -111,15 +110,12 @@ fn main() {
 
     let s = "Hello, world".to_string();
 
-    println!("{}", some_string_length(s));
+    println!("{}", some_string_length(s.as_slice()));
 }
 ```
 
 Both of these lines will print `12`. 
 
-The only method that the `Str` trait has is `as_slice()`, which gives you
-access to a `&str` value from the underlying string.
-
 ## Comparisons
 
 To compare a String to a constant string, prefer `as_slice()`...
@@ -161,25 +157,93 @@ indexing is basically never what you want to do. The reason is that each
 character can be a variable number of bytes. This means that you have to iterate
 through the characters anyway, which is a O(n) operation. 
 
-To iterate over a string, use the `graphemes()` method on `&str`:
+There's 3 basic levels of unicode (and its encodings):
+
+- code units, the underlying data type used to store everything
+- code points/unicode scalar values (char)
+- graphemes (visible characters)
+
+Rust provides iterators for each of these situations:
+
+- `.bytes()` will iterate over the underlying bytes
+- `.chars()` will iterate over the code points
+- `.graphemes()` will iterate over each grapheme
+
+Usually, the `graphemes()` method on `&str` is what you want:
 
 ```{rust}
-let s = "αἰθήρ";
+let s = "u͔n͈̰̎i̙̮͚̦c͚̉o̼̩̰͗d͔̆̓ͥé";
 
 for l in s.graphemes(true) {
     println!("{}", l);
 }
 ```
 
+This prints:
+
+```{notrust,ignore}
+u͔
+n͈̰̎
+i̙̮͚̦
+c͚̉
+o̼̩̰͗
+d͔̆̓ͥ
+é
+```
+
 Note that `l` has the type `&str` here, since a single grapheme can consist of
 multiple codepoints, so a `char` wouldn't be appropriate.
 
-This will print out each character in turn, as you'd expect: first "α", then
-"ἰ", etc. You can see that this is different than just the individual bytes.
-Here's a version that prints out each byte:
+This will print out each visible character in turn, as you'd expect: first "u͔", then
+"n͈̰̎", etc. If you wanted each individual codepoint of each grapheme, you can use `.chars()`:
 
 ```{rust}
-let s = "αἰθήρ";
+let s = "u͔n͈̰̎i̙̮͚̦c͚̉o̼̩̰͗d͔̆̓ͥé";
+
+for l in s.chars() {
+    println!("{}", l);
+}
+```
+
+This prints:
+
+```{notrust,ignore}
+u
+͔
+n
+̎
+͈
+̰
+i
+̙
+̮
+͚
+̦
+c
+̉
+͚
+o
+͗
+̼
+̩
+̰
+d
+̆
+̓
+ͥ
+͔
+e
+́
+```
+
+You can see how some of them are combining characters, and therefore the output
+looks a bit odd.
+
+If you want the individual byte representation of each codepoint, you can use
+`.bytes()`:
+
+```{rust}
+let s = "u͔n͈̰̎i̙̮͚̦c͚̉o̼̩̰͗d͔̆̓ͥé";
 
 for l in s.bytes() {
     println!("{}", l);
@@ -189,16 +253,50 @@ for l in s.bytes() {
 This will print:
 
 ```{notrust,ignore}
-206
-177
-225
-188
+117
+205
+148
+110
+204
+142
+205
+136
+204
 176
-206
-184
-206
+105
+204
+153
+204
 174
-207
+205
+154
+204
+166
+99
+204
+137
+205
+154
+111
+205
+151
+204
+188
+204
+169
+204
+176
+100
+204
+134
+205
+131
+205
+165
+205
+148
+101
+204
 129
 ```
 

branches/try/src/doc/guide.md

@@ -3095,10 +3095,10 @@ And try to run the test:
 
 ```{notrust,ignore}
 $ cargo test
-   Compiling testing v0.0.1 (file:///home/you/projects/testing)
-/home/you/projects/testing/tests/lib.rs:3:18: 3:38 error: unresolved name `add_three_times_four`.
-/home/you/projects/testing/tests/lib.rs:3     let result = add_three_times_four(5i);
-                                                           ^~~~~~~~~~~~~~~~~~~~
+   Compiling testing v0.0.1 (file:///home/youg/projects/testing)
+/home/youg/projects/testing/tests/lib.rs:3:18: 3:38 error: unresolved name `add_three_times_four`.
+/home/youg/projects/testing/tests/lib.rs:3     let result = add_three_times_four(5i);
+                                                            ^~~~~~~~~~~~~~~~~~~~
 error: aborting due to previous error
 Build failed, waiting for other jobs to finish...
 Could not compile `testing`.
@@ -3284,11 +3284,11 @@ Let's give it a shot:
 $ cargo test
    Compiling testing v0.0.1 (file:///home/you/projects/testing)
 
-running 2 tests
+running 1 test
 test test::test_times_four ... ok
 test test::test_add_three ... ok
 
-test result: ok. 2 passed; 0 failed; 0 ignored; 0 measured
+test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured
 
 
 running 0 tests
@@ -4363,7 +4363,7 @@ element, `find` returns an `Option` rather than the element itself.
 Another important consumer is `fold`. Here's what it looks like:
 
 ```{rust}
-let sum = range(1i, 4i)
+let sum = range(1i, 100i)
               .fold(0i, |sum, x| sum + x);
 ```
 
@@ -4387,7 +4387,7 @@ in this iterator:
 We called `fold()` with these arguments:
 
 ```{rust}
-# range(1i, 4i)
+# range(1i, 5i)
 .fold(0i, |sum, x| sum + x);
 ```
 

branches/try/src/doc/intro.md

@@ -442,21 +442,21 @@ It gives us this error:
 ```
 
 It mentions that "numbers moved into closure environment". Because we referred
-to `numbers` inside of our `proc`, and we create three `proc`s, we would have
-three references. Rust detects this and gives us the error: we claim that
-`numbers` has ownership, but our code tries to make three owners. This may
-cause a safety problem, so Rust disallows it.
+to `numbers` inside of our `proc`, and we create ten `proc`s, we would have ten
+references. Rust detects this and gives us the error: we claim that `numbers`
+has ownership, but our code tries to make ten owners. This may cause a safety
+problem, so Rust disallows it.
 
 What to do here? Rust has two types that helps us: `Arc<T>` and `Mutex<T>`.
 "Arc" stands for "atomically reference counted." In other words, an Arc will
 keep track of the number of references to something, and not free the
 associated resource until the count is zero. The 'atomic' portion refers to an
 Arc's usage of concurrency primitives to atomically update the count, making it
-safe across threads. If we use an Arc, we can have our three references. But,
-an Arc does not allow mutable borrows of the data it holds, and we want to
-modify what we're sharing. In this case, we can use a `Mutex<T>` inside of our
-Arc. A Mutex will synchronize our accesses, so that we can ensure that our
-mutation doesn't cause a data race.
+safe across threads. If we use an Arc, we can have our ten references. But, an
+Arc does not allow mutable borrows of the data it holds, and we want to modify
+what we're sharing. In this case, we can use a `Mutex<T>` inside of our Arc. A
+Mutex will synchronize our accesses, so that we can ensure that our mutation
+doesn't cause a data race.
 
 Here's what using an Arc with a Mutex looks like:
 

branches/try/src/libcollections/dlist.rs

@@ -475,6 +475,12 @@ impl<T> DList<T> {
         Items{nelem: self.len(), head: &self.list_head, tail: self.list_tail}
     }
 
+    /// Deprecated: use `iter_mut`.
+    #[deprecated = "use iter_mut"]
+    pub fn mut_iter<'a>(&'a mut self) -> MutItems<'a, T> {
+        self.iter_mut()
+    }
+
     /// Provides a forward iterator with mutable references.
     #[inline]
     pub fn iter_mut<'a>(&'a mut self) -> MutItems<'a, T> {
@@ -490,6 +496,12 @@ impl<T> DList<T> {
         }
     }
 
+    /// Deprecated: use `into_iter`.
+    #[deprecated = "use into_iter"]
+    pub fn move_iter(self) -> MoveItems<T> {
+        self.into_iter()
+    }
+
     /// Consumes the list into an iterator yielding elements by value.
     #[inline]
     pub fn into_iter(self) -> MoveItems<T> {
@@ -858,8 +870,7 @@ mod tests {
         let mut m = list_from(v.as_slice());
         m.append(list_from(u.as_slice()));
         check_links(&m);
-        let mut sum = v;
-        sum.push_all(u.as_slice());
+        let sum = v.append(u.as_slice());
         assert_eq!(sum.len(), m.len());
         for elt in sum.into_iter() {
             assert_eq!(m.pop_front(), Some(elt))

branches/try/src/libcollections/lib.rs

@@ -502,6 +502,40 @@ pub trait Deque<T> : MutableSeq<T> {
     /// ```
     fn push_front(&mut self, elt: T);
 
+    /// Inserts an element last in the sequence.
+    ///
+    /// # Example
+    ///
+    /// ```ignore
+    /// use std::collections::{DList, Deque};
+    ///
+    /// let mut d = DList::new();
+    /// d.push_back(1i);
+    /// d.push_back(2i);
+    /// assert_eq!(d.front(), Some(&1i));
+    /// ```
+    #[deprecated = "use the `push` method"]
+    fn push_back(&mut self, elt: T) { self.push(elt) }
+
+    /// Removes the last element and returns it, or `None` if the sequence is
+    /// empty.
+    ///
+    /// # Example
+    ///
+    /// ```ignore
+    /// use std::collections::{RingBuf, Deque};
+    ///
+    /// let mut d = RingBuf::new();
+    /// d.push_back(1i);
+    /// d.push_back(2i);
+    ///
+    /// assert_eq!(d.pop_back(), Some(2i));
+    /// assert_eq!(d.pop_back(), Some(1i));
+    /// assert_eq!(d.pop_back(), None);
+    /// ```
+    #[deprecated = "use the `pop` method"]
+    fn pop_back(&mut self) -> Option<T> { self.pop() }
+
     /// Removes the first element and returns it, or `None` if the sequence is
     /// empty.
     ///