Add docs

Author: rousan

src/lib.rs

@@ -1,3 +1,27 @@
+//! Creates an asynchronous piped reader and writer pair using `tokio.rs`.
+//!
+//! # Examples
+//!
+//! ```
+//! # async fn run() {
+//! use async_pipe;
+//! use tokio::prelude::*;
+//!
+//! let (mut w, mut r) = async_pipe::pipe();
+//!  
+//! tokio::spawn(async move {
+//!     w.write_all(b"hello world").await.unwrap();
+//! });
+//!  
+//! let mut v = Vec::new();
+//! r.read_to_end(&mut v).await.unwrap();
+//!
+//! println!("Received: {:?}", String::from_utf8(v));
+//! # }
+//!
+//! tokio::runtime::Runtime::new().unwrap().block_on(run());
+//! ```
+
 use state::State;
 use std::sync::{Arc, Mutex};
 
@@ -8,6 +32,7 @@ mod reader;
 mod state;
 mod writer;
 
+/// Creates a piped pair of an [`AsyncWrite`](https://docs.rs/tokio/0.2.16/tokio/io/trait.AsyncWrite.html) and an [`AsyncRead`](https://docs.rs/tokio/0.2.15/tokio/io/trait.AsyncRead.html).
 pub fn pipe() -> (PipeWriter, PipeReader) {
     let shared_state = Arc::new(Mutex::new(State {
         reader_waker: None,

src/reader.rs

@@ -5,11 +5,13 @@ use std::sync::{Arc, Mutex};
 use std::task::{Context, Poll};
 use tokio::io::{self, AsyncRead};
 
+/// The read half of the pipe which implements [`AsyncRead`](https://docs.rs/tokio/0.2.15/tokio/io/trait.AsyncRead.html).
 pub struct PipeReader {
     pub(crate) state: Arc<Mutex<State>>,
 }
 
 impl PipeReader {
+    /// Closes the pipe, any further read will return EOF and any further write will raise an error.
     pub fn close(&self) -> io::Result<()> {
         match self.state.lock() {
             Ok(mut state) => {

src/writer.rs

@@ -5,11 +5,13 @@ use std::sync::{Arc, Mutex};
 use std::task::{Context, Poll};
 use tokio::io::{self, AsyncWrite};
 
+/// The write half of the pipe which implements [`AsyncWrite`](https://docs.rs/tokio/0.2.16/tokio/io/trait.AsyncWrite.html).
 pub struct PipeWriter {
     pub(crate) state: Arc<Mutex<State>>,
 }
 
 impl PipeWriter {
+    /// Closes the pipe, any further read will return EOF and any further write will raise an error.
     pub fn close(&self) -> io::Result<()> {
         match self.state.lock() {
             Ok(mut state) => {