turn the Option<St> into a St

`MapWhile` doesn't need to remember whether it's done. As per the contract of the `Stream` trait:

> Once a stream has finished (returned Ready(None) from poll_next), calling its poll_next method again may panic, block forever, or cause other kinds of problems; the Stream trait places no requirements on the effects of such a call.

This allows us to save the space that may be needed by the boolean,
but also lets us simplify the implementation. People can use `fuse`
if they so need.

tokio-stream/src/stream_ext/map_while.rs

@@ -10,7 +10,7 @@ pin_project! {
     #[must_use = "streams do nothing unless polled"]
     pub struct MapWhile<St, F> {
         #[pin]
-        stream: Option<St>,
+        stream: St,
         f: F,
     }
 }
@@ -28,10 +28,7 @@ where
 
 impl<St, F> MapWhile<St, F> {
     pub(super) fn new(stream: St, f: F) -> Self {
-        MapWhile {
-            stream: Some(stream),
-            f,
-        }
+        MapWhile { stream, f }
     }
 }
 
@@ -43,28 +40,13 @@ where
     type Item = T;
 
     fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<T>> {
-        let mut me = self.project();
+        let me = self.project();
         let f = me.f;
-        match me.stream.as_mut().as_pin_mut() {
-            Some(stream) => match stream.poll_next(cx).map(|opt| opt.and_then(f)) {
-                Poll::Ready(Some(item)) => Poll::Ready(Some(item)),
-                Poll::Ready(None) => {
-                    me.stream.set(None);
-                    Poll::Ready(None)
-                }
-                Poll::Pending => Poll::Pending,
-            },
-            None => Poll::Ready(None),
-        }
+        me.stream.poll_next(cx).map(|opt| opt.and_then(f))
     }
 
     fn size_hint(&self) -> (usize, Option<usize>) {
-        self.stream
-            .as_ref()
-            .map(|stream| {
-                let (_, upper) = stream.size_hint();
-                (0, upper)
-            })
-            .unwrap_or((0, Some(0)))
+        let (_, upper) = self.stream.size_hint();
+        (0, upper)
     }
 }