Incorporate spelling & wording fixes from editorial review.

Co-authored-by: Chuck Toporek <[email protected]>

Author: amartini51

stdlib/public/Concurrency/AsyncStream.swift

@@ -131,7 +131,7 @@ public struct AsyncStream<Element> {
 
       /// The stream successfully enqueued the element.
       ///
-      /// This value reprsents the successful enqueueing of an element, whether
+      /// This value represents the successful enqueueing of an element, whether
       /// the stream buffers the element or delivers it immediately to a pending
       /// call to `next()`. The associated value `remaining` is a hint that
       /// indicates the number of remaining slots in the buffer at the time of
@@ -208,7 +208,7 @@ public struct AsyncStream<Element> {
     /// stream.
     ///
     /// If an `onTermination` callback is set, using task cancellation to
-    /// terminate iteration of a `AsyncStream` results in a call to this
+    /// terminate iteration of an `AsyncStream` results in a call to this
     /// callback.
     ///
     /// Canceling an active iteration invokes the `onTermination` callback
@@ -238,7 +238,7 @@ public struct AsyncStream<Element> {
   ///       unlimited number of elements. You can also set the policy to buffer a
   ///       specified number of oldest or newest elements.
   ///    - build: A custom closure that yields values to the
-  ///       `AsyncStream`. This closure receives a `AsyncStream.Continuation`
+  ///       `AsyncStream`. This closure receives an `AsyncStream.Continuation`
   ///       instance that it uses to provide elements to the stream and terminate the
   ///       stream when finished.
   ///
@@ -286,14 +286,14 @@ public struct AsyncStream<Element> {
   /// - Parameters:
   ///   - produce: A closure that asynchronously produces elements for the
   ///     stream.
-  ///   - onCancel: A closure to execute when cancelling the stream's task.
+  ///   - onCancel: A closure to execute when canceling the stream's task.
   ///
   /// Use this convenience initializer when you have an asychronous function
   /// that can produce elements for the stream, and don't want to invoke
   /// a continuation manually. This initializer "unfolds" your closure into
   /// an asynchronous stream. The created stream handles conformance
   /// to the `AsyncSequence` protocol automatically, including termination
-  /// (whether by cancellation or by returning `nil` from the closure to finish
+  /// (either by cancellation or by returning `nil` from the closure to finish
   /// iteration).
   ///
   /// The following example shows an `AsyncStream` created with this

stdlib/public/Concurrency/AsyncThrowingStream.swift

@@ -154,13 +154,13 @@ public struct AsyncThrowingStream<Element, Failure: Error> {
 
       /// The stream successfully enqueued the element.
       ///
-      /// This value reprsents the successful enqueueing of an element, whether
+      /// This value represents the successful enqueueing of an element, whether
       /// the stream buffers the element or delivers it immediately to a pending
       /// call to `next()`. The associated value `remaining` is a hint that
       /// indicates the number of remaining slots in the buffer at the time of
       /// the `yield` call.
       ///
-      /// - Note: From a thread safety viewpoint, `remaining` is a lower bound
+      /// - Note: From a thread safety perspective, `remaining` is a lower bound
       /// on the number of remaining slots. This is because a subsequent call
       /// that uses the `remaining` value could race on the consumption of
       /// values from the stream.
@@ -233,7 +233,7 @@ public struct AsyncThrowingStream<Element, Failure: Error> {
     /// stream.
     ///
     /// If an `onTermination` callback is set, using task cancellation to
-    /// terminate iteration of a `AsyncThrowingStream` results in a call to this
+    /// terminate iteration of an `AsyncThrowingStream` results in a call to this
     /// callback.
     ///
     /// Canceling an active iteration invokes the `onTermination` callback