Merge pull request #62685 from Jager-yoo/fix-concurrency-doc

[stdlib] Correct actual print outputs in Concurrency files

Author: amartini51

stdlib/public/Concurrency/AsyncCompactMapSequence.swift

@@ -38,7 +38,7 @@ extension AsyncSequence {
   ///     for await numeral in stream {
   ///         print(numeral, terminator: " ")
   ///     }
-  ///     // Prints "I II III V"
+  ///     // Prints "I II III V "
   ///
   /// - Parameter transform: A mapping closure. `transform` accepts an element
   ///   of this sequence as its parameter and returns a transformed value of the

stdlib/public/Concurrency/AsyncDropFirstSequence.swift

@@ -27,7 +27,7 @@ extension AsyncSequence {
   ///     for await number in Counter(howHigh: 10).dropFirst(3) {
   ///         print(number, terminator: " ")
   ///     }
-  ///     // Prints "4 5 6 7 8 9 10"
+  ///     // Prints "4 5 6 7 8 9 10 "
   ///
   /// If the number of elements to drop exceeds the number of elements in the
   /// sequence, the result is an empty sequence.

stdlib/public/Concurrency/AsyncDropWhileSequence.swift

@@ -30,7 +30,7 @@ extension AsyncSequence {
   ///     for await number in stream {
   ///         print(number, terminator: " ")
   ///     }
-  ///     // Prints "3 4 5 6 7 8 9 10"
+  ///     // Prints "3 4 5 6 7 8 9 10 "
   ///
   /// After the predicate returns `false`, the sequence never executes it again,
   /// and from then on the sequence passes through elements from its underlying

stdlib/public/Concurrency/AsyncFilterSequence.swift

@@ -26,7 +26,7 @@ extension AsyncSequence {
   ///     for await number in stream {
   ///         print(number, terminator: " ")
   ///     }
-  ///     // Prints "2 4 6 8 10"
+  ///     // Prints "2 4 6 8 10 "
   ///
   /// - Parameter isIncluded: A closure that takes an element of the
   ///   asynchronous sequence as its argument and returns a Boolean value

stdlib/public/Concurrency/AsyncFlatMapSequence.swift

@@ -33,7 +33,7 @@ extension AsyncSequence {
   ///     for await number in stream {
   ///         print(number, terminator: " ")
   ///     }
-  ///     // Prints "1 1 2 1 2 3 1 2 3 4 1 2 3 4 5"
+  ///     // Prints "1 1 2 1 2 3 1 2 3 4 1 2 3 4 5 "
   ///
   /// - Parameter transform: A mapping closure. `transform` accepts an element
   ///   of this sequence as its parameter and returns an `AsyncSequence`.

stdlib/public/Concurrency/AsyncIteratorProtocol.swift

@@ -57,10 +57,10 @@ import Swift
 ///
 /// At the call site, this looks like:
 ///
-///     for await i in Counter(howHigh: 10) {
-///       print(i, terminator: " ")
+///     for await number in Counter(howHigh: 10) {
+///       print(number, terminator: " ")
 ///     }
-///     // Prints "1 2 3 4 5 6 7 8 9 10"
+///     // Prints "1 2 3 4 5 6 7 8 9 10 "
 ///
 /// ### End of Iteration
 ///

stdlib/public/Concurrency/AsyncMapSequence.swift

@@ -36,7 +36,7 @@ extension AsyncSequence {
   ///     for await numeral in stream {
   ///         print(numeral, terminator: " ")
   ///     }
-  ///     // Prints "I II III (unknown) V"
+  ///     // Prints "I II III (unknown) V "
   ///
   /// - Parameter transform: A mapping closure. `transform` accepts an element
   ///   of this sequence as its parameter and returns a transformed value of the

stdlib/public/Concurrency/AsyncPrefixSequence.swift

@@ -27,7 +27,7 @@ extension AsyncSequence {
   ///     for await number in Counter(howHigh: 10).prefix(6) {
   ///         print(number, terminator: " ")
   ///     }
-  ///     // Prints "1 2 3 4 5 6"
+  ///     // Prints "1 2 3 4 5 6 "
   ///
   /// If the count passed to `prefix(_:)` exceeds the number of elements in the
   /// base sequence, the result contains all of the elements in the sequence.

stdlib/public/Concurrency/AsyncPrefixWhileSequence.swift

@@ -31,7 +31,7 @@ extension AsyncSequence {
   ///     for try await number in stream {
   ///         print(number, terminator: " ")
   ///     }
-  ///     // Prints "1 2 3 4 5"
+  ///     // Prints "1 2 3 4 5 "
   ///     
   /// - Parameter predicate: A closure that takes an element as a parameter and
   ///   returns a Boolean value indicating whether the element should be

stdlib/public/Concurrency/AsyncSequence.swift

@@ -27,10 +27,10 @@ import Swift
 /// over `Counter`, a custom `AsyncSequence` that produces `Int` values from
 /// `1` up to a `howHigh` value:
 ///
-///     for await i in Counter(howHigh: 10) {
-///         print(i, terminator: " ")
+///     for await number in Counter(howHigh: 10) {
+///         print(number, terminator: " ")
 ///     }
-///     // Prints "1 2 3 4 5 6 7 8 9 10"
+///     // Prints "1 2 3 4 5 6 7 8 9 10 "
 ///
 /// An `AsyncSequence` doesn't generate or contain the values; it just defines
 /// how you access them. Along with defining the type of values as an associated
@@ -69,7 +69,7 @@ import Swift
 ///     for await s in stream {
 ///         print(s, terminator: " ")
 ///     }
-///     // Prints "Odd Even Odd Even Odd Even Odd Even Odd Even"
+///     // Prints "Odd Even Odd Even Odd Even Odd Even Odd Even "
 ///
 @available(SwiftStdlib 5.1, *)
 @rethrows

stdlib/public/Concurrency/AsyncThrowingCompactMapSequence.swift

@@ -47,7 +47,7 @@ extension AsyncSequence {
   ///     } catch {
   ///         print("Error: \(error)")
   ///     }
-  ///     // Prints "I II III Error: MyError()"
+  ///     // Prints "I II III Error: MyError() "
   ///
   /// - Parameter transform: An error-throwing mapping closure. `transform`
   ///   accepts an element of this sequence as its parameter and returns a

stdlib/public/Concurrency/AsyncThrowingFilterSequence.swift

@@ -36,7 +36,7 @@ extension AsyncSequence {
   ///     } catch {
   ///         print("Error: \(error)")
   ///     }
-  ///     // Prints "2 4 Error: MyError()"
+  ///     // Prints "2 4 Error: MyError() "
   ///
   /// - Parameter isIncluded: An error-throwing closure that takes an element
   ///   of the asynchronous sequence as its argument and returns a Boolean value

stdlib/public/Concurrency/AsyncThrowingFlatMapSequence.swift

@@ -44,7 +44,7 @@ extension AsyncSequence {
   ///     } catch {
   ///         print(error)
   ///     }
-  ///     // Prints "1 1 2 1 2 3 MyError()"
+  ///     // Prints "1 1 2 1 2 3 MyError() "
   ///
   /// - Parameter transform: An error-throwing mapping closure. `transform`
   ///   accepts an element of this sequence as its parameter and returns an

stdlib/public/Concurrency/AsyncThrowingMapSequence.swift

@@ -48,7 +48,7 @@ extension AsyncSequence {
   ///     } catch {
   ///         print("Error: \(error)")
   ///     }
-  ///     // Prints "I II III Error: MyError()"
+  ///     // Prints "I II III Error: MyError() "
   ///
   /// - Parameter transform: A mapping closure. `transform` accepts an element
   ///   of this sequence as its parameter and returns a transformed value of the

stdlib/public/Concurrency/AsyncThrowingPrefixWhileSequence.swift

@@ -41,7 +41,7 @@ extension AsyncSequence {
   ///     } catch {
   ///         print("Error: \(error)")
   ///     }
-  ///     // Prints "1 2 3 4 Error: MyError()"
+  ///     // Prints "1 2 3 4 Error: MyError() "
   ///
   /// - Parameter predicate: A error-throwing closure that takes an element of
   ///   the asynchronous sequence as its argument and returns a Boolean value