Replace empty enums with Never type

futures-core/src/lib.rs

@@ -29,6 +29,9 @@ pub mod stream;
 pub mod task;
 #[doc(hidden)] pub use self::task::Poll;
 
+pub mod never;
+#[doc(hidden)] pub use self::never::Never;
+
 #[doc(hidden)]
 pub mod core_reexport {
     #[doc(hidden)]

futures-core/src/never.rs

@@ -0,0 +1,17 @@
+//! Definition of the `Never` type,
+//! a stand-in for the `!` type until it becomes stable.
+
+/// A type with no possible values.
+///
+/// This is used to indicate values which can never be created, such as the
+/// error type of infallible futures.
+///
+/// This type is a stable equivalent to the `!` type from `std`.
+///
+/// This is currently an alias for [`std::convert::Infallible`], but in
+/// the future it may be an alias for [`!`][never].
+/// See ["Future compatibility" section of `std::convert::Infallible`][infallible] for more.
+///
+/// [never]: https://doc.rust-lang.org/nightly/std/primitive.never.html
+/// [infallible]: https://doc.rust-lang.org/nightly/std/convert/enum.Infallible.html#future-compatibility
+pub type Never = core::convert::Infallible;

futures-sink/src/lib.rs

@@ -165,14 +165,10 @@ mod channel_impls;
 #[cfg(feature = "alloc")]
 mod if_alloc {
     use super::*;
+    use futures_core::never::Never;
 
-    /// The error type for `Vec` and `VecDequeue` when used as `Sink`s.
-    /// Values of this type can never be created.
-    #[derive(Copy, Clone, Debug)]
-    pub enum VecSinkError {}
-
-    impl<T> Sink<T> for ::alloc::vec::Vec<T> {
-        type SinkError = VecSinkError;
+    impl<T> Sink<T> for alloc::vec::Vec<T> {
+        type SinkError = Never;
 
         fn poll_ready(self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<Result<(), Self::SinkError>> {
             Poll::Ready(Ok(()))
@@ -193,8 +189,8 @@ mod if_alloc {
         }
     }
 
-    impl<T> Sink<T> for ::alloc::collections::VecDeque<T> {
-        type SinkError = VecSinkError;
+    impl<T> Sink<T> for alloc::collections::VecDeque<T> {
+        type SinkError = Never;
 
         fn poll_ready(self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<Result<(), Self::SinkError>> {
             Poll::Ready(Ok(()))
@@ -215,7 +211,7 @@ mod if_alloc {
         }
     }
 
-    impl<S: ?Sized + Sink<Item> + Unpin, Item> Sink<Item> for ::alloc::boxed::Box<S> {
+    impl<S: ?Sized + Sink<Item> + Unpin, Item> Sink<Item> for alloc::boxed::Box<S> {
         type SinkError = S::SinkError;
 
         fn poll_ready(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), Self::SinkError>> {
@@ -235,6 +231,3 @@ mod if_alloc {
         }
     }
 }
-
-#[cfg(feature = "alloc")]
-pub use self::if_alloc::*;

futures-util/src/sink/drain.rs

@@ -1,7 +1,7 @@
-use core::fmt;
 use core::marker::PhantomData;
 use core::pin::Pin;
 use futures_core::task::{Context, Poll};
+use futures_core::never::Never;
 use futures_sink::Sink;
 
 /// Sink for the [`drain`] function.
@@ -11,11 +11,6 @@ pub struct Drain<T> {
     marker: PhantomData<T>,
 }
 
-/// The error type for the [`Drain`] sink.
-#[derive(Debug)]
-pub enum DrainError {
-}
-
 /// Create a sink that will just discard all items given to it.
 ///
 /// Similar to [`io::Sink`](::std::io::Sink).
@@ -29,14 +24,14 @@ pub enum DrainError {
 ///
 /// let mut drain = sink::drain();
 /// drain.send(5).await?;
-/// # Ok::<(), futures::sink::DrainError>(()) }).unwrap();
+/// # Ok::<(), futures::never::Never>(()) }).unwrap();
 /// ```
 pub fn drain<T>() -> Drain<T> {
     Drain { marker: PhantomData }
 }
 
 impl<T> Sink<T> for Drain<T> {
-    type SinkError = DrainError;
+    type SinkError = Never;
 
     fn poll_ready(
         self: Pin<&mut Self>,
@@ -66,21 +61,3 @@ impl<T> Sink<T> for Drain<T> {
         Poll::Ready(Ok(()))
     }
 }
-
-impl fmt::Display for DrainError {
-    fn fmt(&self, _: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match *self {
-        }
-    }
-}
-
-#[cfg(feature = "std")]
-impl std::error::Error for DrainError {}
-
-impl DrainError {
-    /// Convert this drain error into any type
-    pub fn into_any<T>(self) -> T {
-        match self {
-        }
-    }
-}

futures-util/src/sink/mod.rs

@@ -15,7 +15,7 @@ mod close;
 pub use self::close::Close;
 
 mod drain;
-pub use self::drain::{drain, Drain, DrainError};
+pub use self::drain::{drain, Drain};
 
 mod fanout;
 pub use self::fanout::Fanout;

futures/src/lib.rs

@@ -66,6 +66,8 @@ compile_error!("The `never-type` feature requires the `nightly` feature as an ex
 
 #[doc(hidden)] pub use futures_core::task::Poll;
 
+#[doc(hidden)] pub use futures_core::never::Never;
+
 // Macro reexports
 pub use futures_core::ready; // Readiness propagation
 pub use futures_util::pin_mut;
@@ -369,7 +371,7 @@ pub mod sink {
 
     pub use futures_util::sink::{
         Close, Flush, Send, SendAll, SinkErrInto, SinkMapErr, With,
-        SinkExt, Fanout, Drain, DrainError, drain,
+        SinkExt, Fanout, Drain, drain,
         WithFlatMap,
     };
 
@@ -504,6 +506,14 @@ pub mod task {
     pub use futures_util::task::AtomicWaker;
 }
 
+pub mod never {
+    //! This module contains the `Never` type.
+    //!
+    //! Values of this type can never be created and will never exist.
+
+    pub use futures_core::never::Never;
+}
+
 // `select!` re-export --------------------------------------
 
 #[cfg(feature = "async-await")]