From ae1856cb9ea58cdbd9b910de3b0b0ac164092812 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?John=20K=C3=A5re=20Alsaker?= <john.kare.alsaker@gmail.com>
Date: Fri, 21 Jul 2017 05:54:01 +0200
Subject: [PATCH] Update rename State in docs

---
 .../src/language-features/generators.md       | 22 +++++++++----------
 1 file changed, 11 insertions(+), 11 deletions(-)

diff --git a/src/doc/unstable-book/src/language-features/generators.md b/src/doc/unstable-book/src/language-features/generators.md
index a8d449382eec..3b7b77e2c3ed 100644
--- a/src/doc/unstable-book/src/language-features/generators.md
+++ b/src/doc/unstable-book/src/language-features/generators.md
@@ -28,7 +28,7 @@ A syntactical example of a generator is:
 ```rust
 #![feature(generators, generator_trait)]
 
-use std::ops::{Generator, State};
+use std::ops::{Generator, GeneratorState};
 
 fn main() {
     let mut generator = || {
@@ -37,11 +37,11 @@ fn main() {
     };
 
     match generator.resume() {
-        State::Yielded(1) => {}
+        GeneratorState::Yielded(1) => {}
         _ => panic!("unexpected value from resume"),
     }
     match generator.resume() {
-        State::Complete("foo") => {}
+        GeneratorState::Complete("foo") => {}
         _ => panic!("unexpected value from resume"),
     }
 }
@@ -87,12 +87,12 @@ The `Generator` trait in `std::ops` currently looks like:
 
 ```
 # #![feature(generator_trait)]
-# use std::ops::State;
+# use std::ops::GeneratorState;
 
 pub trait Generator {
     type Yield;
     type Return;
-    fn resume(&mut self) -> State<Self::Yield, Self::Return>;
+    fn resume(&mut self) -> GeneratorState<Self::Yield, Self::Return>;
 }
 ```
 
@@ -102,10 +102,10 @@ generator. This is typically the last expression in a generator's definition or
 any value passed to `return` in a generator. The `resume` function is the entry
 point for executing the `Generator` itself.
 
-The return value of `resume`, `State`, looks like:
+The return value of `resume`, `GeneratorState`, looks like:
 
 ```
-pub enum State<Y, R> {
+pub enum GeneratorState<Y, R> {
     Yielded(Y),
     Complete(R),
 }
@@ -185,7 +185,7 @@ This generator literal will compile down to something similar to:
 ```rust
 #![feature(generators, generator_trait)]
 
-use std::ops::{Generator, State};
+use std::ops::{Generator, GeneratorState};
 
 fn main() {
     let ret = "foo";
@@ -200,17 +200,17 @@ fn main() {
             type Yield = i32;
             type Return = &'static str;
 
-            fn resume(&mut self) -> State<i32, &'static str> {
+            fn resume(&mut self) -> GeneratorState<i32, &'static str> {
                 use std::mem;
                 match mem::replace(self, __Generator::Done) {
                     __Generator::Start(s) => {
                         *self = __Generator::Yield1(s);
-                        State::Yielded(1)
+                        GeneratorState::Yielded(1)
                     }
 
                     __Generator::Yield1(s) => {
                         *self = __Generator::Done;
-                        State::Complete(s)
+                        GeneratorState::Complete(s)
                     }
 
                     __Generator::Done => {