Refactor TryStream combinator

Author: MajorBreakfast

futures-util/src/try_stream/mod.rs

@@ -15,8 +15,8 @@ impl<S: TryStream> TryStreamExt for S {}
 
 /// Adapters specific to `Result`-returning streams
 pub trait TryStreamExt: TryStream {
-    /// Attempt to Collect all of the values of this stream into a vector, returning a
-    /// future representing the result of that computation.
+    /// Attempt to Collect all of the values of this stream into a vector,
+    /// returning a future representing the result of that computation.
     ///
     /// This combinator will collect all successful results of this stream and
     /// collect them into a `Vec<Self::Item>`. If an error happens then all
@@ -53,6 +53,6 @@ pub trait TryStreamExt: TryStream {
     fn try_collect<C: Default + Extend<Self::Ok>>(self) -> TryCollect<Self, C>
         where Self: Sized
     {
-        try_collect::new(self)
+        TryCollect::new(self)
     }
 }

futures-util/src/try_stream/try_collect.rs

@@ -10,39 +10,37 @@ use std::prelude::v1::*;
 /// This future is created by the `Stream::try_collect` method.
 #[derive(Debug)]
 #[must_use = "streams do nothing unless polled"]
-pub struct TryCollect<S, C> where S: TryStream {
-    stream: S,
+pub struct TryCollect<St, C> where St: TryStream {
+    stream: St,
     items: C,
 }
 
-pub fn new<S, C>(s: S) -> TryCollect<S, C>
-    where S: TryStream, C: Default
-{
-    TryCollect {
-        stream: s,
-        items: Default::default(),
+impl<St: TryStream, C: Default> TryCollect<St, C> {
+    unsafe_pinned!(stream: St);
+    unsafe_unpinned!(items: C);
+
+    pub(super) fn new(s: St) -> TryCollect<St, C> {
+        TryCollect {
+            stream: s,
+            items: Default::default(),
+        }
     }
-}
 
-impl<S: TryStream, C: Default> TryCollect<S, C> {
     fn finish(mut self: PinMut<Self>) -> C {
         mem::replace(self.items(), Default::default())
     }
-
-    unsafe_pinned!(stream: S);
-    unsafe_unpinned!(items: C);
 }
 
-impl<S: Unpin + TryStream, C> Unpin for TryCollect<S, C> {}
+impl<St: Unpin + TryStream, C> Unpin for TryCollect<St, C> {}
 
-impl<S, C> Future for TryCollect<S, C>
-    where S: TryStream, C: Default + Extend<S::Ok>
+impl<St, C> Future for TryCollect<St, C>
+    where St: TryStream, C: Default + Extend<St::Ok>
 {
-    type Output = Result<C, S::Error>;
+    type Output = Result<C, St::Error>;
 
     fn poll(
         mut self: PinMut<Self>,
-        cx: &mut task::Context
+        cx: &mut task::Context,
     ) -> Poll<Self::Output> {
         loop {
             match ready!(self.stream().try_poll_next(cx)) {