Merge pull request #10 from mtj0928/fix-ci

Fix CI Settings

Author: mtj0928

.github/workflows/test.yml

@@ -11,7 +11,6 @@ jobs:
     strategy:
       matrix:
         swift_version:
-          - "5.10"
           - "6.0"
           - "6.1"
           - "6.2"
@@ -27,7 +26,7 @@ jobs:
     - name: Add Swiftly to PATH
       run: echo "${HOME}/.swiftly/bin" >> "${GITHUB_PATH}"
     - name: Install Swift
-      run: ~/.swiftly/bin/swiftly install ${{ matrix.swift_version }}
+      run: ~/.swiftly/bin/swiftly install --use ${{ matrix.swift_version }}
     - name: Get swift version
       run: swift --version
     - uses: actions/checkout@v4

Package@swift-5.10.swift

@@ -172,7 +172,7 @@ print(results) // 😁 [0, 2, 4, 6, 8, 10]
 ```
 
 ## Requirements
-Swift 5.10 or later.
+Swift 6.0 or later.
 
 ## Installation
 You can install the library via Swift Package Manager.

README.md

@@ -1,4 +1,3 @@
-#if compiler(>=6.0)
 /// A wrapper function of `withTaskGroup`.
 ///
 /// The main difference with `withTaskGroup` is that the group's next function returns the results in the order the tasks were added.
@@ -30,18 +29,6 @@ public func withOrderedTaskGroup<ChildTaskResult: Sendable, GroupResult>(
         return await body(&orderedTaskGroup)
     }
 }
-#else
-public func withOrderedTaskGroup<ChildTaskResult: Sendable, GroupResult>(
-    of childTaskResultType: ChildTaskResult.Type,
-    returning returnType: GroupResult.Type = GroupResult.self,
-    body: (inout OrderedTaskGroup<ChildTaskResult>) async -> GroupResult
-) async -> GroupResult {
-    await withTaskGroup(of: (Index, ChildTaskResult).self, returning: returnType) { group in
-        var orderedTaskGroup = OrderedTaskGroup<ChildTaskResult>(group)
-        return await body(&orderedTaskGroup)
-    }
-}
-#endif
 
 public struct OrderedTaskGroup<ChildTaskResult: Sendable> {
     private var internalGroup: TaskGroup<(Index, ChildTaskResult)>
@@ -53,7 +40,6 @@ public struct OrderedTaskGroup<ChildTaskResult: Sendable> {
         self.internalGroup = internalGroup
     }
 
-#if compiler(>=6.0)
     public mutating func addTask(
         priority: TaskPriority? = nil,
         operation: sending @escaping @isolated(any) () async -> ChildTaskResult
@@ -65,19 +51,6 @@ public struct OrderedTaskGroup<ChildTaskResult: Sendable> {
         }
         addedTaskIndex = addedTaskIndex.next()
     }
-#else
-    public mutating func addTask(
-        priority: TaskPriority? = nil,
-        operation: @escaping @Sendable () async -> ChildTaskResult
-    ) {
-        let currentIndex = addedTaskIndex
-        internalGroup.addTask(priority: priority) {
-            let result = await operation()
-            return (currentIndex, result)
-        }
-        addedTaskIndex = addedTaskIndex.next()
-    }
-#endif
 
     public mutating func waitForAll() async {
         await internalGroup.waitForAll()

Sources/AsyncOperations/withOrderedTaskGroup.swift

@@ -1,4 +1,3 @@
-#if compiler(>=6.0)
 /// A wrapper function of `withThrowingTaskGroup`.
 ///
 /// The main difference with `withThrowingTaskGroup` is that the group's next function returns the results in the order the tasks were added.
@@ -36,21 +35,6 @@ public func withThrowingOrderedTaskGroup<ChildTaskResult: Sendable, GroupResult>
         return try await body(&throwingOrderedTaskGroup)
     }
 }
-#else
-public func withThrowingOrderedTaskGroup<ChildTaskResult: Sendable, GroupResult>(
-    of childTaskResultType: ChildTaskResult.Type,
-    returning returnType: GroupResult.Type = GroupResult.self,
-    body: (inout ThrowingOrderedTaskGroup<ChildTaskResult, any Error>) async throws -> GroupResult
-) async rethrows -> GroupResult {
-    try await withThrowingTaskGroup(
-        of: (Index, ChildTaskResult).self,
-        returning: GroupResult.self
-    ) { group in
-        var throwingOrderedTaskGroup = ThrowingOrderedTaskGroup<ChildTaskResult, any Error>(group)
-        return try await body(&throwingOrderedTaskGroup)
-    }
-}
-#endif
 
 public struct ThrowingOrderedTaskGroup<ChildTaskResult: Sendable, Failure: Error> {
     private var internalGroup: ThrowingTaskGroup<(Index, ChildTaskResult), Failure>
@@ -62,7 +46,6 @@ public struct ThrowingOrderedTaskGroup<ChildTaskResult: Sendable, Failure: Error
         self.internalGroup = internalGroup
     }
 
-#if compiler(>=6.0)
     public mutating func addTask(
         priority: TaskPriority? = nil,
         operation: sending @escaping @isolated(any) () async throws(Failure) -> ChildTaskResult
@@ -78,23 +61,6 @@ public struct ThrowingOrderedTaskGroup<ChildTaskResult: Sendable, Failure: Error
         }
         addedTaskIndex = addedTaskIndex.next()
     }
-#else
-    public mutating func addTask(
-        priority: TaskPriority? = nil,
-        operation: @escaping @Sendable () async throws -> ChildTaskResult
-    ) {
-        let currentIndex = addedTaskIndex
-        internalGroup.addTask(priority: priority) {
-            do {
-                let result = try await operation()
-                return (currentIndex, result)
-            } catch {
-                throw InternalError(index: currentIndex, rawError: error)
-            }
-        }
-        addedTaskIndex = addedTaskIndex.next()
-    }
-#endif
 
     public mutating func waitForAll() async throws {
         do {

Sources/AsyncOperations/withThrowingOrderedTaskGroup.swift

@@ -1,9 +1,11 @@
 import AsyncOperations
-import XCTest
+import Testing
 
-final class AsyncSequenceAsyncForEachTests: XCTestCase {
+struct AsyncSequenceAsyncForEachTests {
+
+    @Test
     @MainActor
-    func testAsyncForEach() async throws {
+    func asyncForEach() async throws {
         var results: [Int] = []
         var events: [ConcurrentTaskEvent] = []
 
@@ -18,8 +20,8 @@ final class AsyncSequenceAsyncForEachTests: XCTestCase {
             events.append(.end)
             results.append(number)
         }
-        XCTAssertEqual(results.count, 5)
-        XCTAssertEqual(Set(results), [0, 1, 2, 3, 4])
-        XCTAssertEqual(events, [.start, .start, .start, .end, .start, .end, .start, .end, .end, .end])
+        #expect(results.count == 5)
+        #expect(Set(results) == [0, 1, 2, 3, 4])
+        #expect(events == [.start, .start, .start, .end, .start, .end, .start, .end, .end, .end])
     }
 }

Tests/AsyncOperationsTests/AsyncSequence/AsyncSequenceAsyncForEachTests.swift

@@ -1,18 +1,19 @@
 import AsyncOperations
-import XCTest
+import Testing
 
-final class SequenceAsyncAllSatisfyTests: XCTestCase {
-    func testAsyncAllSatisfy() async throws {
+struct SequenceAsyncAllSatisfyTests {
+    @Test
+    func asyncAllSatisfy() async throws {
         let satisfiedResult = await [0, 1, 2, 3, 4].asyncAllSatisfy { number in
             await Task.yield()
             return number < 5
         }
-        XCTAssertTrue(satisfiedResult)
+        #expect(satisfiedResult)
 
         let unsatisfiedResult = await [0, 1, 2, 3, 4].asyncAllSatisfy { number in
             await Task.yield()
             return number < 4
         }
-        XCTAssertFalse(unsatisfiedResult)
+        #expect(!unsatisfiedResult)
     }
 }

Tests/AsyncOperationsTests/Sequence/SequenceAsyncAllSatisfyTests.swift

@@ -1,14 +1,13 @@
 import AsyncOperations
-import XCTest
+import Testing
 
-
-final class SequenceAsyncCompactMapTests: XCTestCase {
-    func testAsyncCompactMapMultipleTasks() async throws {
+struct SequenceAsyncCompactMapTests {
+    @Test func asyncCompactMapMultipleTasks() async throws {
         let results = await [0, 1, 2, 3, 4].asyncCompactMap { number in
             await Task.yield()
             return number % 2 == 0 ? nil : number * 2
         }
 
-        XCTAssertEqual(results, [2, 6])
+        #expect(results == [2, 6])
     }
 }

Tests/AsyncOperationsTests/Sequence/SequenceAsyncCompactMapTests.swift

@@ -1,17 +1,19 @@
 import AsyncOperations
-import XCTest
+import Testing
 
-final class SequenceAsyncContainsTests: XCTestCase {
-    func testAsyncContains() async throws {
+struct SequenceAsyncContainsTests {
+
+    @Test
+    func asyncContains() async throws {
         let containsResult = await [1, 2, 3].asyncContains { number in
-            XCTAssertNotEqual(number, 3)
+            #expect(number != 3)
             return number == 2
         }
-        XCTAssertTrue(containsResult)
+        #expect(containsResult)
 
         let notContainsResult = await [1, 2, 3].asyncContains { number in
             return number == 4
         }
-        XCTAssertFalse(notContainsResult)
+        #expect(!notContainsResult)
     }
 }

Tests/AsyncOperationsTests/Sequence/SequenceAsyncContainsTests.swift

@@ -1,12 +1,14 @@
 import AsyncOperations
-import XCTest
+import Testing
 
-final class SequenceAsyncFilterTests: XCTestCase {
-    func testAsyncFilter() async throws {
+struct SequenceAsyncFilterTests {
+
+    @Test
+    func asyncFilter() async throws {
         let filteredNumbers = await [0, 1, 2, 3, 4].asyncFilter { number in
             await Task.yield()
             return number.isMultiple(of: 2)
         }
-        XCTAssertEqual(filteredNumbers, [0, 2, 4])
+        #expect(filteredNumbers == [0, 2, 4])
     }
 }