Feature adapt swift6

.swiftpm/xcode/xcshareddata/xcschemes/Tetra.xcscheme

@@ -38,6 +38,15 @@
                ReferencedContainer = "container:">
             </BuildableReference>
          </TestableReference>
+         <TestableReference
+            skipped = "NO">
+            <BuildableReference
+               BuildableIdentifier = "primary"
+               BlueprintIdentifier = "TetraRunLoopConcurrencyTests"
+               BuildableName = "TetraRunLoopConcurrencyTests"
+               ReferencedContainer = "container:">
+            </BuildableReference>
+         </TestableReference>
       </Testables>
    </TestAction>
    <LaunchAction

Package.swift

@@ -1,4 +1,4 @@
-// swift-tools-version: 5.9
+// swift-tools-version: 6.2
 // The swift-tools-version declares the minimum version of Swift required to build this package.
 
 import PackageDescription
@@ -18,28 +18,145 @@ let package = Package(
         .library(
             name: "Tetra",
             targets: ["Tetra"]
-        )
+        ),
+    ],
+    // Opt-in trait for the SchedulingExecutor / RunLoopExecutor / MainExecutor SPI
+    // conformances in `TetraRunLoopConcurrency`. Those protocols are only nameable on a
+    // toolchain whose stdlib exposes them (a development snapshot); the release/standard
+    // stdlib does not (`cannot find type 'SchedulingExecutor'`), and no `#if compiler(>=x)`
+    // can tell the two apart. NOT in the default set → OFF by default, so release/standard
+    // toolchains build cleanly. Enable with `swift build --traits SchedulingExecutorSPI` on
+    // a toolchain that exposes the SPI; an enabled trait becomes the `#if SchedulingExecutorSPI`
+    // compilation condition.
+    traits: [
+        .trait(
+            name: "SchedulingExecutorSPI",
+            description: "Conform StackBoundRunLoopExecutor to the SchedulingExecutor/RunLoopExecutor/MainExecutor _Concurrency SPI protocols (only compilable where the stdlib exposes them)."
+        ),
     ],
     dependencies: [
         // Dependencies declare other packages that this package depends on.
         // .package(url: /* package url */, from: "1.0.0"),
+        .package(
+            url: "https://github.com/apple/swift-collections.git",
+                .upToNextMajor(from: "1.3.0"),
+            traits: [
+                .defaults,
+//                .trait(name: "UnstableContainersPreview")
+            ],
+        ),
+        .package(
+            url: "https://github.com/apple/swift-atomics.git",
+            .upToNextMajor(from: "1.3.0"),
+            traits: [.defaults],
+        ),
+        .package(url: "https://github.com/apple/swift-async-algorithms", from: "1.1.5"),
+
     ],
     targets: [
         // Targets are the basic building blocks of a package. A target can define a module or a test suite.
         // Targets can depend on other targets in this package, and on products in packages this package depends on.
+        .target(
+            name: "Namespace",
+            swiftSettings: [
+                .swiftLanguageMode(.v6)
+            ]
+        ),
+        .target(
+            name: "NamespaceExtension",
+            dependencies: [
+                "Namespace",
+            ],
+            swiftSettings: [
+                .swiftLanguageMode(.v6)
+            ]
+        ),
+        .target(
+            name: "CriticalSection",
+            dependencies: [
+                .product(name: "Atomics", package: "swift-atomics"),
+
+            ],
+            swiftSettings: [
+                .swiftLanguageMode(.v6),
+                .enableExperimentalFeature("StaticExclusiveOnly"),
+                .enableExperimentalFeature("RawLayout"),
+                .enableExperimentalFeature("BuiltinModule"),
+                .enableExperimentalFeature("Lifetimes"),
+                .enableExperimentalFeature("LifetimeDependence"),
+            ]
+        ),
+        .target(
+            name: "BackportDiscardingTaskGroup",
+            dependencies: [
+                "Namespace",
+                "CriticalSection",
+            ],
+            swiftSettings: [
+                .enableUpcomingFeature("FullTypedThrows"),
+                .enableExperimentalFeature("IsolatedAny"),
+                .swiftLanguageMode(.v6)
+            ]
+        ),
         .target(
             name: "Tetra",
-            dependencies: [],
+            dependencies: [
+                .product(name: "DequeModule", package: "swift-collections"),
+                .product(name: "HeapModule", package: "swift-collections"),
+
+                "BackPortAsyncSequence",
+                "CriticalSection",
+                "BackportDiscardingTaskGroup",
+                "Namespace",
+                "NamespaceExtension", "TetraRunLoopConcurrency",
+                .product(name: "AsyncAlgorithms", package: "swift-async-algorithms"),
+            ],
+            swiftSettings: [
+                .enableUpcomingFeature("FullTypedThrows"),
+                .enableExperimentalFeature("IsolatedAny"),
+                .swiftLanguageMode(.v6)
+            ]
+        ),
+
+        .target(
+            name: "TetraRunLoopConcurrency",
+            dependencies: [
+                "CriticalSection",
+                .product(name: "Atomics", package: "swift-atomics"),
+                .product(name: "HeapModule", package: "swift-collections"),
+                .product(name: "BasicContainers", package: "swift-collections"),
+                .product(name: "ContainersPreview", package:  "swift-collections"),
+            ],
             swiftSettings: [
-                .enableExperimentalFeature("StrictConcurrency=complete"),
+                .swiftLanguageMode(.v6),
+                .enableExperimentalFeature("BuiltinModule"),
+            ]
+        ),
+        .target(
+            name: "BackPortAsyncSequence",
+            dependencies: [ "Namespace"],
+            swiftSettings: [
+                .swiftLanguageMode(.v6),
             ]
         ),
         .testTarget(
             name: "TetraTests",
             dependencies: [
                 "Tetra"
             ],
-            resources: [.process("Resources")]
-        )
-    ]
+            resources: [.process("Resources")],
+            swiftSettings: [
+                .swiftLanguageMode(.v5)
+            ]
+        ),
+        .testTarget(
+            name: "TetraRunLoopConcurrencyTests",
+            dependencies: ["TetraRunLoopConcurrency"],
+            swiftSettings: [
+                .swiftLanguageMode(.v6),
+                .unsafeFlags(["-Xfrontend", "-disable-availability-checking"]),
+
+            ]
+        ),
+    ],
 )

README.md

@@ -71,13 +71,16 @@ import Combine
 
         let cancellable = (0..<20).publisher
             .setFailureType(to: URLError.self)
-            .multiMapTask(maxTasks: .unlimited) { _ in
+            .multiMapTask(maxTasks: .unlimited) { _ throws(URLError) in
+
                 // Underlying Task is cancelled if subscription is cancelled before task completes.
                 do {
                     let (data, response) = try await URLSession.shared.data(from: URL(string: "https://google.com")!)
-                    return .success(data) as Result<Data,URLError>
+                    // below unsafe cancel is no-op, throw appropriate error to interrupt combine pipeline
+                    // withUnsafeCurrentTask { $0?.cancel() }
+                    return data
                 } catch {
-                    return .failure(error as! URLError) as Result<Data,URLError>
+                    throw (error as! URLError)
                 }
             }.sink { completion in
 
@@ -101,8 +104,7 @@ import Tetra
             continuation.yield(1)
             continuation.finish()
             // Underlying AsyncIterator and Task receive task cancellation if subscription is cancelled.
-        }.tetra.publisher
-            .catch{ _ in Empty().setFailureType(to: Never.self) }
+        }.tetra.bridge.tetra.publisher
             .sink { number in
 
             }
@@ -188,3 +190,38 @@ struct ContentView: View {
 - more fine grained way to introduce extension methods (maybe something like `.af` in Alamofire?)
 
 - remove all `AsyncTypedSequence` and `WrappedAsyncSequence` dummy protocol when `FullTypedThrow` is implemented.
+
+## WIP
+
+[PriorityRunLoop](./Sources/Tetra/Concurrency/PriorityRunLoop.swift)
+
+TaskPriority aware NSRunLoop based `Concurrency Serial Executor`.
+
+Can be useful for old Apple Framework that does not support `libDispatch` and only support `CFRunLoop` like `CoreLocation`, `perform(_:on:with:waitUntilDone:)`
+
+Reorder the jobs in Priority Order, and increase QoS level, according to the TaskPriority.
+
+
+[AsyncFlatMap](./Sources/Tetra/Combine/Publishers+AsyncFlatMap.swift)
+
+Combine operator which convert the Upstream to AsyncSequence and transfer the elements to the downstream.
+
+uses actor based cooperative control to minimize contention.
+
+Investingating for a way to backport rich asyncSequence features before Swift 6 platform.
+
+
+[BackportDiscardingTaskGroup](./Sources/BackportDiscardingTaskGroup/ThrowingTaskGroup.swift)
+
+Backport the behavior of `Discarding(Throwing)TaskGroup`. This now possbile thanks to Swift 6 generalized AsyncSequnce. Because we can wrap the `TaskGroup` into isolation.
+
+Investingating for a way to merge it with existing `Discarding(Throwing)TaskGroup` using some kind of opaque types rather than erased types.
+
+Investigating a way to merge NonFailure type and Failing type using typedThrow, which is currently not possible due to Swift 6 compiler bug.
+
+
+[MemorySafe Data/String](./Sources/Tetra/Foundation/PruneMemory.swift)
+
+`Data` and `String` which erase its memory footprints when deallocated. implemented by `CoreFoundation` API.
+
+Still can not erase memory footprints caused by Swift Briding copy and os level memory paging.