Merge pull request rust-lang#142 from apasel422/typos

Fix typos

README.md

@@ -1,6 +1,6 @@
 # futures-rs
 
-This library is an implementation of **zero cost futures** in Rust.
+This library is an implementation of **zero-cost futures** in Rust.
 
 [![Build Status](https://travis-ci.org/alexcrichton/futures-rs.svg?branch=master)](https://travis-ci.org/alexcrichton/futures-rs)
 [![Build status](https://ci.appveyor.com/api/projects/status/yl5w3ittk4kggfsh?svg=true)](https://ci.appveyor.com/project/alexcrichton/futures-rs)
@@ -41,14 +41,14 @@ all, check out the [tutorial].
                     on top of `tokio-core`
 * [`tokio-socks5`] - an implementation of an efficient SOCKSv5 proxy server
                      showcasing `futures` and `tokio-core`
-* [`tokio-tls`] - TLS/SSL streams built on futures, implementing both client and
-                  server side connections, with support for the native system
+* [`tokio-tls`] - TLS/SSL streams built on futures, implementing both client- and
+                  server-side connections, with support for the native system
                   library on all platforms
 * [`tokio-curl`] - an asynchronous HTTP client backed by libcurl exposed
                    through futures
 * [`tokio-uds`] - bindings for Unix domain sockets and futures
 * [`tokio-minihttp`] - a simple HTTP server with some "hello world" examples
-                       that show the screaming fast performance of the futures
+                       that show the screaming-fast performance of the futures
                        and mio stack
 
 [`futures`]: http://alexcrichton.com/futures-rs/futures
@@ -79,9 +79,9 @@ they can all compose with one another.
 ## The `Future` trait
 
 At the heart of this crate is [the `Future` trait][Future], which in true Rust
-style, is an interface for **zero allocation futures**. Like iterators in Rust,
+style, is an interface for **zero-allocation futures**. Like iterators in Rust,
 there are a wide variety of helpful combinators associated with this trait which
-are also zero allocation and serve as a succinct and powerful way to compose
+are also zero-allocation and serve as a succinct and powerful way to compose
 computations on futures.
 
 [Future]: http://alexcrichton.com/futures-rs/futures/trait.Future.html

TUTORIAL.md

@@ -391,7 +391,7 @@ pub enum Async<T> {
 
 Through this `enum` futures can communicate whether the future's value is ready
 to go. If an error ever happens, then `Err` is returned immediately. Otherwise,
-the [`Async`] type indicates whether the futures is ready with a successful
+the [`Async`] type indicates whether the future is ready with a successful
 payload or not ready.
 
 The [`Future`] trait, like `Iterator`, doesn't specify what happens after
@@ -430,7 +430,7 @@ convert it to a future of `u32`? For this sort of composition, the `Future`
 trait also provides a large number of **combinators** which can be seen on the
 [`Future`] trait itself.
 
-These combinators similar to the [`Iterator`] combinators in that they all
+These combinators are similar to the [`Iterator`] combinators in that they all
 consume the receiving future and return a new future. For example, we could
 have:
 
@@ -470,7 +470,7 @@ The combinators on futures allow expressing concepts like:
 
 Usage of the combinators should feel very similar to the [`Iterator`] trait in
 Rust or [futures in Scala][scala-futures]. Most composition of futures ends up
-being done through these combinators. All combinators are zero-cost, that means
+being done through these combinators. All combinators are zero-cost, meaning that
 no memory is allocated internally and the implementation will optimize to what
 you would have otherwise written by hand.
 
@@ -481,7 +481,7 @@ you would have otherwise written by hand.
 
 [Back to top][top]
 
-Previously, we've taken a long look at the [`Future`] trait which is useful if
+Previously, we've taken a long look at the [`Future`] trait, which is useful if
 we're only producing one value over time. But sometimes computations are best
 modeled as a *stream* of values being produced over time. For example, a TCP
 listener produces a number of TCP socket connections over its lifetime.
@@ -700,7 +700,7 @@ together.  But where do all these futures originally come from? Let's take a
 look at a few concrete implementations of futures and streams.
 
 First, any value already available is trivially a future that is immediately
-ready. For this, the [`done`], [`failed`], [`finished`] functions suffice. The
+ready. For this, the [`done`], [`failed`], and [`finished`] functions suffice. The
 [`done`] variant takes a `Result<T, E>` and returns a `Future<Item=T, Error=E>`.
 The [`failed`] and [`finished`] variants then specify either `T` or `E` and
 leave the other associated type as a wildcard.

src/lib.rs

@@ -2,7 +2,7 @@
 //!
 //! This library is an implementation of futures in Rust which aims to provide
 //! a robust implementation of handling asynchronous computations, ergonomic
-//! composition and usage, and zero cost abstractions over what would otherwise
+//! composition and usage, and zero-cost abstractions over what would otherwise
 //! be written by hand.
 //!
 //! Futures are a concept for an object which is a proxy for another value that