Re-export IO traits from futures

.travis.yml

@@ -63,5 +63,6 @@ matrix:
         - mdbook test -L ./target/debug/deps docs
 
 script:
+  - cargo check --all --benches --bins --examples --tests
   - cargo check --features unstable --all --benches --bins --examples --tests
   - cargo test --all --doc --features unstable

docs/src/concepts/futures.md

@@ -51,9 +51,9 @@ Remember the talk about "deferred computation" in the intro? That's all it is. I
 Let's have a look at a simple function, specifically the return value:
 
 ```rust,edition2018
-# use std::{fs::File, io::{self, Read}};
+# use std::{fs::File, io, io::prelude::*};
 #
-fn read_file(path: &str) -> Result<String, io::Error> {
+fn read_file(path: &str) -> io::Result<String> {
     let mut file = File::open(path)?;
     let mut contents = String::new();
     file.read_to_string(&mut contents)?;
@@ -69,7 +69,7 @@ But we wanted to abstract over *computation* and let someone else choose how to
 ```rust,edition2018
 # use std::{fs::File, io::{self, Read}};
 #
-fn read_file(path: &str) -> Result<String, io::Error> {
+fn read_file(path: &str) -> io::Result<String> {
     let mut file = File::open(path)?;
     let mut contents = String::new();
     file.read_to_string(&mut contents)?;
@@ -112,10 +112,9 @@ While the `Future` trait has existed in Rust for a while, it was inconvenient to
 
 ```rust,edition2018
 # extern crate async_std;
-# use async_std::{fs::File, io::Read};
-# use std::io;
+# use async_std::{fs::File, io, io::prelude::*};
 #
-async fn read_file(path: &str) -> Result<String, io::Error> {
+async fn read_file(path: &str) -> io::Result<String> {
     let mut file = File::open(path).await?;
     let mut contents = String::new();
     file.read_to_string(&mut contents).await?;
@@ -125,7 +124,7 @@ async fn read_file(path: &str) -> Result<String, io::Error> {
 
 Amazingly little difference, right? All we did is label the function `async` and insert 2 special commands: `.await`.
 
-This `async` function sets up a deferred computation. When this function is called, it will produce a `Future<Output=Result<String, io::Error>>` instead of immediately returning a `Result<String, io::Error>`. (Or, more precisely, generate a type for you that implements `Future<Output=Result<String, io::Error>>`.)
+This `async` function sets up a deferred computation. When this function is called, it will produce a `Future<Output = io::Result<String>>` instead of immediately returning a `io::Result<String>`. (Or, more precisely, generate a type for you that implements `Future<Output = io::Result<String>>`.)
 
 ## What does `.await` do?
 

docs/src/concepts/tasks.md

@@ -6,9 +6,9 @@ In `async-std`, the [`tasks`][tasks] module is responsible for this. The simples
 
 ```rust,edition2018
 # extern crate async_std;
-use async_std::{io, task, fs::File, io::Read};
+use async_std::{fs::File, io, prelude::*, task};
 
-async fn read_file(path: &str) -> Result<String, io::Error> {
+async fn read_file(path: &str) -> io::Result<String> {
     let mut file = File::open(path).await?;
     let mut contents = String::new();
     file.read_to_string(&mut contents).await?;
@@ -33,10 +33,9 @@ This asks the runtime baked into `async_std` to execute the code that reads a fi
 
 ```rust,edition2018
 # extern crate async_std;
-# use async_std::{fs::File, io::Read, task};
-# use std::io;
+# use async_std::{fs::File, io, prelude::*, task};
 #
-# async fn read_file(path: &str) -> Result<String, io::Error> {
+# async fn read_file(path: &str) -> io::Result<String> {
 #     let mut file = File::open(path).await?;
 #     let mut contents = String::new();
 #     file.read_to_string(&mut contents).await?;

src/fs/file.rs

@@ -9,11 +9,11 @@ use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::{Arc, Mutex};
 
 use cfg_if::cfg_if;
-use futures_io::{AsyncRead, AsyncSeek, AsyncWrite, Initializer};
 
 use crate::fs::{Metadata, Permissions};
 use crate::future;
-use crate::io::{self, SeekFrom, Write};
+use crate::io::{self, Read, Seek, SeekFrom, Write};
+use crate::prelude::*;
 use crate::task::{self, blocking, Context, Poll, Waker};
 
 /// An open file on the filesystem.
@@ -302,22 +302,17 @@ impl fmt::Debug for File {
     }
 }
 
-impl AsyncRead for File {
+impl Read for File {
     fn poll_read(
         self: Pin<&mut Self>,
         cx: &mut Context<'_>,
         buf: &mut [u8],
     ) -> Poll<io::Result<usize>> {
         Pin::new(&mut &*self).poll_read(cx, buf)
     }
-
-    #[inline]
-    unsafe fn initializer(&self) -> Initializer {
-        Initializer::nop()
-    }
 }
 
-impl AsyncRead for &File {
+impl Read for &File {
     fn poll_read(
         self: Pin<&mut Self>,
         cx: &mut Context<'_>,
@@ -326,14 +321,9 @@ impl AsyncRead for &File {
         let state = futures_core::ready!(self.lock.poll_lock(cx));
         state.poll_read(cx, buf)
     }
-
-    #[inline]
-    unsafe fn initializer(&self) -> Initializer {
-        Initializer::nop()
-    }
 }
 
-impl AsyncWrite for File {
+impl Write for File {
     fn poll_write(
         self: Pin<&mut Self>,
         cx: &mut Context<'_>,
@@ -351,7 +341,7 @@ impl AsyncWrite for File {
     }
 }
 
-impl AsyncWrite for &File {
+impl Write for &File {
     fn poll_write(
         self: Pin<&mut Self>,
         cx: &mut Context<'_>,
@@ -372,7 +362,7 @@ impl AsyncWrite for &File {
     }
 }
 
-impl AsyncSeek for File {
+impl Seek for File {
     fn poll_seek(
         self: Pin<&mut Self>,
         cx: &mut Context<'_>,
@@ -382,7 +372,7 @@ impl AsyncSeek for File {
     }
 }
 
-impl AsyncSeek for &File {
+impl Seek for &File {
     fn poll_seek(
         self: Pin<&mut Self>,
         cx: &mut Context<'_>,

src/io/buf_read/lines.rs

@@ -2,10 +2,8 @@ use std::mem;
 use std::pin::Pin;
 use std::str;
 
-use futures_io::AsyncBufRead;
-
 use super::read_until_internal;
-use crate::io;
+use crate::io::{self, BufRead};
 use crate::task::{Context, Poll};
 
 /// A stream of lines in a byte stream.
@@ -25,7 +23,7 @@ pub struct Lines<R> {
     pub(crate) read: usize,
 }
 
-impl<R: AsyncBufRead> futures_core::stream::Stream for Lines<R> {
+impl<R: BufRead> futures_core::stream::Stream for Lines<R> {
     type Item = io::Result<String>;
 
     fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
@@ -50,7 +48,7 @@ impl<R: AsyncBufRead> futures_core::stream::Stream for Lines<R> {
     }
 }
 
-pub fn read_line_internal<R: AsyncBufRead + ?Sized>(
+pub fn read_line_internal<R: BufRead + ?Sized>(
     reader: Pin<&mut R>,
     cx: &mut Context<'_>,
     buf: &mut String,