Remove internal class from the sequence

Author: FranzBusch

Sources/AsyncAlgorithms/Merge/AsyncMerge2Sequence.swift

@@ -32,28 +32,8 @@ public struct AsyncMerge2Sequence<
 {
     public typealias Element = Base1.Element
 
-    /// This class is needed to hook the deinit to observe once all references to the ``AsyncMerge2Sequence`` are dropped.
-    ///
-    /// If we get move-only types we should be able to drop this class and use the `deinit` of the ``AsyncMerge2Sequence`` struct itself.
-    final class InternalClass: Sendable {
-        fileprivate let storage: MergeStorage<Base1, Base2, Base1>
-
-        fileprivate init(storage: MergeStorage<Base1, Base2, Base1>) {
-            self.storage = storage
-        }
-
-        deinit {
-            storage.sequenceDeinitialized()
-        }
-    }
-
-    /// The internal class to hook the `deinit`.
-    let internalClass: InternalClass
-
-    /// The underlying storage
-    fileprivate var storage: MergeStorage<Base1, Base2, Base1> {
-        internalClass.storage
-    }
+    private let base1: Base1
+    private let base2: Base2
 
     /// Initializes a new ``AsyncMerge2Sequence``.
     ///
@@ -64,18 +44,19 @@ public struct AsyncMerge2Sequence<
         _ base1: Base1,
         _ base2: Base2
     ) {
-        let storage = MergeStorage<Base1, Base2, Base1>(
-            base1: base1,
-            base2: base2,
-            base3: nil
-        )
-        internalClass = .init(storage: storage)
+        self.base1 = base1
+        self.base2 = base2
     }
 }
 
 extension AsyncMerge2Sequence: AsyncSequence {
     public func makeAsyncIterator() -> AsyncIterator {
-        AsyncIterator(storage: internalClass.storage)
+        let storage = MergeStorage<Base1, Base2, Base1>(
+            base1: base1,
+            base2: base2,
+            base3: nil
+        )
+        return AsyncIterator(storage: storage)
     }
 }
 

Sources/AsyncAlgorithms/Merge/AsyncMerge3Sequence.swift

@@ -39,28 +39,9 @@ public struct AsyncMerge3Sequence<
 {
     public typealias Element = Base1.Element
 
-    /// This class is needed to hook the deinit to observe once all references to the ``AsyncMerge2Sequence`` are dropped.
-    ///
-    /// If we get move-only types we should be able to drop this class and use the `deinit` of the ``AsyncMerge2Sequence`` struct itself.
-    final class InternalClass: Sendable {
-        fileprivate let storage: MergeStorage<Base1, Base2, Base3>
-
-        fileprivate init(storage: MergeStorage<Base1, Base2, Base3>) {
-            self.storage = storage
-        }
-
-        deinit {
-            storage.sequenceDeinitialized()
-        }
-    }
-
-    /// The internal class to hook the `deinit`.
-    let internalClass: InternalClass
-
-    /// The underlying storage
-    fileprivate var storage: MergeStorage<Base1, Base2, Base3> {
-        internalClass.storage
-    }
+    private let base1: Base1
+    private let base2: Base2
+    private let base3: Base3
 
     /// Initializes a new ``AsyncMerge2Sequence``.
     ///
@@ -73,18 +54,20 @@ public struct AsyncMerge3Sequence<
         _ base2: Base2,
         _ base3: Base3
     ) {
-        let storage = MergeStorage<Base1, Base2, Base3>(
-            base1: base1,
-            base2: base2,
-            base3: base3
-        )
-        internalClass = .init(storage: storage)
+        self.base1 = base1
+        self.base2 = base2
+        self.base3 = base3
     }
 }
 
 extension AsyncMerge3Sequence: AsyncSequence {
     public func makeAsyncIterator() -> AsyncIterator {
-        AsyncIterator(storage: internalClass.storage)
+        let storage = MergeStorage(
+            base1: base1,
+            base2: base2,
+            base3: base3
+        )
+        return AsyncIterator(storage: storage)
     }
 }
 

Sources/AsyncAlgorithms/Merge/MergeStateMachine.swift

@@ -82,28 +82,6 @@ struct MergeStateMachine<
         }
     }
 
-    mutating func sequenceDeinitialized() {
-        switch state {
-        case .initial:
-            // The references to the sequence were dropped before any iterator was ever created
-            state = .finished
-
-        case .merging, .upstreamFailure:
-            // An iterator was created and we deinited the sequence.
-            // This is an expected pattern and we just continue on normal.
-            // Importantly since we are a unicast sequence no more iterators can be created
-            return
-
-        case .finished:
-            // We are already finished so there is nothing left to clean up.
-            // This is just the references dropping afterwards.
-            return
-
-        case .modifying:
-            preconditionFailure("Invalid state")
-        }
-    }
-
     /// Actions returned by `iteratorInitialized()`.
     enum IteratorInitializedAction {
         /// Indicates that a new `Task` should be created that consumed the sequences.

Sources/AsyncAlgorithms/Merge/MergeStorage.swift

@@ -38,10 +38,6 @@ final class MergeStorage<
         self.lock.deinitialize()
     }
 
-    func sequenceDeinitialized() {
-        lock.withLock { self.stateMachine.sequenceDeinitialized() }
-    }
-
     func iteratorInitialized() {
         lock.withLockVoid {
             let action = self.stateMachine.iteratorInitialized()