---

yaml
---
r: 233798
b: refs/heads/beta
c: c5ab116
h: refs/heads/master
v: v3

Author: zaeleus

[refs]

@@ -23,7 +23,7 @@ refs/tags/0.9: 36870b185fc5f5486636d4515f0e22677493f225
 refs/tags/0.10: ac33f2b15782272ae348dbd7b14b8257b2148b5a
 refs/tags/0.11.0: e1247cb1d0d681be034adb4b558b5a0c0d5720f9
 refs/tags/0.12.0: f0c419429ef30723ceaf6b42f9b5a2aeb5d2e2d1
-refs/heads/beta: 3a804114158dbde947cd9fffc2ad28be9c1dd14c
+refs/heads/beta: c5ab1166e7869dd8188beba435c8557b221db93b
 refs/tags/1.0.0-alpha: e42bd6d93a1d3433c486200587f8f9e12590a4d7
 refs/heads/tmp: 370fe2786109360f7c35b8ba552b83b773dd71d6
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f

branches/beta/src/doc/trpl/testing.md

@@ -120,26 +120,13 @@ And that's reflected in the summary line:
 test result: FAILED. 0 passed; 1 failed; 0 ignored; 0 measured
 ```
 
-We also get a non-zero status code. We can use `$?` on OS X and Linux:
+We also get a non-zero status code:
 
 ```bash
 $ echo $?
 101
 ```
 
-On Windows, if you’re using `cmd`:
-
-```bash
-> echo %ERRORLEVEL%
-```
-
-And if you’re using PowerShell:
-
-```bash
-> echo $LASTEXITCODE # the code itself
-> echo $? # a boolean, fail or succeed
-```
-
 This is useful if you want to integrate `cargo test` into other tooling.
 
 We can invert our test's failure with another attribute: `should_panic`:

branches/beta/src/libcollections/lib.rs

@@ -113,7 +113,7 @@ mod std {
 }
 
 /// An endpoint of a range of keys.
-#[unstable(feature = "collections_bound", issue = "27787")]
+#[unstable(feature = "collections_bound", issue = "27711")]
 #[derive(Clone, Copy, Debug, Hash, PartialEq, Eq)]
 pub enum Bound<T> {
     /// An inclusive bound.

branches/beta/src/libcollections/string.rs

@@ -734,8 +734,7 @@ impl String {
     ///
     /// Note that this will drop any excess capacity.
     #[unstable(feature = "box_str",
-               reason = "recently added, matches RFC",
-               issue = "27785")]
+               reason = "recently added, matches RFC")]
     #[deprecated(since = "1.4.0", reason = "renamed to `into_boxed_str`")]
     pub fn into_boxed_slice(self) -> Box<str> {
         self.into_boxed_str()
@@ -769,27 +768,18 @@ impl fmt::Display for FromUtf16Error {
 
 #[stable(feature = "rust1", since = "1.0.0")]
 impl FromIterator<char> for String {
-    fn from_iter<I: IntoIterator<Item=char>>(iterable: I) -> String {
+    fn from_iter<I: IntoIterator<Item=char>>(iter: I) -> String {
         let mut buf = String::new();
-        buf.extend(iterable);
+        buf.extend(iter);
         buf
     }
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<'a> FromIterator<&'a str> for String {
-    fn from_iter<I: IntoIterator<Item=&'a str>>(iterable: I) -> String {
-        let mut buf = String::new();
-        buf.extend(iterable);
-        buf
-    }
-}
-
-#[stable(feature = "extend_string", since = "1.4.0")]
-impl FromIterator<String> for String {
-    fn from_iter<I: IntoIterator<Item=String>>(iterable: I) -> String {
+    fn from_iter<I: IntoIterator<Item=&'a str>>(iter: I) -> String {
         let mut buf = String::new();
-        buf.extend(iterable);
+        buf.extend(iter);
         buf
     }
 }
@@ -808,8 +798,8 @@ impl Extend<char> for String {
 
 #[stable(feature = "extend_ref", since = "1.2.0")]
 impl<'a> Extend<&'a char> for String {
-    fn extend<I: IntoIterator<Item=&'a char>>(&mut self, iterable: I) {
-        self.extend(iterable.into_iter().cloned());
+    fn extend<I: IntoIterator<Item=&'a char>>(&mut self, iter: I) {
+        self.extend(iter.into_iter().cloned());
     }
 }
 
@@ -822,15 +812,6 @@ impl<'a> Extend<&'a str> for String {
     }
 }
 
-#[stable(feature = "extend_string", since = "1.4.0")]
-impl Extend<String> for String {
-    fn extend<I: IntoIterator<Item=String>>(&mut self, iterable: I) {
-        for s in iterable {
-            self.push_str(&s)
-        }
-    }
-}
-
 /// A convenience impl that delegates to the impl for `&str`
 impl<'a, 'b> Pattern<'a> for &'b String {
     type Searcher = <&'b str as Pattern<'a>>::Searcher;

branches/beta/src/libcore/macros.rs

@@ -239,8 +239,7 @@ macro_rules! writeln {
 /// ```
 #[macro_export]
 #[unstable(feature = "core",
-           reason = "relationship with panic is unclear",
-           issue = "27701")]
+           reason = "relationship with panic is unclear")]
 macro_rules! unreachable {
     () => ({
         panic!("internal error: entered unreachable code")
@@ -255,55 +254,9 @@ macro_rules! unreachable {
 
 /// A standardised placeholder for marking unfinished code. It panics with the
 /// message `"not yet implemented"` when executed.
-///
-/// This can be useful if you are prototyping and are just looking to have your
-/// code typecheck, or if you're implementing a trait that requires multiple
-/// methods, and you're only planning on using one of them.
-///
-/// # Examples
-///
-/// Here's an example of some in-progress code. We have a trait `Foo`:
-///
-/// ```
-/// trait Foo {
-///     fn bar(&self);
-///     fn baz(&self);
-/// }
-/// ```
-///
-/// We want to implement `Foo` on one of our types, but we also want to work on
-/// just `bar()` first. In order for our code to compile, we need to implement
-/// `baz()`, so we can use `unimplemented!`:
-///
-/// ```
-/// # trait Foo {
-/// #     fn foo(&self);
-/// #     fn bar(&self);
-/// # }
-/// struct MyStruct;
-///
-/// impl Foo for MyStruct {
-///     fn foo(&self) {
-///         // implementation goes here
-///     }
-///
-///     fn bar(&self) {
-///         // let's not worry about implementing bar() for now
-///         unimplemented!();
-///     }
-/// }
-///
-/// fn main() {
-///     let s = MyStruct;
-///     s.foo();
-///
-///     // we aren't even using bar() yet, so this is fine.
-/// }
-/// ```
 #[macro_export]
 #[unstable(feature = "core",
-           reason = "relationship with panic is unclear",
-           issue = "27701")]
+           reason = "relationship with panic is unclear")]
 macro_rules! unimplemented {
     () => (panic!("not yet implemented"))
 }

branches/beta/src/libcore/option.rs

@@ -779,26 +779,6 @@ impl<T> IntoIterator for Option<T> {
     }
 }
 
-#[stable(since = "1.4.0", feature = "option_iter")]
-impl<'a, T> IntoIterator for &'a Option<T> {
-    type Item = &'a T;
-    type IntoIter = Iter<'a, T>;
-
-    fn into_iter(self) -> Iter<'a, T> {
-        self.iter()
-    }
-}
-
-#[stable(since = "1.4.0", feature = "option_iter")]
-impl<'a, T> IntoIterator for &'a mut Option<T> {
-    type Item = &'a mut T;
-    type IntoIter = IterMut<'a, T>;
-
-    fn into_iter(mut self) -> IterMut<'a, T> {
-        self.iter_mut()
-    }
-}
-
 /////////////////////////////////////////////////////////////////////////////
 // The Option Iterators
 /////////////////////////////////////////////////////////////////////////////

branches/beta/src/libcore/result.rs

@@ -815,26 +815,6 @@ impl<T, E> IntoIterator for Result<T, E> {
     }
 }
 
-#[stable(since = "1.4.0", feature = "result_iter")]
-impl<'a, T, E> IntoIterator for &'a Result<T, E> {
-    type Item = &'a T;
-    type IntoIter = Iter<'a, T>;
-
-    fn into_iter(self) -> Iter<'a, T> {
-        self.iter()
-    }
-}
-
-#[stable(since = "1.4.0", feature = "result_iter")]
-impl<'a, T, E> IntoIterator for &'a mut Result<T, E> {
-    type Item = &'a mut T;
-    type IntoIter = IterMut<'a, T>;
-
-    fn into_iter(mut self) -> IterMut<'a, T> {
-        self.iter_mut()
-    }
-}
-
 /////////////////////////////////////////////////////////////////////////////
 // The Result Iterators
 /////////////////////////////////////////////////////////////////////////////

branches/beta/src/libcoretest/iter.rs

@@ -9,6 +9,7 @@
 // except according to those terms.
 
 use core::iter::*;
+use core::iter::order::*;
 use core::{i8, i16, isize};
 use core::usize;
 
@@ -20,51 +21,51 @@ fn test_lt() {
     let xs = [1,2,3];
     let ys = [1,2,0];
 
-    assert!(!xs.iter().lt(ys.iter()));
-    assert!(!xs.iter().le(ys.iter()));
-    assert!( xs.iter().gt(ys.iter()));
-    assert!( xs.iter().ge(ys.iter()));
+    assert!(!lt(xs.iter(), ys.iter()));
+    assert!(!le(xs.iter(), ys.iter()));
+    assert!( gt(xs.iter(), ys.iter()));
+    assert!( ge(xs.iter(), ys.iter()));
 
-    assert!( ys.iter().lt(xs.iter()));
-    assert!( ys.iter().le(xs.iter()));
-    assert!(!ys.iter().gt(xs.iter()));
-    assert!(!ys.iter().ge(xs.iter()));
+    assert!( lt(ys.iter(), xs.iter()));
+    assert!( le(ys.iter(), xs.iter()));
+    assert!(!gt(ys.iter(), xs.iter()));
+    assert!(!ge(ys.iter(), xs.iter()));
 
-    assert!( empty.iter().lt(xs.iter()));
-    assert!( empty.iter().le(xs.iter()));
-    assert!(!empty.iter().gt(xs.iter()));
-    assert!(!empty.iter().ge(xs.iter()));
+    assert!( lt(empty.iter(), xs.iter()));
+    assert!( le(empty.iter(), xs.iter()));
+    assert!(!gt(empty.iter(), xs.iter()));
+    assert!(!ge(empty.iter(), xs.iter()));
 
     // Sequence with NaN
     let u = [1.0f64, 2.0];
     let v = [0.0f64/0.0, 3.0];
 
-    assert!(!u.iter().lt(v.iter()));
-    assert!(!u.iter().le(v.iter()));
-    assert!(!u.iter().gt(v.iter()));
-    assert!(!u.iter().ge(v.iter()));
+    assert!(!lt(u.iter(), v.iter()));
+    assert!(!le(u.iter(), v.iter()));
+    assert!(!gt(u.iter(), v.iter()));
+    assert!(!ge(u.iter(), v.iter()));
 
     let a = [0.0f64/0.0];
     let b = [1.0f64];
     let c = [2.0f64];
 
-    assert!(a.iter().lt(b.iter()) == (a[0] <  b[0]));
-    assert!(a.iter().le(b.iter()) == (a[0] <= b[0]));
-    assert!(a.iter().gt(b.iter()) == (a[0] >  b[0]));
-    assert!(a.iter().ge(b.iter()) == (a[0] >= b[0]));
+    assert!(lt(a.iter(), b.iter()) == (a[0] <  b[0]));
+    assert!(le(a.iter(), b.iter()) == (a[0] <= b[0]));
+    assert!(gt(a.iter(), b.iter()) == (a[0] >  b[0]));
+    assert!(ge(a.iter(), b.iter()) == (a[0] >= b[0]));
 
-    assert!(c.iter().lt(b.iter()) == (c[0] <  b[0]));
-    assert!(c.iter().le(b.iter()) == (c[0] <= b[0]));
-    assert!(c.iter().gt(b.iter()) == (c[0] >  b[0]));
-    assert!(c.iter().ge(b.iter()) == (c[0] >= b[0]));
+    assert!(lt(c.iter(), b.iter()) == (c[0] <  b[0]));
+    assert!(le(c.iter(), b.iter()) == (c[0] <= b[0]));
+    assert!(gt(c.iter(), b.iter()) == (c[0] >  b[0]));
+    assert!(ge(c.iter(), b.iter()) == (c[0] >= b[0]));
 }
 
 #[test]
 fn test_multi_iter() {
     let xs = [1,2,3,4];
     let ys = [4,3,2,1];
-    assert!(xs.iter().eq(ys.iter().rev()));
-    assert!(xs.iter().lt(xs.iter().skip(2)));
+    assert!(eq(xs.iter(), ys.iter().rev()));
+    assert!(lt(xs.iter(), xs.iter().skip(2)));
 }
 
 #[test]

branches/beta/src/libcoretest/option.rs

@@ -180,14 +180,11 @@ fn test_iter() {
     assert_eq!(it.next(), Some(&val));
     assert_eq!(it.size_hint(), (0, Some(0)));
     assert!(it.next().is_none());
-
-    let mut it = (&x).into_iter();
-    assert_eq!(it.next(), Some(&val));
 }
 
 #[test]
 fn test_mut_iter() {
-    let mut val = 5;
+    let val = 5;
     let new_val = 11;
 
     let mut x = Some(val);
@@ -208,10 +205,6 @@ fn test_mut_iter() {
         assert!(it.next().is_none());
     }
     assert_eq!(x, Some(new_val));
-
-    let mut y = Some(val);
-    let mut it = (&mut y).into_iter();
-    assert_eq!(it.next(), Some(&mut val));
 }
 
 #[test]

branches/beta/src/libcoretest/result.rs

@@ -150,36 +150,3 @@ pub fn test_expect_err() {
     let err: Result<isize, &'static str> = Err("All good");
     err.expect("Got expected error");
 }
-
-#[test]
-pub fn test_iter() {
-    let ok: Result<isize, &'static str> = Ok(100);
-    let mut it = ok.iter();
-    assert_eq!(it.size_hint(), (1, Some(1)));
-    assert_eq!(it.next(), Some(&100));
-    assert_eq!(it.size_hint(), (0, Some(0)));
-    assert!(it.next().is_none());
-    assert_eq!((&ok).into_iter().next(), Some(&100));
-
-    let err: Result<isize, &'static str> = Err("error");
-    assert_eq!(err.iter().next(), None);
-}
-
-#[test]
-pub fn test_iter_mut() {
-    let mut ok: Result<isize, &'static str> = Ok(100);
-    for loc in ok.iter_mut() {
-        *loc = 200;
-    }
-    assert_eq!(ok, Ok(200));
-    for loc in &mut ok {
-        *loc = 300;
-    }
-    assert_eq!(ok, Ok(300));
-
-    let mut err: Result<isize, &'static str> = Err("error");
-    for loc in err.iter_mut() {
-        *loc = 200;
-    }
-    assert_eq!(err, Err("error"));
-}