This might be better maybe dunno hopefully

src/empty.rs

@@ -1,7 +1,6 @@
 use core::marker;
 
 use {Future, Poll};
-use stream::Stream;
 
 /// A future which is never resolved.
 ///
@@ -28,15 +27,3 @@ impl<T, E> Future for Empty<T, E> {
         Poll::NotReady
     }
 }
-
-impl<T, E> Stream for Empty<T, E>
-    where T: Send + 'static,
-          E: Send + 'static
-{
-    type Item = T;
-    type Error = E;
-
-    fn poll(&mut self) -> Poll<Option<Self::Item>, Self::Error> {
-        Poll::Ok(None)
-    }
-}

src/stream/empty.rs

@@ -0,0 +1,33 @@
+use core::marker;
+
+use stream::Stream;
+use Poll;
+
+/// A stream which is never resolved.
+///
+/// This stream can be created with the `stream::empty` function.
+pub struct Empty<T, E> {
+    _data: marker::PhantomData<(T, E)>,
+}
+
+/// Creates a stream which never resolves, representing a computation that never
+/// finishes.
+///
+/// The returned stream will never resolve with a value but is still
+/// susceptible to cancellation. That is, if a callback is scheduled on the
+/// returned stream, it is only run once the stream is dropped (canceled).
+pub fn empty<T, E>() -> Empty<T, E> {
+    Empty { _data: marker::PhantomData }
+}
+
+impl<T, E> Stream for Empty<T, E>
+    where T: Send + 'static,
+          E: Send + 'static
+{
+    type Item = T;
+    type Error = E;
+
+    fn poll(&mut self) -> Poll<Option<Self::Item>, Self::Error> {
+        Poll::Ok(None)
+    }
+}

src/stream/mod.rs

@@ -17,6 +17,7 @@ mod iter;
 pub use self::iter::{iter, IterStream};
 
 mod and_then;
+mod empty;
 mod filter;
 mod filter_map;
 mod flatten;
@@ -35,6 +36,7 @@ mod take;
 mod then;
 mod zip;
 pub use self::and_then::AndThen;
+pub use self::empty::{Empty, empty};
 pub use self::filter::Filter;
 pub use self::filter_map::FilterMap;
 pub use self::flatten::Flatten;