refactor

Author: ZirgVoice

.gitignore

@@ -87,4 +87,6 @@ fastlane/test_output
 # After new code Injection tools there's a generated folder /iOSInjectionProject
 # https://github.com/johnno1962/injectionforxcode
 
-iOSInjectionProject/
+iOSInjectionProject/
+Sources/.DS_Store
+.DS_Store

Package.resolved

@@ -18,15 +18,6 @@
         "version" : "1.2.0"
       }
     },
-    {
-      "identity" : "swift-async-algorithms",
-      "kind" : "remoteSourceControl",
-      "location" : "https://github.com/apple/swift-async-algorithms",
-      "state" : {
-        "revision" : "cb417003f962f9de3fc7852c1b735a1f1152a89a",
-        "version" : "1.0.0-beta.1"
-      }
-    },
     {
       "identity" : "swift-collections",
       "kind" : "remoteSourceControl",

Package.swift

@@ -11,15 +11,13 @@ let package = Package(
     ],
     dependencies: [
         .package(url: "https://github.com/apple/swift-algorithms.git", from: "1.0.0"),
-        .package(url: "https://github.com/apple/swift-async-algorithms", from: "1.0.0-beta.1"),
         .package(url: "https://github.com/adam-fowler/async-collections", from: "0.0.1"),
     ],
     targets: [
         .target(
             name: "DataLoader",
             dependencies: [
                 .product(name: "Algorithms", package: "swift-algorithms"),
-                .product(name: "AsyncAlgorithms", package: "swift-async-algorithms"),
                 .product(name: "AsyncCollections", package: "async-collections"),
             ]
         ),

Sources/DataLoader/Channel/Channel.swift

@@ -0,0 +1,55 @@
+public actor Channel<Success: Sendable, Failure: Error>: Sendable {
+    private var state = State<Success, Failure>()
+}
+
+public extension Channel {
+    @discardableResult
+    func fulfill(_ value: Success) async -> Bool {
+        if await state.result == nil {
+            await state.setResult(result: value)
+
+            for waiters in await state.waiters {
+                waiters.resume(returning: value)
+            }
+
+            await state.removeAllWaiters()
+
+            return false
+        }
+        
+        return true
+    }
+
+    @discardableResult
+    func fail(_ failure: Failure) async -> Bool {
+        if await state.failure == nil {
+            await state.setFailure(failure: failure)
+
+            for waiters in await state.waiters {
+                waiters.resume(throwing: failure)
+            }
+
+            await state.removeAllWaiters()
+
+            return false
+        }
+
+        return true
+    }
+
+    var value: Success {
+        get async throws {
+            try await withCheckedThrowingContinuation { continuation in
+                Task {
+                    if let result = await state.result {
+                        continuation.resume(returning: result)
+                    } else if let failure = await self.state.failure {
+                        continuation.resume(throwing: failure)
+                    } else {
+                        await state.appendWaiters(waiters: continuation)
+                    }
+                }
+            }
+        }
+    }
+}

Sources/DataLoader/Channel/State.swift

@@ -0,0 +1,25 @@
+typealias Waiter<Success, Failure> = CheckedContinuation<Success, Error>
+
+actor State<Success, Failure> {
+    var waiters = [Waiter<Success, Failure>]()
+    var result: Success?
+    var failure: Failure?
+}
+
+extension State {
+    func setResult(result: Success) {
+        self.result = result
+    }
+
+    func setFailure(failure: Failure) {
+        self.failure = failure
+    }
+
+    func appendWaiters(waiters: Waiter<Success, Failure>...) {
+        self.waiters.append(contentsOf: waiters)
+    }
+
+    func removeAllWaiters() {
+        waiters.removeAll()
+    }
+}

Sources/DataLoader/DataLoader.swift

@@ -1,28 +1,11 @@
 import Algorithms
-import AsyncAlgorithms
 import AsyncCollections
 
 public enum DataLoaderValue<T: Sendable>: Sendable {
     case success(T)
     case failure(Error)
 }
 
-actor Concurrent<T> {
-    var wrappedValue: T
-
-    func nonmutating<Returned>(_ action: (T) throws -> Returned) async rethrows -> Returned {
-        try action(wrappedValue)
-    }
-
-    func mutating<Returned>(_ action: (inout T) throws -> Returned) async rethrows -> Returned {
-        try action(&wrappedValue)
-    }
-
-    init(_ value: T) {
-        wrappedValue = value
-    }
-}
-
 public typealias BatchLoadFunction<Key: Hashable & Sendable, Value: Sendable> = @Sendable (_ keys: [Key]) async throws -> [DataLoaderValue<Value>]
 private typealias LoaderQueue<Key: Hashable & Sendable, Value: Sendable> = [(key: Key, channel: Channel<Value, Error>)]
 
@@ -63,30 +46,34 @@ public actor DataLoader<Key: Hashable & Sendable, Value: Sendable> {
 
         if options.batchingEnabled {
             queue.append((key: key, channel: channel))
+
             if let executionPeriod = options.executionPeriod, !dispatchScheduled {
                 Task.detached {
                     try await Task.sleep(nanoseconds: executionPeriod)
                     try await self.execute()
                 }
+
                 dispatchScheduled = true
             }
         } else {
             Task.detached {
                 do {
                     let results = try await self.batchLoadFunction([key])
+
                     if results.isEmpty {
-                        await channel.fail(with: DataLoaderError.noValueForKey("Did not return value for key: \(key)"))
+                        await channel.fail(DataLoaderError.noValueForKey("Did not return value for key: \(key)"))
                     } else {
                         let result = results[0]
+
                         switch result {
                         case let .success(value):
-                            await channel.fulfill(with: value)
+                            await channel.fulfill(value)
                         case let .failure(error):
-                                await channel.fail(with: error)
+                            await channel.fail(error)
                         }
                     }
                 } catch {
-                    await channel.fail(with: error)
+                    await channel.fail(error)
                 }
             }
         }
@@ -116,22 +103,23 @@ public actor DataLoader<Key: Hashable & Sendable, Value: Sendable> {
     /// ```swift
     /// async let a = myLoader.load(key: "a")
     /// async let b = myLoader.load(key: "b")
-    /// let aAndB = try await a + b
     /// ```
     public func loadMany(keys: [Key]) async throws -> [Value] {
         guard !keys.isEmpty else {
             return []
         }
-        let futures = try await keys.concurrentMap { try await self.load(key: $0) }
-        return futures
+
+        return try await keys.concurrentMap { try await self.load(key: $0) }
     }
 
     /// Clears the value at `key` from the cache, if it exists. Returns itself for
     /// method chaining.
     @discardableResult
     public func clear(key: Key) -> DataLoader<Key, Value> {
         let cacheKey = options.cacheKeyFunction?(key) ?? key
+
         cache.removeValue(forKey: cacheKey)
+
         return self
     }
 
@@ -141,6 +129,7 @@ public actor DataLoader<Key: Hashable & Sendable, Value: Sendable> {
     @discardableResult
     public func clearAll() -> DataLoader<Key, Value> {
         cache.removeAll()
+
         return self
     }
 
@@ -152,8 +141,9 @@ public actor DataLoader<Key: Hashable & Sendable, Value: Sendable> {
 
         if cache[cacheKey] == nil {
             let channel = Channel<Value, Error>()
+
             Task.detached {
-                await channel.fulfill(with: value)
+                await channel.fulfill(value)
             }
 
             cache[cacheKey] = channel
@@ -165,7 +155,9 @@ public actor DataLoader<Key: Hashable & Sendable, Value: Sendable> {
     public func execute() async throws {
         // Take the current loader queue, replacing it with an empty queue.
         let batch = queue
+
         queue = []
+
         if dispatchScheduled {
             dispatchScheduled = false
         }
@@ -196,6 +188,7 @@ public actor DataLoader<Key: Hashable & Sendable, Value: Sendable> {
         // loaded queue.
         do {
             let values = try await batchLoadFunction(keys)
+
             if values.count != keys.count {
                 throw DataLoaderError.typeError("The function did not return an array of the same length as the array of keys. \nKeys count: \(keys.count)\nValues count: \(values.count)")
             }
@@ -205,9 +198,9 @@ public actor DataLoader<Key: Hashable & Sendable, Value: Sendable> {
 
                 switch result {
                 case let .failure(error):
-                        await entry.element.channel.fail(with: error)
+                    await entry.element.channel.fail(error)
                 case let .success(value):
-                    await entry.element.channel.fulfill(with: value)
+                    await entry.element.channel.fulfill(value)
                 }
             }
         } catch {
@@ -218,85 +211,8 @@ public actor DataLoader<Key: Hashable & Sendable, Value: Sendable> {
     private func failedExecution(batch: LoaderQueue<Key, Value>, error: Error) async {
         for (key, channel) in batch {
             _ = clear(key: key)
-            await channel.fail(with: error)
-        }
-    }
-}
-
-public actor Channel<Success: Sendable, Failure: Error>: Sendable {
-    typealias Waiter = CheckedContinuation<Success, Error>
-
-    private actor State {
-        var waiters = [Waiter]()
-        var result: Success? = nil
-        var failure: Failure? = nil
-
-        func setResult(result: Success) {
-            self.result = result
-        }
 
-        func setFailure(failure: Failure) {
-            self.failure = failure
+            await channel.fail(error)
         }
-
-        func appendWaiters(waiters: Waiter...) {
-            self.waiters.append(contentsOf: waiters)
-        }
-
-        func removeAllWaiters() {
-            self.waiters.removeAll()
-        }
-    }
-
-    private var state = State()
-
-    public init(_ elementType: Success.Type = Success.self) {}
-
-    @discardableResult
-    public func fulfill(with value: Success) async -> Bool {
-            if await state.result == nil {
-                await state.setResult(result:value)
-                for waiters in await state.waiters {
-                    waiters.resume(returning: value)
-                }
-                await state.removeAllWaiters()
-                return false
-            }
-        return true
-    }
-
-    @discardableResult
-    public func fail(with failure: Failure) async -> Bool {
-            if await state.failure == nil {
-                await state.setFailure(failure: failure)
-                for waiters in await state.waiters {
-                    waiters.resume(throwing: failure)
-                }
-                await state.removeAllWaiters()
-                return false
-            }
-        return true
-    }
-
-    public var value: Success {
-        get async throws {
-            try await withCheckedThrowingContinuation { continuation in
-                Task {
-                    if let result = await state.result {
-                        continuation.resume(returning: result)
-                    } else if let failure = await self.state.failure {
-                        continuation.resume(throwing: failure)
-                    } else {
-                        await state.appendWaiters(waiters: continuation)
-                    }
-                }
-            }
-        }
-    }
-}
-
-extension Channel where Success == Void {
-    func fulfill() async -> Bool {
-        return await fulfill(with: ())
     }
 }

Tests/DataLoaderTests/DataLoaderAbuseTests.swift

@@ -25,7 +25,6 @@ class DataLoaderAbuseTests: XCTestCase {
     }
 
     func testBatchFuntionMustPromiseAnArrayOfCorrectLength() async {
-
         let identityLoader = DataLoader<Int, Int>() { _ in
             []
         }
@@ -95,7 +94,7 @@ class DataLoaderAbuseTests: XCTestCase {
 
         async let value1 = identityLoader.load(key: 1)
         async let value2 = identityLoader.load(key: 2)
-        
+
         var didFailWithError: Error?
 
         do {