Introduce Core trait to reduce PhantomData

Author: hecrj

src/core.rs

@@ -0,0 +1,21 @@
+use crate::{Future, Stream};
+
+/// The core trait of a [`Sipper`].
+///
+/// It is used internally for convenience to avoid phantom data, since it
+/// has [`Output`] and [`Progress`] as associated types.
+pub trait Core: Future<Output = <Self as Core>::Output> + Stream<Item = Self::Progress> {
+    /// The output of the [`Sipper`].
+    type Output;
+
+    /// The progress of the [`Sipper`].
+    type Progress;
+}
+
+impl<T> Core for T
+where
+    T: Future + Stream,
+{
+    type Output = <T as Future>::Output;
+    type Progress = T::Item;
+}

src/filter_with.rs

@@ -1,4 +1,4 @@
-use crate::{Future, Sipper, Stream};
+use crate::{Core, Future, Stream};
 
 use pin_project_lite::pin_project;
 
@@ -10,16 +10,16 @@ pin_project! {
     /// Maps and filters the progress of a [`Sipper`].
     ///
     /// The result of [`Sipper::filter_with`].
-    pub struct FilterWith<S, Output, Progress, A,F>
+    pub struct FilterWith<S, F, A>
     {
         #[pin]
         sipper: S,
         mapper: F,
-        _types: PhantomData<(Output, Progress, A)>,
+        _types: PhantomData<A>,
     }
 }
 
-impl<S, Output, Progress, A, F> FilterWith<S, Output, Progress, A, F> {
+impl<S, F, A> FilterWith<S, F, A> {
     pub(crate) fn new(sipper: S, mapper: F) -> Self {
         Self {
             sipper,
@@ -29,22 +29,22 @@ impl<S, Output, Progress, A, F> FilterWith<S, Output, Progress, A, F> {
     }
 }
 
-impl<S, Output, Progress, A, F> Future for FilterWith<S, Output, Progress, A, F>
+impl<S, F, A> Future for FilterWith<S, F, A>
 where
-    S: Sipper<Output, Progress>,
+    S: Core,
 {
-    type Output = Output;
+    type Output = <S as Core>::Output;
 
     fn poll(self: Pin<&mut Self>, cx: &mut task::Context<'_>) -> task::Poll<Self::Output> {
         let this = self.project();
         this.sipper.poll(cx)
     }
 }
 
-impl<S, Output, Progress, A, F> Stream for FilterWith<S, Output, Progress, A, F>
+impl<S, F, A> Stream for FilterWith<S, F, A>
 where
-    S: Sipper<Output, Progress>,
-    F: FnMut(Progress) -> Option<A>,
+    S: Core,
+    F: FnMut(S::Progress) -> Option<A>,
 {
     type Item = A;
 

src/lib.rs

@@ -263,12 +263,14 @@
 //! [`with`]: Sipper::with
 //! [`filter_with`]: Sipper::filter_with
 //! [`run`]: Sipper::run
+mod core;
 mod filter_with;
 mod run;
 mod sender;
 mod straw;
 mod with;
 
+pub use core::Core;
 pub use filter_with::FilterWith;
 pub use run::Run;
 pub use sender::Sender;
@@ -287,15 +289,16 @@ pub use futures::never::Never;
 #[doc(no_inline)]
 pub use futures::{Future, FutureExt, Sink, Stream, StreamExt};
 
-/// A sipper is a [`Future`] that can notify progress.
+/// A sipper is both a [`Stream`] that produces a bunch of progress
+/// and a [`Future`] that produces some final output.
 pub trait Sipper<Output, Progress = Output>:
-    Future<Output = Output> + Stream<Item = Progress>
+    core::Core<Output = Output, Progress = Progress>
 {
     /// Maps the progress of the [`Sipper`] with the given closure.
     ///
     /// This is analogous to `map` in many other types; but we use `with`
     /// to avoid naming collisions with [`Future`] and [`Stream`].
-    fn with<F, A>(self, f: F) -> With<Self, Output, Progress, A, F>
+    fn with<F, A>(self, f: F) -> With<Self, F, A>
     where
         Self: Sized,
         F: FnMut(Progress) -> A,
@@ -307,7 +310,7 @@ pub trait Sipper<Output, Progress = Output>:
     ///
     /// This is analogous to `filter_map` in many other types; but we use `filter_with`
     /// to avoid naming collisions with [`Future`] and [`Stream`].
-    fn filter_with<F, A>(self, f: F) -> FilterWith<Self, Output, Progress, A, F>
+    fn filter_with<F, A>(self, f: F) -> FilterWith<Self, F, A>
     where
         Self: Sized,
         F: FnMut(Progress) -> Option<A>,
@@ -328,7 +331,7 @@ pub trait Sipper<Output, Progress = Output>:
 
     /// Runs the [`Sipper`], sending any progress through the given [`Sender`] and returning
     /// its output at the end.
-    fn run<S>(self, on_progress: impl Into<Sender<Progress, S>>) -> Run<Self, S, Output, Progress>
+    fn run<S>(self, on_progress: impl Into<Sender<Progress, S>>) -> Run<Self, S>
     where
         Self: Sized,
         S: Sink<Progress>,
@@ -348,7 +351,7 @@ pub trait Sipper<Output, Progress = Output>:
 }
 
 impl<T, Output, Progress> Sipper<Output, Progress> for T where
-    T: Future<Output = Output> + Stream<Item = Progress>
+    T: core::Core<Output = Output, Progress = Progress>
 {
 }
 

src/run.rs

@@ -1,8 +1,7 @@
-use crate::{Future, Sink, Sipper};
+use crate::{Core, Future, Sink};
 
 use pin_project_lite::pin_project;
 
-use std::marker::PhantomData;
 use std::pin::Pin;
 use std::task;
 
@@ -11,24 +10,22 @@ pin_project! {
     /// its output at the end.
     ///
     /// The result of [`Sipper::run`].
-    pub struct Run<S, Si, Output, Progress>
+    pub struct Run<S: Core, Si>
     {
         #[pin]
         sipper: S,
         #[pin]
         on_progress: Si,
-        state: State<Progress>,
-        _types: PhantomData<(Output, Progress)>,
+        state: State<S::Progress>,
     }
 }
 
-impl<S, Si, Output, Progress> Run<S, Si, Output, Progress> {
+impl<S: Core, Si> Run<S, Si> {
     pub(crate) fn new(sipper: S, on_progress: Si) -> Self {
         Self {
             sipper,
             on_progress,
             state: State::Read,
-            _types: PhantomData,
         }
     }
 }
@@ -41,12 +38,12 @@ enum State<T> {
     Output,
 }
 
-impl<S, Si, Output, Progress> Future for Run<S, Si, Output, Progress>
+impl<S, Si> Future for Run<S, Si>
 where
-    S: Sipper<Output, Progress>,
-    Si: Sink<Progress>,
+    S: Core,
+    Si: Sink<S::Progress>,
 {
-    type Output = Output;
+    type Output = <S as Core>::Output;
 
     fn poll(self: Pin<&mut Self>, cx: &mut task::Context<'_>) -> task::Poll<Self::Output> {
         use futures::ready;

src/with.rs

@@ -1,4 +1,4 @@
-use crate::{Future, Sipper, Stream};
+use crate::{Core, Future, Stream};
 
 use pin_project_lite::pin_project;
 
@@ -10,16 +10,16 @@ pin_project! {
     /// Maps the progress of a [`Sipper`].
     ///
     /// The result of [`Sipper::with`].
-    pub struct With<S, Output, Progress, A, F>
+    pub struct With<S, F, A>
     {
         #[pin]
         sipper: S,
         mapper: F,
-        _types: PhantomData<(Output, Progress, A)>,
+        _types: PhantomData<A>,
     }
 }
 
-impl<S, Output, Progress, A, F> With<S, Output, Progress, A, F> {
+impl<S, F, A> With<S, F, A> {
     pub(crate) fn new(sipper: S, mapper: F) -> Self {
         Self {
             sipper,
@@ -29,22 +29,22 @@ impl<S, Output, Progress, A, F> With<S, Output, Progress, A, F> {
     }
 }
 
-impl<S, Output, Progress, A, F> Future for With<S, Output, Progress, A, F>
+impl<S, F, A> Future for With<S, F, A>
 where
-    S: Sipper<Output, Progress>,
+    S: Core,
 {
-    type Output = Output;
+    type Output = <S as Core>::Output;
 
     fn poll(self: Pin<&mut Self>, cx: &mut task::Context<'_>) -> task::Poll<Self::Output> {
         let this = self.project();
         this.sipper.poll(cx)
     }
 }
 
-impl<S, Output, Progress, A, F> Stream for With<S, Output, Progress, A, F>
+impl<S, F, A> Stream for With<S, F, A>
 where
-    S: Sipper<Output, Progress>,
-    F: FnMut(Progress) -> A,
+    S: Core,
+    F: FnMut(S::Progress) -> A,
 {
     type Item = A;