From ab36387c45ea4f5cce719f40e699bf8a31b7b0c5 Mon Sep 17 00:00:00 2001
From: Max Countryman <maxc@me.com>
Date: Sat, 16 Nov 2024 16:09:54 -0800
Subject: [PATCH] fix some typos

---
 src/job.rs    | 8 ++++----
 src/queue.rs  | 4 ++--
 src/task.rs   | 2 +-
 src/worker.rs | 4 ++--
 4 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/src/job.rs b/src/job.rs
index 6f97238..a0d9802 100644
--- a/src/job.rs
+++ b/src/job.rs
@@ -251,7 +251,7 @@
 //! # Atomicity
 //!
 //! Apart from state, context also provides another useful field: a transaction
-//! that's shared wtih the worker.
+//! that's shared with the worker.
 //!
 //! Access to this transaction means we can make updates to the database that
 //! are only visible if the execution itself succeeds and the transaction is
@@ -293,7 +293,7 @@
 //! # Retry policies
 //!
 //! Steps being tasks also have associated retry policies. This policy inherits
-//! the default but can be providied for each step.
+//! the default but can be provided for each step.
 //!
 //! ```rust
 //! use serde::{Deserialize, Serialize};
@@ -487,7 +487,7 @@
 //! # }
 //! ```
 //!
-//! # Runnning jobs
+//! # Running jobs
 //!
 //! Jobs are run via workers and schedulers, where the former processes tasks
 //! and the latter processes schedules for enqueuing tasks. Starting both is
@@ -1415,7 +1415,7 @@ where
         worker.run().await
     }
 
-    /// Contructs a worker which then immediately runs schedule processing.
+    /// Constructs a worker which then immediately runs schedule processing.
     ///
     /// # Errors
     ///
diff --git a/src/queue.rs b/src/queue.rs
index 0f99f53..fb7e301 100644
--- a/src/queue.rs
+++ b/src/queue.rs
@@ -363,7 +363,7 @@ impl<T: Task> Queue<T> {
     /// to the task and returned upon successful enqueue.
     ///
     /// **Note:** If you pass a transactional executor and the transaction is
-    /// rolled back, the returned tasl ID will not correspond to any persisted
+    /// rolled back, the returned task ID will not correspond to any persisted
     /// task.
     ///
     /// # Errors
@@ -569,7 +569,7 @@ impl<T: Task> Queue<T> {
     /// Dequeues the next available task.
     ///
     /// This method uses the `FOR UPDATE SKIP LOCKED` clause to ensure efficient
-    /// retrievial of pending task rows.
+    /// retrieval of pending task rows.
     ///
     /// If an available task is found, it's marked as "in progress".
     ///
diff --git a/src/task.rs b/src/task.rs
index f65ec9c..9451608 100644
--- a/src/task.rs
+++ b/src/task.rs
@@ -575,7 +575,7 @@ pub enum State {
     /// Execute cancelled.
     Cancelled,
 
-    /// Execute completed unsucessfully.
+    /// Execute completed unsuccessfully.
     Failed,
 }
 
diff --git a/src/worker.rs b/src/worker.rs
index abbaffd..fdac392 100644
--- a/src/worker.rs
+++ b/src/worker.rs
@@ -10,7 +10,7 @@
 //!
 //! Also note that workers retry failed tasks in accordance with their
 //! configured retry policies. When a task has remaining retries, it will be
-//! requeued in a "pending" state.
+//! re-enqueued in a "pending" state.
 //!
 //! To ensure that only a single worker can process a task at a time, a
 //! [transaction-level advisory lock][advisory-locks] is held over either the
@@ -648,7 +648,7 @@ impl<T: Task + Sync> Worker<T> {
     /// Processes the next available task in the queue.
     ///
     /// When a task is found, its execute method will be invoked with the
-    /// deqeued input.
+    /// dequeued input.
     ///
     /// If the execution exceeds the task's timeout then the execute future is
     /// cancelled. This can also result in the task being marked failed if its