Mark all iterators as non-Sendable (#280)

Author: FranzBusch

Sources/AsyncAlgorithms/AsyncAdjacentPairsSequence.swift

@@ -9,6 +9,29 @@
 //
 //===----------------------------------------------------------------------===//
 
+extension AsyncSequence {
+  /// An `AsyncSequence` that iterates over the adjacent pairs of the original
+  /// original `AsyncSequence`.
+  ///
+  /// ```
+  /// for await (first, second) in (1...5).async.adjacentPairs() {
+  ///    print("First: \(first), Second: \(second)")
+  /// }
+  ///
+  /// // First: 1, Second: 2
+  /// // First: 2, Second: 3
+  /// // First: 3, Second: 4
+  /// // First: 4, Second: 5
+  /// ```
+  ///
+  /// - Returns: An `AsyncSequence` where the element is a tuple of two adjacent elements
+  ///   or the original `AsyncSequence`.
+  @inlinable
+  public func adjacentPairs() -> AsyncAdjacentPairsSequence<Self> {
+    AsyncAdjacentPairsSequence(self)
+  }
+}
+
 /// An `AsyncSequence` that iterates over the adjacent pairs of the original
 /// `AsyncSequence`.
 @frozen
@@ -60,29 +83,6 @@ public struct AsyncAdjacentPairsSequence<Base: AsyncSequence>: AsyncSequence {
   }
 }
 
-extension AsyncSequence {
-  /// An `AsyncSequence` that iterates over the adjacent pairs of the original
-  /// original `AsyncSequence`.
-  ///
-  /// ```
-  /// for await (first, second) in (1...5).async.adjacentPairs() {
-  ///    print("First: \(first), Second: \(second)")
-  /// }
-  ///
-  /// // First: 1, Second: 2
-  /// // First: 2, Second: 3
-  /// // First: 3, Second: 4
-  /// // First: 4, Second: 5
-  /// ```
-  ///
-  /// - Returns: An `AsyncSequence` where the element is a tuple of two adjacent elements
-  ///   or the original `AsyncSequence`.
-  @inlinable
-  public func adjacentPairs() -> AsyncAdjacentPairsSequence<Self> {
-    AsyncAdjacentPairsSequence(self)
-  }
-}
-
 extension AsyncAdjacentPairsSequence: Sendable where Base: Sendable, Base.Element: Sendable { }
 
 @available(*, unavailable)

Sources/AsyncAlgorithms/AsyncAlgorithms.docc/Guides/Timer.md

@@ -42,7 +42,7 @@ extension AsyncTimerSequence: Sendable { }
 extension AsyncTimerSequence.Iterator: Sendable { }
 ```
 
-Since all the types comprising `AsyncTimerSequence` and it's `Iterator` are `Sendable` these types are also `Sendable`.
+Since all the types comprising `AsyncTimerSequence` are `Sendable` these types are also `Sendable`.
 
 ## Credits/Inspiration
 

Sources/AsyncAlgorithms/AsyncChain3Sequence.swift

@@ -95,3 +95,6 @@ extension AsyncChain3Sequence: AsyncSequence {
 }
 
 extension AsyncChain3Sequence: Sendable where Base1: Sendable, Base2: Sendable, Base3: Sendable { }
+
+@available(*, unavailable)
+extension AsyncChain3Sequence.Iterator: Sendable { }

Sources/AsyncAlgorithms/AsyncChunkedByGroupSequence.swift

@@ -117,4 +117,6 @@ public struct AsyncChunkedByGroupSequence<Base: AsyncSequence, Collected: RangeR
 }
 
 extension AsyncChunkedByGroupSequence : Sendable where Base : Sendable, Base.Element : Sendable { }
-extension AsyncChunkedByGroupSequence.Iterator : Sendable where Base.AsyncIterator : Sendable, Base.Element : Sendable { }
+
+@available(*, unavailable)
+extension AsyncChunkedByGroupSequence.Iterator: Sendable { }

Sources/AsyncAlgorithms/AsyncChunkedOnProjectionSequence.swift

@@ -97,4 +97,6 @@ public struct AsyncChunkedOnProjectionSequence<Base: AsyncSequence, Subject: Equ
 }
 
 extension AsyncChunkedOnProjectionSequence : Sendable where Base : Sendable, Base.Element : Sendable { }
-extension AsyncChunkedOnProjectionSequence.Iterator : Sendable where Base.AsyncIterator : Sendable, Base.Element : Sendable, Subject : Sendable { }
+
+@available(*, unavailable)
+extension AsyncChunkedOnProjectionSequence.Iterator: Sendable { }

Sources/AsyncAlgorithms/AsyncChunksOfCountOrSignalSequence.swift

@@ -128,3 +128,6 @@ public struct AsyncChunksOfCountOrSignalSequence<Base: AsyncSequence, Collected:
     return Iterator(iterator: merge(chain(base.map { Either.element($0) }, [.terminal].async), signal.map { _ in Either.signal }).makeAsyncIterator(), count: count)
   }
 }
+
+@available(*, unavailable)
+extension AsyncChunksOfCountOrSignalSequence.Iterator: Sendable { }

Sources/AsyncAlgorithms/AsyncChunksOfCountSequence.swift

@@ -83,3 +83,6 @@ public struct AsyncChunksOfCountSequence<Base: AsyncSequence, Collected: RangeRe
 
 extension AsyncChunksOfCountSequence : Sendable where Base : Sendable, Base.Element : Sendable { }
 extension AsyncChunksOfCountSequence.Iterator : Sendable where Base.AsyncIterator : Sendable, Base.Element : Sendable { }
+
+@available(*, unavailable)
+extension AsyncChunksOfCountSequence.Iterator: Sendable { }

Sources/AsyncAlgorithms/AsyncCompactedSequence.swift

@@ -9,6 +9,22 @@
 //
 //===----------------------------------------------------------------------===//
 
+extension AsyncSequence {
+  /// Returns a new `AsyncSequence` that iterates over every non-nil element from the
+  /// original `AsyncSequence`.
+  ///
+  /// Produces the same result as `c.compactMap { $0 }`.
+  ///
+  /// - Returns: An `AsyncSequence` where the element is the unwrapped original
+  ///   element and iterates over every non-nil element from the original
+  ///   `AsyncSequence`.
+  @inlinable
+  public func compacted<Unwrapped>() -> AsyncCompactedSequence<Self, Unwrapped>
+    where Element == Unwrapped? {
+    AsyncCompactedSequence(self)
+  }
+}
+
 /// An `AsyncSequence` that iterates over every non-nil element from the original
 /// `AsyncSequence`.
 @frozen
@@ -50,22 +66,7 @@ public struct AsyncCompactedSequence<Base: AsyncSequence, Element>: AsyncSequenc
   }
 }
 
-extension AsyncSequence {
-  /// Returns a new `AsyncSequence` that iterates over every non-nil element from the
-  /// original `AsyncSequence`.
-  ///
-  /// Produces the same result as `c.compactMap { $0 }`.
-  ///
-  /// - Returns: An `AsyncSequence` where the element is the unwrapped original
-  ///   element and iterates over every non-nil element from the original
-  ///   `AsyncSequence`.
-  ///
-  /// Complexity: O(1)
-  @inlinable
-  public func compacted<Unwrapped>() -> AsyncCompactedSequence<Self, Unwrapped>
-    where Element == Unwrapped? {
-    AsyncCompactedSequence(self)
-  }
-}
-
 extension AsyncCompactedSequence: Sendable where Base: Sendable, Base.Element: Sendable { }
+
+@available(*, unavailable)
+extension AsyncCompactedSequence.Iterator: Sendable { }

Sources/AsyncAlgorithms/AsyncExclusiveReductionsSequence.swift

@@ -112,3 +112,6 @@ extension AsyncExclusiveReductionsSequence: AsyncSequence {
 }
 
 extension AsyncExclusiveReductionsSequence: Sendable where Base: Sendable, Element: Sendable { }
+
+@available(*, unavailable)
+extension AsyncExclusiveReductionsSequence.Iterator: Sendable { }

Sources/AsyncAlgorithms/AsyncInclusiveReductionsSequence.swift

@@ -85,3 +85,6 @@ extension AsyncInclusiveReductionsSequence: AsyncSequence {
 }
 
 extension AsyncInclusiveReductionsSequence: Sendable where Base: Sendable { }
+
+@available(*, unavailable)
+extension AsyncInclusiveReductionsSequence.Iterator: Sendable { }