---

yaml
---
r: 165517
b: refs/heads/master
c: abf492d
h: refs/heads/master
i:
  165515: cf17f30
v: v3

Author: csouth3

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: b04bc5cc49a398df712092a68ab9ad83019498ad
+refs/heads/master: abf492d44f0a3b705be8c0920bfb4771f039b843
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 658529467d9d69ac9e09cacf98a6d61d781c2c76
 refs/heads/try: aee614fc4973262a5a68efc643026e2b1458d65b

trunk/src/compiletest/compiletest.rs

@@ -152,7 +152,7 @@ pub fn parse_config(args: Vec<String> ) -> Config {
             matches.opt_str("ratchet-metrics").map(|s| Path::new(s)),
         ratchet_noise_percent:
             matches.opt_str("ratchet-noise-percent")
-                   .and_then(|s| s.as_slice().parse::<f64>()),
+                   .and_then(|s| from_str::<f64>(s.as_slice())),
         runtool: matches.opt_str("runtool"),
         host_rustcflags: matches.opt_str("host-rustcflags"),
         target_rustcflags: matches.opt_str("target-rustcflags"),
@@ -190,7 +190,9 @@ pub fn log_config(config: &Config) {
     logv(c, format!("filter: {}",
                     opt_str(&config.filter
                                    .as_ref()
-                                   .map(|re| re.to_string()))));
+                                   .map(|re| {
+                                       re.to_string().into_string()
+                                   }))));
     logv(c, format!("runtool: {}", opt_str(&config.runtool)));
     logv(c, format!("host-rustcflags: {}",
                     opt_str(&config.host_rustcflags)));

trunk/src/compiletest/header.rs

@@ -351,8 +351,8 @@ pub fn gdb_version_to_int(version_string: &str) -> int {
         panic!("{}", error_string);
     }
 
-    let major: int = components[0].parse().expect(error_string);
-    let minor: int = components[1].parse().expect(error_string);
+    let major: int = from_str(components[0]).expect(error_string);
+    let minor: int = from_str(components[1]).expect(error_string);
 
     return major * 1000 + minor;
 }
@@ -362,6 +362,6 @@ pub fn lldb_version_to_int(version_string: &str) -> int {
         "Encountered LLDB version string with unexpected format: {}",
         version_string);
     let error_string = error_string.as_slice();
-    let major: int = version_string.parse().expect(error_string);
+    let major: int = from_str(version_string).expect(error_string);
     return major;
 }

trunk/src/compiletest/runtest.rs

@@ -1361,7 +1361,7 @@ fn split_maybe_args(argstr: &Option<String>) -> Vec<String> {
             s.as_slice()
              .split(' ')
              .filter_map(|s| {
-                 if s.chars().all(|c| c.is_whitespace()) {
+                 if s.is_whitespace() {
                      None
                  } else {
                      Some(s.to_string())

trunk/src/doc/guide.md

@@ -2257,10 +2257,10 @@ a function for that:
 let input = io::stdin().read_line()
                        .ok()
                        .expect("Failed to read line");
-let input_num: Option<uint> = input.parse();
+let input_num: Option<uint> = from_str(input.as_slice());
 ```
 
-The `parse` function takes in a `&str` value and converts it into something.
+The `from_str` function takes in a `&str` value and converts it into something.
 We tell it what kind of something with a type hint. Remember our type hint with
 `random()`? It looked like this:
 
@@ -2279,8 +2279,8 @@ In this case, we say `x` is a `uint` explicitly, so Rust is able to properly
 tell `random()` what to generate. In a similar fashion, both of these work:
 
 ```{rust,ignore}
-let input_num = "5".parse::<uint>();         // input_num: Option<uint>
-let input_num: Option<uint> = "5".parse();   // input_num: Option<uint>
+let input_num = from_str::<uint>("5");       // input_num: Option<uint>
+let input_num: Option<uint> = from_str("5"); // input_num: Option<uint>
 ```
 
 Anyway, with us now converting our input to a number, our code looks like this:
@@ -2301,7 +2301,7 @@ fn main() {
     let input = io::stdin().read_line()
                            .ok()
                            .expect("Failed to read line");
-    let input_num: Option<uint> = input.parse();
+    let input_num: Option<uint> = from_str(input.as_slice());
 
     println!("You guessed: {}", input_num);
 
@@ -2350,7 +2350,7 @@ fn main() {
     let input = io::stdin().read_line()
                            .ok()
                            .expect("Failed to read line");
-    let input_num: Option<uint> = input.parse();
+    let input_num: Option<uint> = from_str(input.as_slice());
 
     let num = match input_num {
         Some(num) => num,
@@ -2395,7 +2395,7 @@ Uh, what? But we did!
 
 ... actually, we didn't. See, when you get a line of input from `stdin()`,
 you get all the input. Including the `\n` character from you pressing Enter.
-Therefore, `parse()` sees the string `"5\n"` and says "nope, that's not a
+Therefore, `from_str()` sees the string `"5\n"` and says "nope, that's not a
 number; there's non-number stuff in there!" Luckily for us, `&str`s have an easy
 method we can use defined on them: `trim()`. One small modification, and our
 code looks like this:
@@ -2416,7 +2416,7 @@ fn main() {
     let input = io::stdin().read_line()
                            .ok()
                            .expect("Failed to read line");
-    let input_num: Option<uint> = input.trim().parse();
+    let input_num: Option<uint> = from_str(input.as_slice().trim());
 
     let num = match input_num {
         Some(num) => num,
@@ -2491,7 +2491,7 @@ fn main() {
         let input = io::stdin().read_line()
                                .ok()
                                .expect("Failed to read line");
-        let input_num: Option<uint> = input.trim().parse();
+        let input_num: Option<uint> = from_str(input.as_slice().trim());
 
         let num = match input_num {
             Some(num) => num,
@@ -2566,7 +2566,7 @@ fn main() {
         let input = io::stdin().read_line()
                                .ok()
                                .expect("Failed to read line");
-        let input_num: Option<uint> = input.trim().parse();
+        let input_num: Option<uint> = from_str(input.as_slice().trim());
 
         let num = match input_num {
             Some(num) => num,
@@ -2621,7 +2621,7 @@ fn main() {
         let input = io::stdin().read_line()
                                .ok()
                                .expect("Failed to read line");
-        let input_num: Option<uint> = input.trim().parse();
+        let input_num: Option<uint> = from_str(input.as_slice().trim());
 
         let num = match input_num {
             Some(num) => num,
@@ -2697,7 +2697,7 @@ fn main() {
         let input = io::stdin().read_line()
                                .ok()
                                .expect("Failed to read line");
-        let input_num: Option<uint> = input.trim().parse();
+        let input_num: Option<uint> = from_str(input.as_slice().trim());
 
         let num = match input_num {
             Some(num) => num,

trunk/src/doc/reference.md

@@ -3177,7 +3177,7 @@ Some examples of call expressions:
 # fn add(x: int, y: int) -> int { 0 }
 
 let x: int = add(1, 2);
-let pi: Option<f32> = "3.14".parse();
+let pi: Option<f32> = from_str("3.14");
 ```
 
 ### Lambda expressions

trunk/src/libcollections/binary_heap.rs

@@ -272,15 +272,16 @@ impl<T: Ord> BinaryHeap<T> {
     /// use std::collections::BinaryHeap;
     ///
     /// let mut heap = BinaryHeap::new();
-    /// assert_eq!(heap.top(), None);
+    /// assert_eq!(heap.peek(), None);
     ///
     /// heap.push(1i);
     /// heap.push(5i);
     /// heap.push(2i);
-    /// assert_eq!(heap.top(), Some(&5i));
+    /// assert_eq!(heap.peek(), Some(&5i));
     ///
     /// ```
-    pub fn top(&self) -> Option<&T> {
+    #[stable]
+    pub fn peek(&self) -> Option<&T> {
         self.data.get(0)
     }
 
@@ -388,7 +389,7 @@ impl<T: Ord> BinaryHeap<T> {
     /// heap.push(1i);
     ///
     /// assert_eq!(heap.len(), 3);
-    /// assert_eq!(heap.top(), Some(&5i));
+    /// assert_eq!(heap.peek(), Some(&5i));
     /// ```
     #[unstable = "matches collection reform specification, waiting for dust to settle"]
     pub fn push(&mut self, item: T) {
@@ -412,7 +413,7 @@ impl<T: Ord> BinaryHeap<T> {
     /// assert_eq!(heap.push_pop(3i), 5);
     /// assert_eq!(heap.push_pop(9i), 9);
     /// assert_eq!(heap.len(), 2);
-    /// assert_eq!(heap.top(), Some(&3i));
+    /// assert_eq!(heap.peek(), Some(&3i));
     /// ```
     pub fn push_pop(&mut self, mut item: T) -> T {
         match self.data.get_mut(0) {
@@ -442,7 +443,7 @@ impl<T: Ord> BinaryHeap<T> {
     /// assert_eq!(heap.replace(1i), None);
     /// assert_eq!(heap.replace(3i), Some(1i));
     /// assert_eq!(heap.len(), 1);
-    /// assert_eq!(heap.top(), Some(&3i));
+    /// assert_eq!(heap.peek(), Some(&3i));
     /// ```
     pub fn replace(&mut self, mut item: T) -> Option<T> {
         if !self.is_empty() {
@@ -714,13 +715,13 @@ mod tests {
     }
 
     #[test]
-    fn test_top_and_pop() {
+    fn test_peek_and_pop() {
         let data = vec!(2u, 4, 6, 2, 1, 8, 10, 3, 5, 7, 0, 9, 1);
         let mut sorted = data.clone();
         sorted.sort();
         let mut heap = BinaryHeap::from_vec(data);
         while !heap.is_empty() {
-            assert_eq!(heap.top().unwrap(), sorted.last().unwrap());
+            assert_eq!(heap.peek().unwrap(), sorted.last().unwrap());
             assert_eq!(heap.pop().unwrap(), sorted.pop().unwrap());
         }
     }
@@ -729,44 +730,44 @@ mod tests {
     fn test_push() {
         let mut heap = BinaryHeap::from_vec(vec!(2i, 4, 9));
         assert_eq!(heap.len(), 3);
-        assert!(*heap.top().unwrap() == 9);
+        assert!(*heap.peek().unwrap() == 9);
         heap.push(11);
         assert_eq!(heap.len(), 4);
-        assert!(*heap.top().unwrap() == 11);
+        assert!(*heap.peek().unwrap() == 11);
         heap.push(5);
         assert_eq!(heap.len(), 5);
-        assert!(*heap.top().unwrap() == 11);
+        assert!(*heap.peek().unwrap() == 11);
         heap.push(27);
         assert_eq!(heap.len(), 6);
-        assert!(*heap.top().unwrap() == 27);
+        assert!(*heap.peek().unwrap() == 27);
         heap.push(3);
         assert_eq!(heap.len(), 7);
-        assert!(*heap.top().unwrap() == 27);
+        assert!(*heap.peek().unwrap() == 27);
         heap.push(103);
         assert_eq!(heap.len(), 8);
-        assert!(*heap.top().unwrap() == 103);
+        assert!(*heap.peek().unwrap() == 103);
     }
 
     #[test]
     fn test_push_unique() {
         let mut heap = BinaryHeap::from_vec(vec!(box 2i, box 4, box 9));
         assert_eq!(heap.len(), 3);
-        assert!(*heap.top().unwrap() == box 9);
+        assert!(*heap.peek().unwrap() == box 9);
         heap.push(box 11);
         assert_eq!(heap.len(), 4);
-        assert!(*heap.top().unwrap() == box 11);
+        assert!(*heap.peek().unwrap() == box 11);
         heap.push(box 5);
         assert_eq!(heap.len(), 5);
-        assert!(*heap.top().unwrap() == box 11);
+        assert!(*heap.peek().unwrap() == box 11);
         heap.push(box 27);
         assert_eq!(heap.len(), 6);
-        assert!(*heap.top().unwrap() == box 27);
+        assert!(*heap.peek().unwrap() == box 27);
         heap.push(box 3);
         assert_eq!(heap.len(), 7);
-        assert!(*heap.top().unwrap() == box 27);
+        assert!(*heap.peek().unwrap() == box 27);
         heap.push(box 103);
         assert_eq!(heap.len(), 8);
-        assert!(*heap.top().unwrap() == box 103);
+        assert!(*heap.peek().unwrap() == box 103);
     }
 
     #[test]
@@ -831,9 +832,9 @@ mod tests {
     }
 
     #[test]
-    fn test_empty_top() {
+    fn test_empty_peek() {
         let empty = BinaryHeap::<int>::new();
-        assert!(empty.top().is_none());
+        assert!(empty.peek().is_none());
     }
 
     #[test]