Feature adapt swift6

Package.resolved

@@ -0,0 +1,24 @@
+{
+  "originHash" : "2fc989cc1b67d91eb25b0319fdf3b974c0dd91e42699a64bf0c693dd7dde9fab",
+  "pins" : [
+    {
+      "identity" : "swift-atomics",
+      "kind" : "remoteSourceControl",
+      "location" : "https://github.com/apple/swift-atomics.git",
+      "state" : {
+        "revision" : "cd142fd2f64be2100422d658e7411e39489da985",
+        "version" : "1.2.0"
+      }
+    },
+    {
+      "identity" : "swift-collections",
+      "kind" : "remoteSourceControl",
+      "location" : "https://github.com/apple/swift-collections.git",
+      "state" : {
+        "revision" : "94cf62b3ba8d4bed62680a282d4c25f9c63c2efb",
+        "version" : "1.1.0"
+      }
+    }
+  ],
+  "version" : 3
+}

Package.swift

@@ -1,4 +1,4 @@
-// swift-tools-version: 5.9
+// swift-tools-version: 6.0
 // The swift-tools-version declares the minimum version of Swift required to build this package.
 
 import PackageDescription
@@ -18,28 +18,111 @@ let package = Package(
         .library(
             name: "Tetra",
             targets: ["Tetra"]
-        )
+        ),
     ],
     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.1.0")),
+        .package(
+            url: "https://github.com/apple/swift-atomics.git",
+            .upToNextMajor(from: "1.2.0") // or `.upToNextMinor
+        ),
+
     ],
     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"),
+            ]
+        ),
+        .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"
+            ],
+            swiftSettings: [
+                .enableUpcomingFeature("FullTypedThrows"),
+                .enableExperimentalFeature("IsolatedAny"),
+                .swiftLanguageMode(.v6)
+            ]
+        ),
+        .target(
+            name: "TetraConcurrentQueueShim",
+            linkerSettings: [
+                .linkedFramework("CoreFoundation")
+            ]
+        ),
+        .target(
+            name: "TetraRunLoopConcurrency",
+            dependencies: [
+                "TetraConcurrentQueueShim",
+            ],
             swiftSettings: [
-                .enableExperimentalFeature("StrictConcurrency=complete"),
+                .swiftLanguageMode(.v6)
+            ]
+        ),
+        .target(
+            name: "BackPortAsyncSequence",
+            dependencies: [ "Namespace"],
+            swiftSettings: [
+                .swiftLanguageMode(.v6),
             ]
         ),
         .testTarget(
             name: "TetraTests",
             dependencies: [
                 "Tetra"
             ],
-            resources: [.process("Resources")]
+            resources: [.process("Resources")],
+            swiftSettings: [
+                .swiftLanguageMode(.v5)
+            ]
         )
-    ]
+    ],
+    cxxLanguageStandard: .cxx17
 )

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.

Sources/BackPortAsyncSequence/AsyncCompactMapSequence.swift

@@ -0,0 +1,146 @@
+//
+//  AsyncCompactMapSequence.swift
+//
+//
+//  Created by 박병관 on 6/13/24.
+//
+
+
+extension BackPort {
+
+
+    public struct AsyncCompactMapSequence<Base: AsyncSequence, ElementOfResult> where Base.AsyncIterator: TypedAsyncIteratorProtocol {
+
+        @usableFromInline
+        let base: Base
+
+        @usableFromInline
+        let transform: (Base.Element) async throws(Failure) -> ElementOfResult?
+
+        @inlinable
+        package init(
+            _ base: Base,
+            transform: @escaping (Base.Element) async throws(Failure) -> ElementOfResult?
+        ) {
+            self.base = base
+            self.transform = transform
+        }
+    }
+
+
+}
+
+extension BackPort.AsyncCompactMapSequence: AsyncSequence, TypedAsyncSequence {
+
+    /// The type of element produced by this asynchronous sequence.
+    ///
+    /// The compact map sequence produces errors from either the base
+    /// sequence or the transforming closure.
+    public typealias Failure = AsyncIterator.Failure
+    /// The type of iterator that produces elements of the sequence.
+    public typealias AsyncIterator = Iterator
+
+    /// The iterator that produces elements of the compact map sequence.
+    public struct Iterator {
+
+
+        @usableFromInline
+        var baseIterator: Base.AsyncIterator
+
+        @usableFromInline
+        let transform: (Base.Element) async throws(Failure) -> ElementOfResult?
+
+        @usableFromInline
+        var finished = false
+
+        @usableFromInline
+        init(
+            _ baseIterator: Base.AsyncIterator,
+            transform: @escaping (Base.Element) async throws(Failure) -> ElementOfResult?
+        ) {
+            self.baseIterator = baseIterator
+            self.transform = transform
+        }
+
+
+    }
+
+    @inlinable
+    public __consuming func makeAsyncIterator() -> Iterator {
+        return Iterator(base.makeAsyncIterator(), transform: transform)
+    }
+}
+
+
+extension BackPort.AsyncCompactMapSequence.Iterator: AsyncIteratorProtocol, TypedAsyncIteratorProtocol {
+
+    public typealias Element = ElementOfResult
+    public typealias Failure = Base.AsyncIterator.Err
+
+    /// Produces the next element in the compact map sequence.
+    ///
+    /// This iterator calls `next()` on its base iterator; if this call
+    /// returns `nil`, `next()` returns `nil`. Otherwise, `next()`
+    /// calls the transforming closure on the received element, returning it if
+    /// the transform returns a non-`nil` value. If the transform returns `nil`,
+    /// this method continues to wait for further elements until it gets one
+    /// that transforms to a non-`nil` value. If calling the closure throws an
+    /// error, the sequence ends and `next()` rethrows the error.
+    @inlinable
+    public mutating func next(isolation actor: isolated (any Actor)? = #isolation) async throws(Failure) -> Element? {
+        while !finished {
+            guard let element = try await baseIterator.next(isolation: actor) else {
+                finished = true
+                return nil
+            }
+            let wrapper: (Base.Element) async -> Result<Suppress<Element?>, Failure> = { [transform] in
+                do throws(Base.AsyncIterator.Err) {
+                    let value = try await Suppress(base: transform($0))
+                    return .success(value)
+                } catch {
+                    return .failure(error)
+                }
+            }
+            do throws(Failure) {
+                if let transformed = try await wrapper(Suppress(base: element).base).get().base {
+                    return transformed
+                }
+            } catch {
+                finished = true
+                throw error
+            }
+        }
+        return nil
+    }
+
+    @_disfavoredOverload
+    @inlinable
+    public mutating func next() async throws(Failure) -> Element? {
+        try await next(isolation: nil)
+    }
+
+}
+
+extension BackPort.AsyncCompactMapSequence: @unchecked Sendable
+where Base: Sendable,
+      Base.Element: Sendable { }
+
+
+
+extension BackPort.AsyncCompactMapSequence.Iterator: @unchecked Sendable
+where Base.AsyncIterator: Sendable,
+      Base.Element: Sendable { }
+
+
+extension BackPort.AsyncCompactMapSequence {
+
+    @inlinable
+    package init <Source:AsyncSequence, Failure:Error>(
+        _ source: Source,
+        transform: @escaping (Base.Element) async throws(Failure) -> ElementOfResult?
+    ) where Source.AsyncIterator: TypedAsyncIteratorProtocol, Source.AsyncIterator.Err == Never, Base == AsyncMapErrorSequence<Source, Failure> {
+        let base = AsyncMapErrorSequence(base: source, failure: Failure.self)
+        self.init(base, transform: transform)
+    }
+
+}