---

yaml
---
r: 228325
b: refs/heads/try
c: 5f8b1fa
h: refs/heads/master
i:
  228323: c365de4
v: v3

Author: rick68

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: aca2057ed5fb7af3f8905b2bc01f72fa001c35c8
 refs/heads/snap-stage3: 1af31d4974e33027a68126fa5a5a3c2c6491824f
-refs/heads/try: a16a4173c96a669412b3740dd7acba7d41b66b39
+refs/heads/try: 5f8b1fadb8824e151df2b859a2c47af33d931464
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try/src/compiletest/runtest.rs

@@ -344,7 +344,7 @@ fn run_debuginfo_gdb_test(config: &Config, props: &TestProps, testfile: &Path) {
         check_lines,
         breakpoint_lines
     } = parse_debugger_commands(testfile, "gdb");
-    let mut cmds = commands.join("\n");
+    let mut cmds = commands.connect("\n");
 
     // compile test file (it should have 'compile-flags:-g' in the header)
     let compiler_run_result = compile_test(config, props, testfile);
@@ -799,7 +799,7 @@ fn cleanup_debug_info_options(options: &Option<String>) -> Option<String> {
         split_maybe_args(options).into_iter()
                                  .filter(|x| !options_to_remove.contains(x))
                                  .collect::<Vec<String>>()
-                                 .join(" ");
+                                 .connect(" ");
     Some(new_options)
 }
 
@@ -1412,15 +1412,15 @@ fn make_cmdline(libpath: &str, prog: &str, args: &[String]) -> String {
 
     // Linux and mac don't require adjusting the library search path
     if cfg!(unix) {
-        format!("{} {}", prog, args.join(" "))
+        format!("{} {}", prog, args.connect(" "))
     } else {
         // Build the LD_LIBRARY_PATH variable as it would be seen on the command line
         // for diagnostic purposes
         fn lib_path_cmd_prefix(path: &str) -> String {
             format!("{}=\"{}\"", util::lib_path_env_var(), util::make_new_path(path))
         }
 
-        format!("{} {} {}", lib_path_cmd_prefix(libpath), prog, args.join(" "))
+        format!("{} {} {}", lib_path_cmd_prefix(libpath), prog, args.connect(" "))
     }
 }
 

branches/try/src/doc/trpl/dining-philosophers.md

@@ -151,15 +151,15 @@ look at `main()` again:
 # struct Philosopher {
 #     name: String,
 # }
-#
+# 
 # impl Philosopher {
 #     fn new(name: &str) -> Philosopher {
 #         Philosopher {
 #             name: name.to_string(),
 #         }
 #     }
 # }
-#
+# 
 fn main() {
     let p1 = Philosopher::new("Judith Butler");
     let p2 = Philosopher::new("Gilles Deleuze");
@@ -197,15 +197,15 @@ a method, and then loop through all the philosophers, calling it:
 ```rust
 struct Philosopher {
     name: String,
-}
+}   
 
-impl Philosopher {
+impl Philosopher { 
     fn new(name: &str) -> Philosopher {
         Philosopher {
             name: name.to_string(),
         }
     }
-
+    
     fn eat(&self) {
         println!("{} is done eating.", self.name);
     }
@@ -267,15 +267,15 @@ use std::thread;
 
 struct Philosopher {
     name: String,
-}
+}   
 
-impl Philosopher {
+impl Philosopher { 
     fn new(name: &str) -> Philosopher {
         Philosopher {
             name: name.to_string(),
         }
     }
-
+    
     fn eat(&self) {
         println!("{} is eating.", self.name);
 
@@ -348,9 +348,9 @@ use std::thread;
 
 struct Philosopher {
     name: String,
-}
+}   
 
-impl Philosopher {
+impl Philosopher { 
     fn new(name: &str) -> Philosopher {
         Philosopher {
             name: name.to_string(),
@@ -401,7 +401,7 @@ let handles: Vec<_> = philosophers.into_iter().map(|p| {
 While this is only five lines, they’re a dense five. Let’s break it down.
 
 ```rust,ignore
-let handles: Vec<_> =
+let handles: Vec<_> = 
 ```
 
 We introduce a new binding, called `handles`. We’ve given it this name because
@@ -460,15 +460,15 @@ If you run this program, you’ll see that the philosophers eat out of order!
 We have multi-threading!
 
 ```text
-Judith Butler is eating.
 Gilles Deleuze is eating.
-Karl Marx is eating.
+Gilles Deleuze is done eating.
 Emma Goldman is eating.
+Emma Goldman is done eating.
 Michel Foucault is eating.
+Judith Butler is eating.
 Judith Butler is done eating.
-Gilles Deleuze is done eating.
+Karl Marx is eating.
 Karl Marx is done eating.
-Emma Goldman is done eating.
 Michel Foucault is done eating.
 ```
 

branches/try/src/liballoc/boxed.rs

@@ -71,7 +71,7 @@ use core::raw::{TraitObject};
 /// The following two examples are equivalent:
 ///
 /// ```
-/// #![feature(box_heap)]
+/// # #![feature(box_heap)]
 /// #![feature(box_syntax)]
 /// use std::boxed::HEAP;
 ///
@@ -162,7 +162,7 @@ impl<T : ?Sized> Box<T> {
 ///
 /// # Examples
 /// ```
-/// #![feature(box_raw)]
+/// # #![feature(box_raw)]
 /// use std::boxed;
 ///
 /// let seventeen = Box::new(17u32);

branches/try/src/libcollections/slice.rs

@@ -1056,17 +1056,6 @@ pub trait SliceConcatExt<T: ?Sized> {
     #[stable(feature = "rust1", since = "1.0.0")]
     fn concat(&self) -> Self::Output;
 
-    /// Flattens a slice of `T` into a single value `Self::Output`, placing a
-    /// given separator between each.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// assert_eq!(["hello", "world"].join(" "), "hello world");
-    /// ```
-    #[stable(feature = "rename_connect_to_join", since = "1.3.0")]
-    fn join(&self, sep: &T) -> Self::Output;
-
     /// Flattens a slice of `T` into a single value `Self::Output`, placing a
     /// given separator between each.
     ///
@@ -1076,7 +1065,6 @@ pub trait SliceConcatExt<T: ?Sized> {
     /// assert_eq!(["hello", "world"].connect(" "), "hello world");
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    #[deprecated(since = "1.3.0", reason = "renamed to join")]
     fn connect(&self, sep: &T) -> Self::Output;
 }
 
@@ -1092,7 +1080,7 @@ impl<T: Clone, V: Borrow<[T]>> SliceConcatExt<T> for [V] {
         result
     }
 
-    fn join(&self, sep: &T) -> Vec<T> {
+    fn connect(&self, sep: &T) -> Vec<T> {
         let size = self.iter().fold(0, |acc, v| acc + v.borrow().len());
         let mut result = Vec::with_capacity(size + self.len());
         let mut first = true;
@@ -1102,10 +1090,6 @@ impl<T: Clone, V: Borrow<[T]>> SliceConcatExt<T> for [V] {
         }
         result
     }
-
-    fn connect(&self, sep: &T) -> Vec<T> {
-        self.join(sep)
-    }
 }
 
 /// An iterator that yields the element swaps needed to produce

branches/try/src/libcollections/str.rs

@@ -103,7 +103,7 @@ impl<S: Borrow<str>> SliceConcatExt<str> for [S] {
         result
     }
 
-    fn join(&self, sep: &str) -> String {
+    fn connect(&self, sep: &str) -> String {
         if self.is_empty() {
             return String::new();
         }
@@ -130,10 +130,6 @@ impl<S: Borrow<str>> SliceConcatExt<str> for [S] {
         }
         result
     }
-
-    fn connect(&self, sep: &str) -> String {
-        self.join(sep)
-    }
 }
 
 // Helper functions used for Unicode normalization

branches/try/src/libcollectionstest/slice.rs

@@ -583,22 +583,22 @@ fn test_concat() {
     assert_eq!(d, [1, 2, 3]);
 
     let v: &[&[_]] = &[&[1], &[2, 3]];
-    assert_eq!(v.join(&0), [1, 0, 2, 3]);
+    assert_eq!(v.connect(&0), [1, 0, 2, 3]);
     let v: &[&[_]] = &[&[1], &[2], &[3]];
-    assert_eq!(v.join(&0), [1, 0, 2, 0, 3]);
+    assert_eq!(v.connect(&0), [1, 0, 2, 0, 3]);
 }
 
 #[test]
-fn test_join() {
+fn test_connect() {
     let v: [Vec<i32>; 0] = [];
-    assert_eq!(v.join(&0), []);
-    assert_eq!([vec![1], vec![2, 3]].join(&0), [1, 0, 2, 3]);
-    assert_eq!([vec![1], vec![2], vec![3]].join(&0), [1, 0, 2, 0, 3]);
+    assert_eq!(v.connect(&0), []);
+    assert_eq!([vec![1], vec![2, 3]].connect(&0), [1, 0, 2, 3]);
+    assert_eq!([vec![1], vec![2], vec![3]].connect(&0), [1, 0, 2, 0, 3]);
 
     let v: [&[_]; 2] = [&[1], &[2, 3]];
-    assert_eq!(v.join(&0), [1, 0, 2, 3]);
+    assert_eq!(v.connect(&0), [1, 0, 2, 3]);
     let v: [&[_]; 3] = [&[1], &[2], &[3]];
-    assert_eq!(v.join(&0), [1, 0, 2, 0, 3]);
+    assert_eq!(v.connect(&0), [1, 0, 2, 0, 3]);
 }
 
 #[test]
@@ -1316,11 +1316,11 @@ mod bench {
     }
 
     #[bench]
-    fn join(b: &mut Bencher) {
+    fn connect(b: &mut Bencher) {
         let xss: Vec<Vec<i32>> =
             (0..100).map(|i| (0..i).collect()).collect();
         b.iter(|| {
-            xss.join(&0)
+            xss.connect(&0)
         });
     }
 

branches/try/src/libcollectionstest/str.rs

@@ -158,32 +158,32 @@ fn test_concat_for_different_lengths() {
     test_concat!("abc", ["", "a", "bc"]);
 }
 
-macro_rules! test_join {
+macro_rules! test_connect {
     ($expected: expr, $string: expr, $delim: expr) => {
         {
-            let s = $string.join($delim);
+            let s = $string.connect($delim);
             assert_eq!($expected, s);
         }
     }
 }
 
 #[test]
-fn test_join_for_different_types() {
-    test_join!("a-b", ["a", "b"], "-");
+fn test_connect_for_different_types() {
+    test_connect!("a-b", ["a", "b"], "-");
     let hyphen = "-".to_string();
-    test_join!("a-b", [s("a"), s("b")], &*hyphen);
-    test_join!("a-b", vec!["a", "b"], &*hyphen);
-    test_join!("a-b", &*vec!["a", "b"], "-");
-    test_join!("a-b", vec![s("a"), s("b")], "-");
+    test_connect!("a-b", [s("a"), s("b")], &*hyphen);
+    test_connect!("a-b", vec!["a", "b"], &*hyphen);
+    test_connect!("a-b", &*vec!["a", "b"], "-");
+    test_connect!("a-b", vec![s("a"), s("b")], "-");
 }
 
 #[test]
-fn test_join_for_different_lengths() {
+fn test_connect_for_different_lengths() {
     let empty: &[&str] = &[];
-    test_join!("", empty, "-");
-    test_join!("a", ["a"], "-");
-    test_join!("a-b", ["a", "b"], "-");
-    test_join!("-a-bc", ["", "a", "bc"], "-");
+    test_connect!("", empty, "-");
+    test_connect!("a", ["a"], "-");
+    test_connect!("a-b", ["a", "b"], "-");
+    test_connect!("-a-bc", ["", "a", "bc"], "-");
 }
 
 #[test]
@@ -2089,12 +2089,12 @@ mod bench {
     }
 
     #[bench]
-    fn bench_join(b: &mut Bencher) {
+    fn bench_connect(b: &mut Bencher) {
         let s = "ศไทย中华Việt Nam; Mary had a little lamb, Little lamb";
         let sep = "→";
         let v = vec![s, s, s, s, s, s, s, s, s, s];
         b.iter(|| {
-            assert_eq!(v.join(sep).len(), s.len() * 10 + sep.len() * 9);
+            assert_eq!(v.connect(sep).len(), s.len() * 10 + sep.len() * 9);
         })
     }
 

branches/try/src/libcore/num/mod.rs

@@ -459,15 +459,15 @@ macro_rules! int_impl {
             }
         }
 
-        /// Wrapping (modular) division. Computes `self / other`,
+        /// Wrapping (modular) division. Computes `floor(self / other)`,
         /// wrapping around at the boundary of the type.
         ///
         /// The only case where such wrapping can occur is when one
         /// divides `MIN / -1` on a signed type (where `MIN` is the
         /// negative minimal value for the type); this is equivalent
         /// to `-MIN`, a positive value that is too large to represent
         /// in the type. In such a case, this function returns `MIN`
-        /// itself.
+        /// itself..
         #[stable(feature = "num_wrapping", since = "1.2.0")]
         #[inline(always)]
         pub fn wrapping_div(self, rhs: Self) -> Self {
@@ -1031,15 +1031,15 @@ macro_rules! uint_impl {
             }
         }
 
-        /// Wrapping (modular) division. Computes `self / other`,
+        /// Wrapping (modular) division. Computes `floor(self / other)`,
         /// wrapping around at the boundary of the type.
         ///
         /// The only case where such wrapping can occur is when one
         /// divides `MIN / -1` on a signed type (where `MIN` is the
         /// negative minimal value for the type); this is equivalent
         /// to `-MIN`, a positive value that is too large to represent
         /// in the type. In such a case, this function returns `MIN`
-        /// itself.
+        /// itself..
         #[stable(feature = "num_wrapping", since = "1.2.0")]
         #[inline(always)]
         pub fn wrapping_div(self, rhs: Self) -> Self {