Add async map and filter to array (#10)

Author: 0xLeif

Sources/Fork/Extensions/Array+ForkedArray.swift

@@ -2,12 +2,39 @@ extension Array {
     /// Create a ``ForkedArray`` from the current `Array`
     public func fork<Output>(
         filter: @escaping (Element) async throws -> Bool = { _ in true },
-        output: @escaping (Element) async throws -> Output
+        map: @escaping (Element) async throws -> Output
     ) -> ForkedArray<Element, Output> {
         ForkedArray(
             self,
             filter: filter,
-            output: output
+            map: map
         )
     }
+    
+    /// Create a ``ForkedArray`` from the current `Array` and get the Output Array
+    public func forked<Output>(
+        filter: @escaping (Element) async throws -> Bool,
+        map: @escaping (Element) async throws -> Output
+    ) async throws -> [Output] {
+        try await ForkedArray(
+            self,
+            filter: filter,
+            map: map
+        )
+        .output()
+    }
+    
+    /// Returns an array containing the results of mapping the given closure over the sequence’s elements.
+    public func asyncMap<Output>(
+        _ transform: @escaping (Element) async throws -> Output
+    ) async throws -> [Output] {
+        try await fork(map: transform).output()
+    }
+    
+    /// Returns an array containing only the true results from the given closure over the sequence’s elements.
+    public func asyncFilter(
+        _ isIncluded: @escaping (Element) async throws -> Bool
+    ) async throws -> [Element] {
+        try await fork(filter: isIncluded, map: identity).output()
+    }
 }

Sources/Fork/ForkedArray.swift

@@ -7,7 +7,7 @@ public struct ForkedArray<Value, Output> {
     }
 
     private let filter: (Value) async throws -> Bool
-    private let output: (Value) async throws -> Output
+    private let map: (Value) async throws -> Output
     private let fork: Fork<ForkType, ForkType>
 
     /// The input array used to get the output
@@ -21,11 +21,11 @@ public struct ForkedArray<Value, Output> {
     public init(
         _ array: [Value],
         filter: @escaping (Value) async throws -> Bool = { _ in true },
-        output: @escaping (Value) async throws -> Output
+        map: @escaping (Value) async throws -> Output
     ) {
         self.array = array
         self.filter = filter
-        self.output = output
+        self.map = map
 
         switch ForkedArray.split(array: array) {
         case .none:
@@ -49,8 +49,8 @@ public struct ForkedArray<Value, Output> {
     public func output() async throws -> [Output] {
         try await fork.merged(
             using: { leftForkType, rightForkType in
-                async let leftOutput = try await ForkedArray.output(for: leftForkType, filter: filter, using: output)
-                async let rightOutput = try await ForkedArray.output(for: rightForkType, filter: filter, using: output)
+                async let leftOutput = try await ForkedArray.output(for: leftForkType, isIncluded: filter, transform: map)
+                async let rightOutput = try await ForkedArray.output(for: rightForkType, isIncluded: filter, transform: map)
 
                 return try await leftOutput + rightOutput
             }
@@ -95,23 +95,23 @@ extension ForkedArray {
 
     private static func output(
         for type: ForkType,
-        filter: @escaping (Value) async throws -> Bool,
-        using: @escaping (Value) async throws -> Output
+        isIncluded: @escaping (Value) async throws -> Bool,
+        transform: @escaping (Value) async throws -> Output
     ) async throws -> [Output] {
         switch type {
         case .none:
             return []
         case let .single(value):
-            guard try await filter(value) else { return [] }
+            guard try await isIncluded(value) else { return [] }
 
             try Task.checkCancellation()
 
-            return [try await using(value)]
+            return [try await transform(value)]
         case let .fork(fork):
             return try await fork.merged(
                 using: { leftType, rightType in
-                    async let leftOutput = try output(for: leftType, filter: filter, using: using)
-                    async let rightOutput = try output(for: rightType, filter: filter, using: using)
+                    async let leftOutput = try output(for: leftType, isIncluded: isIncluded, transform: transform)
+                    async let rightOutput = try output(for: rightType, isIncluded: isIncluded, transform: transform)
 
                     try Task.checkCancellation()
 

Tests/ForkTests/ForkedArrayTests.swift

@@ -7,51 +7,47 @@ class ForkedArrayTests: XCTestCase {
         @Sendable func downloadPhoto(named: String) async -> String { named }
         func show(_ photos: [String]) { }
 
-        let forkedArray = ForkedArray(photoNames, output: downloadPhoto(named:))
+        let forkedArray = ForkedArray(photoNames, map: downloadPhoto(named:))
         let photos = try await forkedArray.output()
 
         XCTAssertEqual(photos, photoNames)
     }
 
     func testForkedArray_one() async throws {
         let photoNames = ["one"]
-        @Sendable func downloadPhoto(named: String) async -> String { named }
-        func show(_ photos: [String]) { }
+        @Sendable func isValidPhoto(named: String) async -> Bool { true }
 
-        let forkedArray = ForkedArray(photoNames, output: downloadPhoto(named:))
-        let photos = try await forkedArray.output()
+        let photos = try await photoNames.asyncFilter(isValidPhoto(named:))
 
         XCTAssertEqual(photos, photoNames)
     }
 
     func testForkedArray_two() async throws {
         let photoNames = ["one", "two"]
         @Sendable func downloadPhoto(named: String) async -> String { named }
-        func show(_ photos: [String]) { }
 
-        let forkedArray = ForkedArray(photoNames, output: downloadPhoto(named:))
-        let photos = try await forkedArray.output()
+        let photos = try await photoNames.forked(
+            filter: { _ in true },
+            map: downloadPhoto(named:)
+        )
 
         XCTAssertEqual(photos, photoNames)
     }
 
     func testForkedArray_three() async throws {
         let photoNames = ["one", "two", "three"]
         @Sendable func downloadPhoto(named: String) async -> String { named }
-        func show(_ photos: [String]) { }
 
-        let forkedArray = ForkedArray(photoNames, output: downloadPhoto(named:))
-        let photos = try await forkedArray.output()
+        let photos = try await photoNames.asyncMap(downloadPhoto(named:))
 
         XCTAssertEqual(photos, photoNames)
     }
 
     func testForkedArray_x() async throws {
         let photoNames = (0 ... Int.random(in: 3 ..< 100)).map(\.description)
         @Sendable func downloadPhoto(named: String) async -> String { named }
-        func show(_ photos: [String]) { }
 
-        let forkedArray = photoNames.fork(output: downloadPhoto(named:))
+        let forkedArray = photoNames.fork(map: downloadPhoto(named:))
         let photos = try await forkedArray.output()
 
         XCTAssertEqual(photos, photoNames)