chore: add typo fixes

Author: soumyamahunt

Sources/AsyncObjects/AsyncEvent.swift

@@ -2,7 +2,7 @@ import Foundation
 
 /// An object that controls execution of tasks depending on the signal state.
 ///
-/// An async event suspends tasks if current state is non-signaled and resumes execution when event is signaled.
+/// An async event suspends tasks if current state is non-signaled and resumes execution when event is signalled.
 ///
 /// You can signal event by calling the ``signal()`` method and reset signal by calling ``reset()``.
 /// Wait for event signal by calling ``wait()`` method or its timeout variation ``wait(forNanoseconds:)``.
@@ -11,8 +11,8 @@ public actor AsyncEvent: AsyncObject {
     private typealias Continuation = GlobalContinuation<Void, Error>
     /// The continuations stored with an associated key for all the suspended task that are waiting for event signal.
     private var continuations: [UUID: Continuation] = [:]
-    /// Indicates whether current stateof event is signaled.
-    private var signaled: Bool
+    /// Indicates whether current state of event is signalled.
+    private var signalled: Bool
 
     /// Add continuation with the provided key in `continuations` map.
     ///
@@ -60,13 +60,13 @@ public actor AsyncEvent: AsyncObject {
     }
 
     /// Creates a new event with signal state provided.
-    /// By default, event is initially in signaled state.
+    /// By default, event is initially in signalled state.
     ///
-    /// - Parameter signaled: The signal state for event.
+    /// - Parameter signalled: The signal state for event.
     ///
     /// - Returns: The newly created event.
-    public init(signaledInitially signaled: Bool = true) {
-        self.signaled = signaled
+    public init(signaledInitially signalled: Bool = true) {
+        self.signalled = signalled
     }
 
     deinit { self.continuations.forEach { $0.value.cancel() } }
@@ -76,7 +76,7 @@ public actor AsyncEvent: AsyncObject {
     /// After reset, tasks have to wait for event signal to complete.
     @Sendable
     public func reset() {
-        signaled = false
+        signalled = false
     }
 
     /// Signals the event.
@@ -86,16 +86,16 @@ public actor AsyncEvent: AsyncObject {
     public func signal() {
         continuations.forEach { $0.value.resume() }
         continuations = [:]
-        signaled = true
+        signalled = true
     }
 
-    /// Waits for event signal, or proceeds if already signaled.
+    /// Waits for event signal, or proceeds if already signalled.
     ///
     /// Only waits asynchronously, if event is in non-signaled state,
-    /// until event is signaled.
+    /// until event is signalled.
     @Sendable
     public func wait() async {
-        guard !signaled else { return }
+        guard !signalled else { return }
         try? await withPromisedContinuation()
     }
 }

Sources/AsyncObjects/AsyncObject.swift

@@ -11,11 +11,11 @@ public enum TaskTimeoutResult: Hashable {
     case timedOut
 }
 
-/// An object type that can provide synchonization accross multiple task contexts
+/// An object type that can provide synchronization across multiple task contexts
 ///
 /// Waiting asynchronously can be done by calling ``wait()`` method,
 /// while object decides when to resume task. Similarly, ``signal()`` can be used
-/// to indicate resuming of suspended tasks.
+/// to indicate resuming suspended tasks.
 public protocol AsyncObject: Sendable {
     /// Signals the object for task synchronization.
     ///
@@ -69,7 +69,7 @@ public extension AsyncObject where Self: AnyObject {
 /// Waits for multiple objects to green light task execution.
 ///
 /// Invokes ``AsyncObject/wait()`` for all objects
-/// and returns only when all the invokation completes.
+/// and returns only when all the invocation completes.
 ///
 /// - Parameter objects: The objects to wait for.
 @inlinable
@@ -83,7 +83,7 @@ public func waitForAll(_ objects: [any AsyncObject]) async {
 /// Waits for multiple objects to green light task execution.
 ///
 /// Invokes ``AsyncObject/wait()`` for all objects
-/// and returns only when all the invokation completes.
+/// and returns only when all the invocation completes.
 ///
 /// - Parameter objects: The objects to wait for.
 @inlinable
@@ -95,7 +95,7 @@ public func waitForAll(_ objects: any AsyncObject...) async {
 /// within provided duration.
 ///
 /// Invokes ``AsyncObject/wait()`` for all objects
-/// and returns either when all the invokation completes
+/// and returns either when all the invocation completes
 /// or the timeout expires.
 ///
 /// - Parameters:
@@ -116,7 +116,7 @@ public func waitForAll(
 /// within provided duration.
 ///
 /// Invokes ``AsyncObject/wait()`` for all objects
-/// and returns either when all the invokation completes
+/// and returns either when all the invocation completes
 /// or the timeout expires.
 ///
 /// - Parameters:
@@ -135,7 +135,7 @@ public func waitForAll(
 /// by some(provided by count) of them.
 ///
 /// Invokes ``AsyncObject/wait()`` for all objects
-/// and returns when some(provided by count) of the invokation completes.
+/// and returns when some(provided by count) of the invocation completes.
 ///
 /// - Parameters:
 ///   - objects: The objects to wait for.
@@ -153,7 +153,7 @@ public func waitForAny(_ objects: [any AsyncObject], count: Int = 1) async {
 /// by some(provided by count) of them.
 ///
 /// Invokes ``AsyncObject/wait()`` for all objects
-/// and returns when some(provided by count) of the invokation completes.
+/// and returns when some(provided by count) of the invocation completes.
 ///
 /// - Parameters:
 ///   - objects: The objects to wait for.
@@ -167,7 +167,7 @@ public func waitForAny(_ objects: any AsyncObject..., count: Int = 1) async {
 /// by some(provided by count) of them within provided duration.
 ///
 /// Invokes ``AsyncObject/wait()`` for all objects
-/// and returns when some(provided by count) of the invokation completes
+/// and returns when some(provided by count) of the invocation completes
 /// or the timeout expires.
 ///
 /// - Parameters:
@@ -190,7 +190,7 @@ public func waitForAny(
 /// by some(provided by count) of them within provided duration.
 ///
 /// Invokes ``AsyncObject/wait()`` for all objects
-/// and returns when some(provided by count) of the invokation completes
+/// and returns when some(provided by count) of the invocation completes
 /// or the timeout expires.
 ///
 /// - Parameters:

Sources/AsyncObjects/AsyncSemaphore.swift

@@ -18,7 +18,7 @@ public actor AsyncSemaphore: AsyncObject {
     /// Has value provided during initialization incremented by one.
     private var limit: UInt
     /// Current count of semaphore.
-    /// Can have maximum value upto `limit`.
+    /// Can have maximum value up to `limit`.
     private var count: Int
 
     /// Add continuation with the provided key in `continuations` map.

Sources/AsyncObjects/CancellationSource.swift

@@ -2,18 +2,18 @@ import Foundation
 
 /// An object that controls cooperative cancellation of multiple registered tasks and linked object registered tasks.
 ///
-/// An async event suspends tasks if current state is non-signaled and resumes execution when event is signaled.
+/// An async event suspends tasks if current state is non-signaled and resumes execution when event is signalled.
 ///
 /// You can register tasks for cancellation using the ``register(task:)`` method
 /// and link with additional sources by creating object with ``init(linkedWith:)`` method.
-/// By calling the ``cancel()`` method all the reigistered tasks will be cancelled
+/// By calling the ``cancel()`` method all the registered tasks will be cancelled
 /// and the cancellation event will be propagated to linked cancellation sources,
-/// which in turn cancels their rigistered tasks and further propagates cancellation.
+/// which in turn cancels their registered tasks and further propagates cancellation.
 ///
 /// - Warning: Cancellation sources propagate cancellation event to other linked cancellation sources.
 ///            In case of circular dependency between cancellation sources, app will go into infinite recursion.
 public actor CancellationSource {
-    /// All the rigistered tasks for cooperative cancellation.
+    /// All the registered tasks for cooperative cancellation.
     private var registeredTasks: [AnyHashable: () -> Void] = [:]
     /// All the linked cancellation sources that cancellation event will be propagated.
     ///
@@ -27,7 +27,7 @@ public actor CancellationSource {
     ///
     /// - Parameter task: The task to register.
     @inline(__always)
-    private func add<Success, Faliure>(task: Task<Success, Faliure>) {
+    private func add<Success, Failure>(task: Task<Success, Failure>) {
         guard !task.isCancelled else { return }
         registeredTasks[task] = { task.cancel() }
     }
@@ -36,7 +36,7 @@ public actor CancellationSource {
     ///
     /// - Parameter task: The task to remove.
     @inline(__always)
-    private func remove<Success, Faliure>(task: Task<Success, Faliure>) {
+    private func remove<Success, Failure>(task: Task<Success, Failure>) {
         registeredTasks.removeValue(forKey: task)
     }
 
@@ -56,7 +56,7 @@ public actor CancellationSource {
     /// Creates a new cancellation source object linking to all the provided cancellation sources.
     ///
     /// Initiating cancellation in any of the provided cancellation sources
-    /// will ensure newly created cancellation source recieve cancellation event.
+    /// will ensure newly created cancellation source receive cancellation event.
     ///
     /// - Parameter sources: The cancellation sources the newly created object will be linked to.
     ///
@@ -73,7 +73,7 @@ public actor CancellationSource {
     /// Creates a new cancellation source object linking to all the provided cancellation sources.
     ///
     /// Initiating cancellation in any of the provided cancellation sources
-    /// will ensure newly created cancellation source recieve cancellation event.
+    /// will ensure newly created cancellation source receive cancellation event.
     ///
     /// - Parameter sources: The cancellation sources the newly created object will be linked to.
     ///
@@ -95,13 +95,13 @@ public actor CancellationSource {
         }
     }
 
-    /// Register task for cooperative cancellation when cancellation event recieved on cancellation source.
+    /// Register task for cooperative cancellation when cancellation event received on cancellation source.
     ///
     /// If task completes before cancellation event is triggered, it is automatically unregistered.
     ///
     /// - Parameter task: The task to register.
     @Sendable
-    public func register<Success, Faliure>(task: Task<Success, Faliure>) {
+    public func register<Success, Failure>(task: Task<Success, Failure>) {
         add(task: task)
         Task { [weak self] in
             let _ = await task.result
@@ -134,7 +134,7 @@ public actor CancellationSource {
 }
 
 public extension Task {
-    /// Runs the given nonthrowing operation asynchronously as part of a new task on behalf of the current actor,
+    /// Runs the given non-throwing operation asynchronously as part of a new task on behalf of the current actor,
     /// with the provided cancellation source controlling cooperative cancellation.
     ///
     /// A child task with the provided operation is created, cancellation of which is controlled by provided cancellation source.
@@ -186,7 +186,7 @@ public extension Task {
         }
     }
 
-    /// Runs the given nonthrowing operation asynchronously as part of a new task,
+    /// Runs the given non-throwing operation asynchronously as part of a new task,
     /// with the provided cancellation source controlling cooperative cancellation.
     ///
     /// A child task with the provided operation is created, cancellation of which is controlled by provided cancellation source.
@@ -238,7 +238,7 @@ public extension Task {
         }
     }
 
-    /// Runs the given nonthrowing operation asynchronously as part of a new top-level task on behalf of the current actor,
+    /// Runs the given non-throwing operation asynchronously as part of a new top-level task on behalf of the current actor,
     /// with the provided cancellation source controlling cooperative cancellation.
     ///
     /// The created task will be cancelled when cancellation event triggered on the provided cancellation source.
@@ -280,7 +280,7 @@ public extension Task {
         await cancellationSource.register(task: self)
     }
 
-    /// Runs the given nonthrowing operation asynchronously as part of a new top-level task,
+    /// Runs the given non-throwing operation asynchronously as part of a new top-level task,
     /// with the provided cancellation source controlling cooperative cancellation.
     ///
     /// The created task will be cancelled when cancellation event triggered on the provided cancellation source.

Sources/AsyncObjects/Continuable.swift

@@ -36,7 +36,7 @@ protocol ThrowingContinuable: Continuable {
     /// with a throwing continuation for the current task.
     ///
     /// The continuation can be resumed exactly once,
-    /// subsequent resumes have different behavior depending on type implemeting.
+    /// subsequent resumes have different behaviors depending on type implementing.
     ///
     /// - Parameter fn: A closure that takes the throwing continuation parameter.
     ///                 You can resume the continuation exactly once.
@@ -92,12 +92,12 @@ protocol NonThrowingContinuable: Continuable {
     /// The type of error to resume the continuation with in case of failure.
     associatedtype Failure = Never
     /// Suspends the current task, then calls the given closure
-    /// with a nonthrowing continuation for the current task.
+    /// with a non-throwing continuation for the current task.
     ///
     /// The continuation can be resumed exactly once,
-    /// subsequent resumes have different behavior depending on type implemeting.
+    /// subsequent resumes have different behavior depending on type implementing.
     ///
-    /// - Parameter fn: A closure that takes the nonthrowing continuation parameter.
+    /// - Parameter fn: A closure that takes the non-throwing continuation parameter.
     ///                 You can resume the continuation exactly once.
     ///
     /// - Returns: The value passed to the continuation by the closure.
@@ -107,7 +107,7 @@ protocol NonThrowingContinuable: Continuable {
 
 extension UnsafeContinuation: NonThrowingContinuable where E == Never {
     /// Suspends the current task, then calls the given closure
-    /// with an unsafe nonthrowing continuation for the current task.
+    /// with an unsafe non-throwing continuation for the current task.
     ///
     /// The continuation must be resumed exactly once, subsequent resumes will cause runtime error.
     /// Use `CheckedContinuation` to capture relevant data in case of runtime errors.
@@ -124,7 +124,7 @@ extension UnsafeContinuation: NonThrowingContinuable where E == Never {
 
 extension CheckedContinuation: NonThrowingContinuable where E == Never {
     /// Suspends the current task, then calls the given closure
-    /// with a checked nonthrowing continuation for the current task.
+    /// with a checked non-throwing continuation for the current task.
     ///
     /// The continuation must be resumed exactly once, subsequent resumes will cause runtime error.
     /// `CheckedContinuation` logs messages proving additional info on these errors.

Sources/AsyncObjects/Future.swift

@@ -40,7 +40,7 @@ public actor Future<Output, Failure: Error> {
     }
 
     /// Creates a future that can be fulfilled later by ``fulfill(with:)`` or
-    /// any other variation of this methos.
+    /// any other variation of this methods.
     ///
     /// - Returns: The newly created future.
     public init() { }
@@ -115,7 +115,7 @@ extension Future where Failure == Never {
     /// The published value of the future, delivered asynchronously.
     ///
     /// This property exposes the fulfilled value for the `Future` asynchronously.
-    /// Immidiately returns if `Future` is fulfilled otherwise waits asynchronously
+    /// Immediately returns if `Future` is fulfilled otherwise waits asynchronously
     /// for `Future` to be fulfilled.
     public var value: Output {
         get async {
@@ -329,7 +329,7 @@ extension Future where Failure == Error {
     /// The published value of the future or an error, delivered asynchronously.
     ///
     /// This property exposes the fulfilled value for the `Future` asynchronously.
-    /// Immidiately returns if `Future` is fulfilled otherwise waits asynchronously
+    /// Immediately returns if `Future` is fulfilled otherwise waits asynchronously
     /// for `Future` to be fulfilled. If the Future terminates with an error,
     /// the awaiting caller receives the error instead.
     public var value: Output {