Docs and grammar
diff --git a/CHANGELOG.md b/CHANGELOG.md
index ed018ac..e95291e 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,7 @@
+# Version 2.1.0
+
+- Stronger gua
+
# Version 2.0.0
- Return `true` in `Task::run()`.
@@ -26,7 +30,7 @@
# Version 1.1.0
-- If a task is dropped or cancelled outside the `run` method, it gets re-scheduled.
+- If a task is dropped or canceled outside the `run` method, it gets re-scheduled.
- Add `spawn_local` constructor.
# Version 1.0.0
diff --git a/Cargo.toml b/Cargo.toml
index e9136d3..f8b0f9f 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,11 +1,11 @@
[package]
name = "async-task"
-version = "2.0.0"
+version = "2.1.0"
authors = ["Stjepan Glavina <stjepang@gmail.com>"]
edition = "2018"
license = "Apache-2.0/MIT"
-repository = "https://github.com/async-rs/async-task"
-homepage = "https://github.com/async-rs/async-task"
+repository = "https://github.com/stjepang/async-task"
+homepage = "https://github.com/stjepang/async-task"
documentation = "https://docs.rs/async-task"
description = "Task abstraction for building executors"
keywords = ["futures", "task", "executor", "spawn"]
diff --git a/examples/panic-result.rs b/examples/panic-result.rs
index 6308240..b93f060 100644
--- a/examples/panic-result.rs
+++ b/examples/panic-result.rs
@@ -56,7 +56,7 @@
// Block on the future and report its result.
match executor::block_on(handle) {
- None => println!("The task was cancelled."),
+ None => println!("The task was canceled."),
Some(Ok(val)) => println!("The task completed with {:?}", val),
Some(Err(_)) => println!("The task has panicked"),
}
@@ -68,7 +68,7 @@
// Block on the future and report its result.
match executor::block_on(handle) {
- None => println!("The task was cancelled."),
+ None => println!("The task was canceled."),
Some(Ok(val)) => println!("The task completed with {:?}", val),
Some(Err(_)) => println!("The task has panicked"),
}
diff --git a/src/header.rs b/src/header.rs
index 5d808c7..a559e48 100644
--- a/src/header.rs
+++ b/src/header.rs
@@ -38,7 +38,7 @@
let mut state = self.state.load(Ordering::Acquire);
loop {
- // If the task has been completed or closed, it can't be cancelled.
+ // If the task has been completed or closed, it can't be canceled.
if state & (COMPLETED | CLOSED) != 0 {
break;
}
diff --git a/src/join_handle.rs b/src/join_handle.rs
index 10a189e..edf9fcd 100644
--- a/src/join_handle.rs
+++ b/src/join_handle.rs
@@ -13,7 +13,7 @@
///
/// This type is a future that resolves to an `Option<R>` where:
///
-/// * `None` indicates the task has panicked or was cancelled.
+/// * `None` indicates the task has panicked or was canceled.
/// * `Some(result)` indicates the task has completed with `result` of type `R`.
pub struct JoinHandle<R, T> {
/// A raw task pointer.
@@ -33,7 +33,7 @@
///
/// If the task has already completed, calling this method will have no effect.
///
- /// When a task is cancelled, its future will not be polled again.
+ /// When a task is canceled, its future will not be polled again.
pub fn cancel(&self) {
let ptr = self.raw_task.as_ptr();
let header = ptr as *const Header;
@@ -42,7 +42,7 @@
let mut state = (*header).state.load(Ordering::Acquire);
loop {
- // If the task has been completed or closed, it can't be cancelled.
+ // If the task has been completed or closed, it can't be canceled.
if state & (COMPLETED | CLOSED) != 0 {
break;
}
diff --git a/src/lib.rs b/src/lib.rs
index c1391a2..c4dea41 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -73,15 +73,18 @@
//! it's waiting for another future and needs to go to sleep. When woken up, its schedule function
//! will be invoked, pushing it back into the queue so that it can be run again.
//!
-//! # Cancellation
+//! # Cancelation
//!
-//! Both [`Task`] and [`JoinHandle`] have methods that cancel the task. When cancelled, the task's
+//! Both [`Task`] and [`JoinHandle`] have methods that cancel the task. When canceled, the task's
//! future will not be polled again and will get dropped instead.
//!
-//! If cancelled by the [`Task`] instance, the task is destroyed immediately. If cancelled by the
+//! If canceled by the [`Task`] instance, the task is destroyed immediately. If canceled by the
//! [`JoinHandle`] instance, it will be scheduled one more time and the next attempt to run it will
//! simply destroy it.
//!
+//! The `JoinHandle` future will then evaluate to `None`, but only after the task's future is
+//! dropped.
+//!
//! # Performance
//!
//! Task construction incurs a single allocation that holds its state, the schedule function, and
diff --git a/src/state.rs b/src/state.rs
index 167a371..58559ac 100644
--- a/src/state.rs
+++ b/src/state.rs
@@ -26,10 +26,10 @@
/// Set if the task is closed.
///
-/// If a task is closed, that means it's either cancelled or its output has been consumed by the
+/// If a task is closed, that means it's either canceled or its output has been consumed by the
/// `JoinHandle`. A task becomes closed when:
///
-/// 1. It gets cancelled by `Task::cancel()`, `Task::drop()`, or `JoinHandle::cancel()`.
+/// 1. It gets canceled by `Task::cancel()`, `Task::drop()`, or `JoinHandle::cancel()`.
/// 2. Its output gets awaited by the `JoinHandle`.
/// 3. It panics while polling the future.
/// 4. It is completed and the `JoinHandle` gets dropped.
diff --git a/src/task.rs b/src/task.rs
index d4da255..a300d63 100644
--- a/src/task.rs
+++ b/src/task.rs
@@ -180,8 +180,8 @@
/// function. In most executors, scheduling simply pushes the [`Task`] reference into a queue of
/// runnable tasks.
///
-/// If the [`Task`] reference is dropped without getting run, the task is automatically cancelled.
-/// When cancelled, the task won't be scheduled again even if a [`Waker`] wakes it. It is possible
+/// If the [`Task`] reference is dropped without getting run, the task is automatically canceled.
+/// When canceled, the task won't be scheduled again even if a [`Waker`] wakes it. It is possible
/// for the [`JoinHandle`] to cancel while the [`Task`] reference exists, in which case an attempt
/// to run the task won't do anything.
///
@@ -206,7 +206,7 @@
/// This is a convenience method that simply reschedules the task by passing it to its schedule
/// function.
///
- /// If the task is cancelled, this method won't do anything.
+ /// If the task is canceled, this method won't do anything.
pub fn schedule(self) {
let ptr = self.raw_task.as_ptr();
let header = ptr as *const Header;
@@ -226,12 +226,12 @@
/// available to the [`JoinHandle`]. And if the future is still pending, the task will have to
/// be woken up in order to be rescheduled and run again.
///
- /// If the task was cancelled by a [`JoinHandle`] before it gets run, then this method won't do
+ /// If the task was canceled by a [`JoinHandle`] before it gets run, then this method won't do
/// anything.
///
/// It is possible that polling the future panics, in which case the panic will be propagated
/// into the caller. It is advised that invocations of this method are wrapped inside
- /// [`catch_unwind`]. If a panic occurs, the task is automatically cancelled.
+ /// [`catch_unwind`]. If a panic occurs, the task is automatically canceled.
///
/// [`JoinHandle`]: struct.JoinHandle.html
/// [`catch_unwind`]: https://doc.rust-lang.org/std/panic/fn.catch_unwind.html
@@ -245,7 +245,7 @@
/// Cancels the task.
///
- /// When cancelled, the task won't be scheduled again even if a [`Waker`] wakes it. An attempt
+ /// When canceled, the task won't be scheduled again even if a [`Waker`] wakes it. An attempt
/// to run it won't do anything.
///
/// [`Waker`]: https://doc.rust-lang.org/std/task/struct.Waker.html
diff --git a/tests/waker_ready.rs b/tests/waker_ready.rs
index a2223c6..7d1d59e 100644
--- a/tests/waker_ready.rs
+++ b/tests/waker_ready.rs
@@ -259,7 +259,7 @@
}
#[test]
-fn wake_cancelled() {
+fn wake_canceled() {
future!(f, waker, POLL, DROP_F);
schedule!(s, chan, SCHEDULE, DROP_S);
task!(task, _, f, s, DROP_T);
