Remove most glob imports

Author: MajorBreakfast

futures-channel/benches/sync_mpsc.rs

@@ -3,8 +3,9 @@
 use futures::ready;
 use futures::channel::mpsc::{self, Sender, UnboundedSender};
 use futures::executor::LocalPool;
-use futures::prelude::*;
-use futures::task::{self, Wake, LocalWaker};
+use futures::stream::{Stream, StreamExt};
+use futures::sink::Sink;
+use futures::task::{self, Poll, Wake, LocalWaker};
 use std::mem::PinMut;
 use std::sync::Arc;
 use test::Bencher;

futures-channel/src/oneshot.rs

@@ -84,24 +84,22 @@ struct Inner<T> {
 ///
 /// ```
 /// use futures::channel::oneshot;
-/// use futures::prelude::*;
+/// use futures::future::FutureExt;
 /// use std::thread;
 ///
-/// fn main() {
-///     let (sender, receiver) = oneshot::channel::<i32>();
+/// let (sender, receiver) = oneshot::channel::<i32>();
 ///
 /// # let t =
-///     thread::spawn(|| {
-///         let future = receiver.map(|i| {
-///             println!("got: {:?}", i);
-///         });
-///         // ...
-/// # return future;
+/// thread::spawn(|| {
+///     let future = receiver.map(|i| {
+///         println!("got: {:?}", i);
 ///     });
+///     // ...
+/// # return future;
+/// });
 ///
-///     sender.send(3).unwrap();
+/// sender.send(3).unwrap();
 /// # futures::executor::block_on(t.join().unwrap());
-/// }
 /// ```
 pub fn channel<T>() -> (Sender<T>, Receiver<T>) {
     let inner = Arc::new(Inner::new());

futures-channel/tests/channel.rs

@@ -3,8 +3,9 @@
 use futures::channel::mpsc;
 use futures::executor::block_on;
 use futures::future::poll_fn;
-use futures::prelude::*;
-use std::sync::atomic::*;
+use futures::stream::StreamExt;
+use futures::sink::SinkExt;
+use std::sync::atomic::{AtomicUsize, ATOMIC_USIZE_INIT, Ordering};
 use std::thread;
 
 #[test]

futures-channel/tests/mpsc-close.rs

@@ -1,11 +1,12 @@
-use futures::channel::mpsc::*;
+use futures::channel::mpsc;
 use futures::executor::block_on;
-use futures::prelude::*;
+use futures::sink::SinkExt;
+use futures::stream::StreamExt;
 use std::thread;
 
 #[test]
 fn smoke() {
-    let (mut sender, receiver) = channel(1);
+    let (mut sender, receiver) = mpsc::channel(1);
 
     let t = thread::spawn(move || {
         while let Ok(()) = block_on(sender.send(42)) {}

futures-channel/tests/mpsc.rs

@@ -1,9 +1,11 @@
 #![feature(futures_api, async_await, await_macro, pin)]
 
-use futures::future::poll_fn;
 use futures::channel::{mpsc, oneshot};
 use futures::executor::{block_on, block_on_stream};
-use futures::prelude::*;
+use futures::future::{FutureExt, poll_fn};
+use futures::stream::{Stream, StreamExt};
+use futures::sink::{Sink, SinkExt};
+use futures::task::Poll;
 use pin_utils::pin_mut;
 use std::sync::{Arc, Mutex};
 use std::sync::atomic::{AtomicUsize, Ordering};

futures-channel/tests/oneshot.rs

@@ -1,17 +1,16 @@
 #![feature(futures_api, arbitrary_self_types, pin)]
 
-use futures::channel::oneshot::*;
+use futures::channel::oneshot::{self, Sender};
 use futures::executor::block_on;
-use futures::future::poll_fn;
-use futures::task;
-use futures::prelude::*;
+use futures::future::{Future, FutureExt, poll_fn};
+use futures::task::{self, Poll};
 use std::mem::PinMut;
 use std::sync::mpsc;
 use std::thread;
 
 #[test]
 fn smoke_poll() {
-    let (mut tx, rx) = channel::<u32>();
+    let (mut tx, rx) = oneshot::channel::<u32>();
     let mut rx = Some(rx);
     let f = poll_fn(|cx| {
         assert!(tx.poll_cancel(cx).is_pending());
@@ -27,7 +26,7 @@ fn smoke_poll() {
 
 #[test]
 fn cancel_notifies() {
-    let (tx, rx) = channel::<u32>();
+    let (tx, rx) = oneshot::channel::<u32>();
 
     let t = thread::spawn(|| {
         block_on(WaitForCancel { tx: tx });
@@ -59,7 +58,7 @@ fn cancel_lots() {
     });
 
     for _ in 0..20000 {
-        let (otx, orx) = channel::<u32>();
+        let (otx, orx) = oneshot::channel::<u32>();
         let (tx2, rx2) = mpsc::channel();
         tx.send((otx, tx2)).unwrap();
         drop(orx);
@@ -72,7 +71,7 @@ fn cancel_lots() {
 
 #[test]
 fn close() {
-    let (mut tx, mut rx) = channel::<u32>();
+    let (mut tx, mut rx) = oneshot::channel::<u32>();
     rx.close();
     block_on(poll_fn(|cx| {
         match rx.poll_unpin(cx) {
@@ -86,7 +85,7 @@ fn close() {
 
 #[test]
 fn close_wakes() {
-    let (tx, mut rx) = channel::<u32>();
+    let (tx, mut rx) = oneshot::channel::<u32>();
     let (tx2, rx2) = mpsc::channel();
     let t = thread::spawn(move || {
         rx.close();
@@ -99,7 +98,7 @@ fn close_wakes() {
 
 #[test]
 fn is_canceled() {
-    let (tx, rx) = channel::<u32>();
+    let (tx, rx) = oneshot::channel::<u32>();
     assert!(!tx.is_canceled());
     drop(rx);
     assert!(tx.is_canceled());
@@ -115,7 +114,7 @@ fn cancel_sends() {
     });
 
     for _ in 0..20000 {
-        let (otx, mut orx) = channel::<u32>();
+        let (otx, mut orx) = oneshot::channel::<u32>();
         tx.send(otx).unwrap();
 
         orx.close();

futures-executor/benches/poll.rs

@@ -1,8 +1,8 @@
 #![feature(test, pin, arbitrary_self_types, futures_api)]
 
 use futures::executor::LocalPool;
-use futures::task::{self, Waker, LocalWaker, Wake, local_waker_from_nonlocal};
-use futures::prelude::*;
+use futures::future::{Future, FutureExt};
+use futures::task::{self, Poll, Waker, LocalWaker, Wake};
 use std::marker::Unpin;
 use std::mem::PinMut;
 use std::sync::Arc;
@@ -15,7 +15,7 @@ fn notify_noop() -> LocalWaker {
         fn wake(_: &Arc<Self>) {}
     }
 
-    local_waker_from_nonlocal(Arc::new(Noop))
+    task::local_waker_from_nonlocal(Arc::new(Noop))
 }
 
 #[bench]

futures-executor/benches/thread_notify.rs

@@ -1,8 +1,8 @@
 #![feature(test, futures_api, pin, arbitrary_self_types)]
 
 use futures::executor::block_on;
-use futures::task::{self, Waker};
-use futures::prelude::*;
+use futures::future::Future;
+use futures::task::{self, Poll, Waker};
 use std::marker::Unpin;
 use std::mem::PinMut;
 use test::Bencher;

futures-executor/src/enter.rs

@@ -25,14 +25,12 @@ pub struct EnterError {
 /// execute a tasks, and drop the returned [`Enter`](Enter) value after
 /// completing task execution:
 ///
-/// ```rust
-/// # use futures::executor::enter;
+/// ```
+/// use futures::executor::enter;
 ///
-/// # fn main() {
 /// let enter = enter().expect("...");
 /// /* run task */
 /// drop(enter);
-/// # }
 /// ```
 ///
 /// Doing so ensures that executors aren't

futures-executor/src/local_pool.rs

@@ -125,7 +125,7 @@ impl LocalPool {
     /// the `LocalPool` by using its executor handle:
     ///
     /// ```
-    /// # #![feature(pin, arbitrary_self_types, futures_api)]
+    /// #![feature(pin, arbitrary_self_types, futures_api)]
     /// use futures::executor::LocalPool;
     /// use futures::future::ready;
     ///

futures-executor/tests/local_pool.rs

@@ -2,9 +2,8 @@
 
 use futures::channel::oneshot;
 use futures::executor::LocalPool;
-use futures::future::lazy;
-use futures::task::{self, Executor};
-use futures::prelude::*;
+use futures::future::{Future, lazy};
+use futures::task::{self, Poll, Executor};
 use std::boxed::PinBox;
 use std::cell::{Cell, RefCell};
 use std::mem::PinMut;

futures-util/benches/futures_unordered.rs

@@ -1,15 +1,13 @@
 #![feature(test, futures_api)]
 
-use futures::prelude::*;
+use futures::channel::oneshot;
+use futures::executor::block_on;
 use futures::future;
-use futures::stream::FuturesUnordered;
-use futures_channel::oneshot;
-use futures_executor::block_on;
-
-use test::Bencher;
-
+use futures::stream::{StreamExt, FuturesUnordered};
+use futures::task::Poll;
 use std::collections::VecDeque;
 use std::thread;
+use test::Bencher;
 
 #[bench]
 fn oneshots(b: &mut Bencher) {

futures-util/benches_disabled/bilock.rs

@@ -2,7 +2,6 @@
 
 #[cfg(feature = "bench")]
 mod bench {
-use futures::prelude::*;
 use futures::task::{self, Wake, Waker};
 use futures::executor::LocalPool;
 use futures_util::lock::BiLock;

futures-util/bilock.rs

@@ -1,4 +1,3 @@
-use futures::prelude::*;
 use futures::task;
 use futures::stream;
 use futures::future;

futures-util/src/future/abortable.rs

@@ -29,17 +29,14 @@ impl<Fut> Abortable<Fut> where Fut: Future {
     ///
     /// Example:
     ///
-    /// ```rust
-    /// use futures::prelude::*;
+    /// ```
     /// use futures::future::{ready, Abortable, AbortHandle, Aborted};
     /// use futures::executor::block_on;
     ///
-    /// # fn main() {
     /// let (abort_handle, abort_registration) = AbortHandle::new_pair();
     /// let future = Abortable::new(ready(2), abort_registration);
     /// abort_handle.abort();
     /// assert_eq!(block_on(future), Err(Aborted));
-    /// # }
     /// ```
     pub fn new(future: Fut, reg: AbortRegistration) -> Self {
         Abortable {
@@ -71,17 +68,14 @@ impl AbortHandle {
     ///
     /// Example:
     ///
-    /// ```rust
-    /// use futures::prelude::*;
+    /// ```
     /// use futures::future::{ready, Abortable, AbortHandle, Aborted};
     /// use futures::executor::block_on;
     ///
-    /// # fn main() {
     /// let (abort_handle, abort_registration) = AbortHandle::new_pair();
     /// let future = Abortable::new(ready(2), abort_registration);
     /// abort_handle.abort();
     /// assert_eq!(block_on(future), Err(Aborted));
-    /// # }
     pub fn new_pair() -> (Self, AbortRegistration) {
         let inner = Arc::new(AbortInner {
             waker: AtomicWaker::new(),

futures-util/src/future/disabled/join_all.rs

@@ -49,11 +49,8 @@ impl<F> fmt::Debug for JoinAll<F>
 /// # Examples
 ///
 /// ```
-/// use futures::prelude::*;
 /// use futures::future::{join_all, ok, err};
 ///
-/// # fn main() {
-/// #
 /// let f = join_all(vec![
 ///     ok::<u32, u32>(1),
 ///     ok::<u32, u32>(2),
@@ -72,7 +69,6 @@ impl<F> fmt::Debug for JoinAll<F>
 ///     assert_eq!(x, Err(2));
 ///     x
 /// });
-/// # }
 /// ```
 pub fn join_all<I>(i: I) -> JoinAll<<I::Item as IntoFuture>::Future>
     where I: IntoIterator,

futures-util/src/future/mod.rs

@@ -176,7 +176,6 @@ pub trait FutureExt: Future {
     /// # Examples
     ///
     /// ```
-    /// use futures::prelude::*;
     /// use futures::future::{self, Either};
     ///
     /// // A poor-man's join implemented on top of select
@@ -195,7 +194,6 @@ pub trait FutureExt: Future {
     ///         }
     ///     }))
     /// }
-    /// # fn main() {}
     /// ```
     fn select<B>(self, other: B) -> Select<Self, B::Future>
         where B: IntoFuture, Self: Sized
@@ -349,9 +347,7 @@ pub trait FutureExt: Future {
     ///
     /// ```
     /// use futures::executor::block_on;
-    /// use futures::future::*;
     ///
-    /// # fn main() {
     /// let x = 6;
     /// let future = if x < 10 {
     ///     ready(true).left_future()
@@ -360,7 +356,6 @@ pub trait FutureExt: Future {
     /// };
     ///
     /// assert_eq!(true, block_on(future));
-    /// # }
     /// ```
     fn left_future<B>(self) -> Either<Self, B>
         where B: Future<Output = Self::Output>,
@@ -379,9 +374,7 @@ pub trait FutureExt: Future {
     ///
     /// ```
     /// use futures::executor::block_on;
-    /// use futures::future::*;
     ///
-    /// # fn main() {
     /// let x = 6;
     /// let future = if x < 10 {
     ///     ready(true).left_future()
@@ -390,7 +383,7 @@ pub trait FutureExt: Future {
     /// };
     ///
     /// assert_eq!(false, block_on(future));
-    /// # }
+    /// ```
     fn right_future<A>(self) -> Either<A, Self>
         where A: Future<Output = Self::Output>,
               Self: Sized,
@@ -558,7 +551,7 @@ pub trait FutureExt: Future {
     ///
     // TODO: minimize and open rust-lang/rust ticket, currently errors:
     //       'assertion failed: !value.has_escaping_regions()'
-    /// ```rust,ignore
+    /// ```ignore
     /// #![feature(async_await, await_macro, futures_api)]
     /// # futures::executor::block_on(async {
     /// use futures::future::{self, FutureExt, Ready};
@@ -613,8 +606,7 @@ pub trait FutureExt: Future {
     /// // synchronous function to better illustrate the cross-thread aspect of
     /// // the `shared` combinator.
     ///
-    /// use futures::prelude::*;
-    /// use futures::future;
+    /// use futures::future::{self, FutureExt};
     /// use futures::executor::block_on;
     /// use std::thread;
     ///