Fix small typos

CHANGELOG.md

@@ -45,7 +45,7 @@ This is a relatively large release of the `futures` crate, although much of it
 is from reworking internals rather than new APIs. The banner feature of this
 release is that the `futures::{task, executor}` modules are now available in
 `no_std` contexts! A large refactoring of the task system was performed in
-PR #436 to accomodate custom memory allocation schemes and otherwise remove
+PR #436 to accommodate custom memory allocation schemes and otherwise remove
 all dependencies on `std` for the task module. More details about this change
 can be found on the PR itself.
 

futures-cpupool/src/lib.rs

@@ -204,7 +204,7 @@ impl CpuPool {
     {
         let (tx, rx) = channel();
         let keep_running_flag = Arc::new(AtomicBool::new(false));
-        // AssertUnwindSafe is used here becuase `Send + 'static` is basically
+        // AssertUnwindSafe is used here because `Send + 'static` is basically
         // an alias for an implementation of the `UnwindSafe` trait but we can't
         // express that in the standard library right now.
         let sender = MySender {

src/stream/futures_unordered.rs

@@ -28,7 +28,7 @@ use task_impl::{self, AtomicTask};
 /// Calling `poll` in this state will result in `Ok(Async::Ready(None))` to be
 /// returned. Futures are submitted to the set using `push`; however, the
 /// future will **not** be polled at this point. `FuturesUnordered` will only
-/// poll managged futures when `FuturesUnordered::poll` is called. As such, it
+/// poll managed futures when `FuturesUnordered::poll` is called. As such, it
 /// is important to call `poll` after pushing new futures.
 ///
 /// If `FuturesUnordered::poll` returns `Ok(Async::Ready(None))` this means that
@@ -90,7 +90,7 @@ pub fn futures_unordered<I>(futures: I) -> FuturesUnordered<<I::Item as IntoFutu
 // `FuturesUnordered`. When a notification is received, the node is scheduled
 // for polling by being inserted into the concurrent linked list.
 //
-// Each node uses an `AtomicUisze` to track it's state. The node state is the
+// Each node uses an `AtomicUsize` to track it's state. The node state is the
 // reference count (the number of outstanding handles to the node) as well as a
 // flag tracking if the node is currently inserted in the atomic queue. When the
 // future is notified, it will only insert itself into the linked list if it

src/stream/iter.rs

@@ -1,4 +1,4 @@
-#![deprecated(note = "implemention moved to `iter_ok` and `iter_result`")]
+#![deprecated(note = "implementation moved to `iter_ok` and `iter_result`")]
 #![allow(deprecated)]
 
 use Poll;

src/sync/mpsc/queue.rs

@@ -114,7 +114,7 @@ impl<T> Queue<T> {
     /// return `Option<T>`. It is possible for this queue to be in an
     /// inconsistent state where many pushes have succeeded and completely
     /// finished, but pops cannot return `Some(t)`. This inconsistent state
-    /// happens when a pusher is pre-empted at an inopportune moment.
+    /// happens when a pusher is preempted at an inopportune moment.
     ///
     /// This inconsistent state means that this queue does indeed have data, but
     /// it does not currently have access to it at this time.

src/sync/oneshot.rs

@@ -35,7 +35,7 @@ pub struct Sender<T> {
 #[derive(Debug)]
 struct Inner<T> {
     /// Indicates whether this oneshot is complete yet. This is filled in both
-    /// by `Sender::drop` and by `Receiver::drop`, and both sides iterperet it
+    /// by `Sender::drop` and by `Receiver::drop`, and both sides interpret it
     /// appropriately.
     ///
     /// For `Receiver`, if this is `true`, then it's guaranteed that `data` is

src/task_impl/std/mod.rs

@@ -588,7 +588,7 @@ impl fmt::Debug for UnparkEvent {
 /// A concurrent set which allows for the insertion of `usize` values.
 ///
 /// `EventSet`s are used to communicate precise information about the event(s)
-/// that trigged a task notification. See `task::with_unpark_event` for details.
+/// that triggered a task notification. See `task::with_unpark_event` for details.
 pub trait EventSet: Send + Sync + 'static {
     /// Insert the given ID into the set
     fn insert(&self, id: usize);

src/task_impl/std/unpark_mutex.rs

@@ -16,7 +16,7 @@ pub struct UnparkMutex<D> {
 }
 
 // `UnparkMutex<D>` functions in many ways like a `Mutex<D>`, except that on
-// acquisition failure, the current lockholder performs the desired work --
+// acquisition failure, the current lock holder performs the desired work --
 // re-polling.
 //
 // As such, these impls mirror those for `Mutex<D>`. In particular, a reference

tests/mpsc.rs

@@ -358,7 +358,7 @@ fn stress_close_receiver() {
 /// Tests that after `poll_ready` indicates capacity a channel can always send without waiting.
 #[test]
 fn stress_poll_ready() {
-    // A task which checks channel capcity using poll_ready, and pushes items onto the channel when
+    // A task which checks channel capacity using poll_ready, and pushes items onto the channel when
     // ready.
     struct SenderTask {
         sender: mpsc::Sender<u32>,

tests/sink.rs

@@ -232,7 +232,7 @@ impl<T> ManualFlush<T> {
 
 #[test]
 // test that the `with` sink doesn't require the underlying sink to flush,
-// but doesn't claim to be flushed until the underlyig sink is
+// but doesn't claim to be flushed until the underlying sink is
 fn with_flush_propagate() {
     let mut sink = ManualFlush::new().with(|x| -> Result<Option<i32>, ()> { Ok(x) });
     assert_eq!(sink.start_send(Some(0)).unwrap(), AsyncSink::Ready);

tests/slot.rs

@@ -171,7 +171,7 @@ fn stress_shared_bounded_hard() {
     t.join().ok().unwrap();
 }
 
-/// Stress test that receiver properly receivesl last message
+/// Stress test that receiver properly receives last message
 /// after sender dropped.
 #[test]
 fn stress_drop_sender() {

tests/support/local_executor.rs

@@ -95,7 +95,7 @@ impl Core {
     /// "Turns" this event loop one tick.
     ///
     /// This'll block the current thread until something happens, and once an
-    /// event happens this will acto on that event.
+    /// event happens this will act on that event.
     ///
     /// # Return value
     ///