---

yaml
---
r: 229051
b: refs/heads/try
c: ddb0290
h: refs/heads/master
i:
  229049: aa1b6b8
  229047: a1169d9
v: v3

Author: Gankra

[refs]

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

branches/try/src/doc/tarpl/borrow-splitting.md

@@ -137,6 +137,7 @@ impl<'a, T> Iterator for IterMut<'a, T> {
 Here's a mutable slice:
 
 ```rust
+# fn main() {}
 use std::mem;
 
 pub struct IterMut<'a, T: 'a>(&'a mut[T]);
@@ -170,6 +171,7 @@ impl<'a, T> DoubleEndedIterator for IterMut<'a, T> {
 And here's a binary tree:
 
 ```rust
+# fn main() {}
 use std::collections::VecDeque;
 
 type Link<T> = Option<Box<Node<T>>>;
@@ -262,7 +264,7 @@ impl<'a, T> Iterator for IterMut<'a, T> {
 }
 
 impl<'a, T> DoubleEndedIterator for IterMut<'a, T> {
-    fn next(&mut self) -> Option<Self::Item> {
+    fn next_back(&mut self) -> Option<Self::Item> {
         loop {
             match self.0.back_mut().and_then(|node_it| node_it.next_back()) {
                 Some(State::Elem(elem)) => return Some(elem),

branches/try/src/doc/tarpl/dropck.md

@@ -8,12 +8,12 @@ when we talked about `'a: 'b`, it was ok for `'a` to live *exactly* as long as
 gets dropped at the same time as another, right? This is why we used the
 following desugarring of `let` statements:
 
-```rust
+```rust,ignore
 let x;
 let y;
 ```
 
-```rust
+```rust,ignore
 {
     let x;
     {
@@ -25,7 +25,7 @@ let y;
 Each creates its own scope, clearly establishing that one drops before the
 other. However, what if we do the following?
 
-```rust
+```rust,ignore
 let (x, y) = (vec![], vec![]);
 ```
 

branches/try/src/doc/tarpl/leaking.md

@@ -188,7 +188,7 @@ data on their parent's stack without any synchronization over that data by
 ensuring the parent joins the thread before any of the shared data goes out
 of scope.
 
-```rust
+```rust,ignore
 pub fn scoped<'a, F>(f: F) -> JoinGuard<'a>
     where F: FnOnce() + Send + 'a
 ```

branches/try/src/doc/tarpl/safe-unsafe-meaning.md

@@ -114,7 +114,7 @@ implementation:
 ```rust
 # use std::cmp::Ordering;
 # struct MyType;
-# pub unsafe trait UnsafeOrd { fn cmp(&self, other: &Self) -> Ordering; }
+# unsafe trait UnsafeOrd { fn cmp(&self, other: &Self) -> Ordering; }
 unsafe impl UnsafeOrd for MyType {
     fn cmp(&self, other: &Self) -> Ordering {
         Ordering::Equal

branches/try/src/doc/tarpl/vec-layout.md

@@ -12,7 +12,6 @@ pub struct Vec<T> {
     cap: usize,
     len: usize,
 }
-
 # fn main() {}
 ```
 
@@ -69,6 +68,7 @@ impl<T> Deref for Unique<T> {
         unsafe { mem::transmute(&self.ptr) }
     }
 }
+# fn main() {}
 ```
 
 Unfortunately the mechanism for stating that your value is non-zero is