---

yaml
---
r: 115166
b: refs/heads/auto
c: 803e92d
h: refs/heads/master
v: v3

Author: bors

[refs]

@@ -13,7 +13,7 @@ refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: feb91f3216c7a60c9f7da582b3a02551fe73bb40
+refs/heads/auto: 803e92de89def55197244269a5d1feffa00c93d9
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/src/doc/tutorial.md

@@ -944,7 +944,7 @@ struct Foo { x: int, y: Box<int> }
     // `a` is the owner of the struct, and thus the owner of the struct's fields
     let a = Foo { x: 5, y: box 10 };
 }
-// when `a` goes out of scope, the destructor for the `~int` in the struct's
+// when `a` goes out of scope, the destructor for the `Box<int>` in the struct's
 // field is called
 
 // `b` is mutable, and the mutability is inherited by the objects it owns

branches/auto/src/libcore/iter.rs

@@ -2016,7 +2016,7 @@ pub struct RangeInclusive<A> {
 
 /// Return an iterator over the range [start, stop]
 #[inline]
-pub fn range_inclusive<A: Add<A, A> + Ord + Clone + One + ToPrimitive>(start: A, stop: A)
+pub fn range_inclusive<A: Add<A, A> + Ord + Clone + One>(start: A, stop: A)
     -> RangeInclusive<A> {
     RangeInclusive{range: range(start, stop), done: false}
 }

branches/auto/src/libflate/lib.rs

@@ -125,7 +125,7 @@ mod tests {
         for _ in range(0, 20) {
             let mut input = vec![];
             for _ in range(0, 2000) {
-                input.push_all(r.choose(words.as_slice()).as_slice());
+                input.push_all(r.choose(words.as_slice()).unwrap().as_slice());
             }
             debug!("de/inflate of {} bytes of random word-sequences",
                    input.len());

branches/auto/src/librand/lib.rs

@@ -266,37 +266,39 @@ pub trait Rng {
                                                              0123456789");
         let mut s = StrBuf::with_capacity(len);
         for _ in range(0, len) {
-            s.push_char(self.choose(GEN_ASCII_STR_CHARSET) as char)
+            s.push_char(*self.choose(GEN_ASCII_STR_CHARSET).unwrap() as char)
         }
         s
     }
 
-    /// Choose an item randomly, failing if `values` is empty.
-    fn choose<T: Clone>(&mut self, values: &[T]) -> T {
-        self.choose_option(values).expect("Rng.choose: `values` is empty").clone()
-    }
-
-    /// Choose `Some(&item)` randomly, returning `None` if values is
-    /// empty.
+    /// Return a random element from `values`.
+    ///
+    /// Return `None` if `values` is empty.
     ///
     /// # Example
     ///
-    /// ```rust
+    /// ```
     /// use rand::{task_rng, Rng};
     ///
     /// let choices = [1, 2, 4, 8, 16, 32];
     /// let mut rng = task_rng();
-    /// println!("{:?}", rng.choose_option(choices));
-    /// println!("{:?}", rng.choose_option(choices.slice_to(0)));
+    /// println!("{}", rng.choose(choices));
+    /// assert_eq!(rng.choose(choices.slice_to(0)), None);
     /// ```
-    fn choose_option<'a, T>(&mut self, values: &'a [T]) -> Option<&'a T> {
+    fn choose<'a, T>(&mut self, values: &'a [T]) -> Option<&'a T> {
         if values.is_empty() {
             None
         } else {
             Some(&values[self.gen_range(0u, values.len())])
         }
     }
 
+    /// Deprecated name for `choose()`.
+    #[deprecated = "replaced by .choose()"]
+    fn choose_option<'a, T>(&mut self, values: &'a [T]) -> Option<&'a T> {
+        self.choose(values)
+    }
+
     /// Shuffle a mutable slice in place.
     ///
     /// # Example
@@ -793,18 +795,10 @@ mod test {
     #[test]
     fn test_choose() {
         let mut r = task_rng();
-        assert_eq!(r.choose([1, 1, 1]), 1);
-    }
+        assert_eq!(r.choose([1, 1, 1]).map(|&x|x), Some(1));
 
-    #[test]
-    fn test_choose_option() {
-        let mut r = task_rng();
         let v: &[int] = &[];
-        assert!(r.choose_option(v).is_none());
-
-        let i = 1;
-        let v = [1,1,1];
-        assert_eq!(r.choose_option(v), Some(&i));
+        assert_eq!(r.choose(v), None);
     }
 
     #[test]