---

yaml
---
r: 151882
b: refs/heads/try2
c: 803e92d
h: refs/heads/master
v: v3

Author: bors

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: feb91f3216c7a60c9f7da582b3a02551fe73bb40
+refs/heads/try2: 803e92de89def55197244269a5d1feffa00c93d9
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/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/try2/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/try2/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/try2/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]