feat: add AnyAsyncThrowingSequece, to differentiate from regular one

This makes things easier when dealing with infinite sequences (like
values from a Combine Publisher)

Sources/AnyAsyncSequence/AnyAsyncSequence.swift

@@ -27,21 +27,63 @@ import Foundation
 
 /// A type erased `AsyncSequence`
 ///
-/// This type allows you to create APIs that return an `AsyncSequence` that allows consumers to iterate over the sequence, without exposing the sequence's underlyin type.
-/// Typically, you wouldn't actually initialize this type yourself, but instead create one using the `.eraseToAnyAsyncSequence()` operator also provided with this package.
+/// This type allows you to create APIs that return an `AsyncSequence` that allows consumers to iterate over the
+/// sequence, without exposing the sequence's underlying type.
+/// Typically, you wouldn't actually initialize this type yourself, but instead create one using the
+/// `.eraseToAnyAsyncSequence()` operator also provided with this package.
 @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *)
 public struct AnyAsyncSequence<Element>: AsyncSequence {
 
     // MARK: - Initializers
-
     /// Create an `AnyAsyncSequence` from an `AsyncSequence` conforming type
     /// - Parameter sequence: The `AnySequence` type you wish to erase
     public init<T: AsyncSequence>(_ sequence: T) where T.Element == Element {
         makeAsyncIteratorClosure = { AnyAsyncIterator(sequence.makeAsyncIterator()) }
     }
 
     // MARK: - API
+    public struct AnyAsyncIterator: AsyncIteratorProtocol {
+        private let nextClosure: () async -> Element?
+
+        public init<T: AsyncIteratorProtocol>(_ iterator: T) where T.Element == Element {
+            var iterator = iterator
+            nextClosure = { try? await iterator.next() }
+        }
+
+        public func next() async -> Element? {
+            await nextClosure()
+        }
+    }
+
+    // MARK: - AsyncSequence
+    public typealias Element = Element
+
+    public typealias AsyncIterator = AnyAsyncIterator
+
+    public func makeAsyncIterator() -> AsyncIterator {
+        AnyAsyncIterator(makeAsyncIteratorClosure())
+    }
 
+    private let makeAsyncIteratorClosure: () -> AsyncIterator
+}
+
+/// A type erased `AsyncThrowingSequence`
+///
+/// This type allows you to create APIs that return an `AsyncThrowingSequence` that allows consumers to iterate over the
+/// sequence, without exposing the sequence's underlying type.
+/// Typically, you wouldn't actually initialize this type yourself, but instead create one using the
+/// `.eraseToAnyAsyncThrowingSequence()` operator also provided with this package.
+@available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *)
+public struct AnyAsyncThrowingSequence<Element>: AsyncSequence {
+
+    // MARK: - Initializers
+    /// Create an `AnyAsyncSequence` from an `AsyncSequence` conforming type
+    /// - Parameter sequence: The `AnySequence` type you wish to erase
+    public init<T: AsyncSequence>(_ sequence: T) where T.Element == Element {
+        makeAsyncIteratorClosure = { AnyAsyncIterator(sequence.makeAsyncIterator()) }
+    }
+
+    // MARK: - API
     public struct AnyAsyncIterator: AsyncIteratorProtocol {
         private let nextClosure: () async throws -> Element?
 
@@ -56,7 +98,6 @@ public struct AnyAsyncSequence<Element>: AsyncSequence {
     }
 
     // MARK: - AsyncSequence
-
     public typealias Element = Element
 
     public typealias AsyncIterator = AnyAsyncIterator
@@ -66,5 +107,4 @@ public struct AnyAsyncSequence<Element>: AsyncSequence {
     }
 
     private let makeAsyncIteratorClosure: () -> AsyncIterator
-
 }

Sources/AnyAsyncSequence/AsyncSequence+AnySequence.swift

@@ -34,4 +34,9 @@ public extension AsyncSequence {
         AnyAsyncSequence(self)
     }
 
+    /// Create a type erased version of this sequence
+    /// - Returns: The sequence, wrapped in an `AnyAsyncThrowingSequence`
+    func eraseToAnyAsyncThrowingSequence() -> AnyAsyncThrowingSequence<Element> where {
+        AnyAsyncThrowingSequence(self)
+    }
 }