Add support for coroutine parameters

KMPNativeCoroutinesAsync/AnyAsyncSequence.swift

@@ -0,0 +1,35 @@
+//
+//  AnyAsyncSequence.swift
+//  KMPNativeCoroutinesAsync
+//
+//  Created by Rick Clephas on 02/09/2023.
+//
+
+/// An `AsyncSequence` that performs type erasure by wrapping another `AsyncSequence`.
+public struct AnyAsyncSequence<Element>: AsyncSequence {
+    public typealias Element = Element
+    public typealias AsyncIterator = Iterator
+
+    public struct Iterator: AsyncIteratorProtocol {
+
+        private var base: any AsyncIteratorProtocol
+
+        internal init<I: AsyncIteratorProtocol>(_ base: I) where I.Element == Element {
+            self.base = base
+        }
+
+        public mutating func next() async throws -> Element? {
+            return try await base.next() as! Element?
+        }
+    }
+
+    private let _makeAsyncIterator: () -> Iterator
+
+    internal init<S: AsyncSequence>(_ base: S) where S.Element == Element {
+        _makeAsyncIterator = { Iterator(base.makeAsyncIterator()) }
+    }
+
+    public func makeAsyncIterator() -> Iterator {
+        return _makeAsyncIterator()
+    }
+}

KMPNativeCoroutinesAsync/AsyncError.swift

@@ -10,8 +10,8 @@ import KMPNativeCoroutinesCore
 /// Awaits the `NativeSuspend` and returns the optional error.
 /// - Parameter nativeSuspend: The native suspend function to await.
 /// - Returns: The `Error` from the `nativeSuspend`, or `nil`.
-public func asyncError<Unit, Failure: Error>(
-    for nativeSuspend: @escaping NativeSuspend<Unit, Failure, Unit>
+public func asyncError<Failure: Error>(
+    for nativeSuspend: @escaping NativeSuspend<NativeUnit?, Failure>
 ) async -> Error? {
     do {
         try await asyncFunction(for: nativeSuspend)

KMPNativeCoroutinesAsync/AsyncFunction.swift

@@ -8,36 +8,41 @@
 import Dispatch
 import KMPNativeCoroutinesCore
 
+internal let RETURN_TYPE_SWIFT_ASYNC = "swift-async"
+
 /// Wraps the `NativeSuspend` in an async function.
 /// - Parameter nativeSuspend: The native suspend function to await.
 /// - Returns: The result from the `nativeSuspend`.
 /// - Throws: Errors thrown by the `nativeSuspend`.
-public func asyncFunction<Result, Failure: Error, Unit>(
-    for nativeSuspend: @escaping NativeSuspend<Result, Failure, Unit>
+public func asyncFunction<Result, Failure: Error>(
+    for nativeSuspend: @escaping NativeSuspend<Result, Failure>
 ) async throws -> Result {
-    try await AsyncFunctionTask(nativeSuspend: nativeSuspend).awaitResult()
+    if let function = nativeSuspend(RETURN_TYPE_SWIFT_ASYNC, EmptyNativeCallback1, EmptyNativeCallback1, EmptyNativeCallback1)() {
+        return try await (function as! (@Sendable () async throws -> Result))()
+    }
+    return try await AsyncFunctionTask(nativeSuspend: nativeSuspend).awaitResult()
 }
 
 /// Wraps the `NativeSuspend` in an async function.
 /// - Parameter nativeSuspend: The native suspend function to await.
 /// - Throws: Errors thrown by the `nativeSuspend`.
-public func asyncFunction<Unit, Failure: Error>(
-    for nativeSuspend: @escaping NativeSuspend<Unit, Failure, Unit>
+public func asyncFunction<Failure: Error>(
+    for nativeSuspend: @escaping NativeSuspend<NativeUnit?, Failure>
 ) async throws -> Void {
     _ = try await AsyncFunctionTask(nativeSuspend: nativeSuspend).awaitResult()
 }
 
-private class AsyncFunctionTask<Result, Failure: Error, Unit>: @unchecked Sendable {
+private class AsyncFunctionTask<Result, Failure: Error>: @unchecked Sendable {
 
     private let semaphore = DispatchSemaphore(value: 1)
-    private var nativeCancellable: NativeCancellable<Unit>?
+    private var nativeCancellable: NativeCancellable?
     private var result: Result? = nil
     private var error: Failure? = nil
     private var cancellationError: Failure? = nil
     private var continuation: UnsafeContinuation<Result, Error>? = nil
 
-    init(nativeSuspend: NativeSuspend<Result, Failure, Unit>) {
-        nativeCancellable = nativeSuspend({ result, unit in
+    init(nativeSuspend: NativeSuspend<Result, Failure>) {
+        nativeCancellable = nativeSuspend(nil, { result in
             self.semaphore.wait()
             defer { self.semaphore.signal() }
             self.result = result
@@ -46,8 +51,8 @@ private class AsyncFunctionTask<Result, Failure: Error, Unit>: @unchecked Sendab
                 self.continuation = nil
             }
             self.nativeCancellable = nil
-            return unit
-        }, { error, unit in
+            return nil
+        }, { error in
             self.semaphore.wait()
             defer { self.semaphore.signal() }
             self.error = error
@@ -56,8 +61,8 @@ private class AsyncFunctionTask<Result, Failure: Error, Unit>: @unchecked Sendab
                 self.continuation = nil
             }
             self.nativeCancellable = nil
-            return unit
-        }, { cancellationError, unit in
+            return nil
+        }, { cancellationError in
             self.semaphore.wait()
             defer { self.semaphore.signal() }
             self.cancellationError = cancellationError
@@ -66,7 +71,7 @@ private class AsyncFunctionTask<Result, Failure: Error, Unit>: @unchecked Sendab
                 self.continuation = nil
             }
             self.nativeCancellable = nil
-            return unit
+            return nil
         })
     }
 

KMPNativeCoroutinesAsync/AsyncResult.swift

@@ -10,8 +10,8 @@ import KMPNativeCoroutinesCore
 /// Awaits the `NativeSuspend` and returns the result.
 /// - Parameter nativeSuspend: The native suspend function to await.
 /// - Returns: The `Result` from the `nativeSuspend`.
-public func asyncResult<Output, Failure: Error, Unit>(
-    for nativeSuspend: @escaping NativeSuspend<Output, Failure, Unit>
+public func asyncResult<Output, Failure: Error>(
+    for nativeSuspend: @escaping NativeSuspend<Output, Failure>
 ) async -> Result<Output, Error> {
     do {
         return .success(try await asyncFunction(for: nativeSuspend))
@@ -23,8 +23,8 @@ public func asyncResult<Output, Failure: Error, Unit>(
 /// Awaits the `NativeSuspend` and returns the result.
 /// - Parameter nativeSuspend: The native suspend function to await.
 /// - Returns: The `Result` from the `nativeSuspend`.
-public func asyncResult<Unit, Failure: Error>(
-    for nativeSuspend: @escaping NativeSuspend<Unit, Failure, Unit>
+public func asyncResult<Failure: Error>(
+    for nativeSuspend: @escaping NativeSuspend<NativeUnit?, Failure>
 ) async -> Result<Void, Error> {
     do {
         return .success(try await asyncFunction(for: nativeSuspend))

KMPNativeCoroutinesAsync/AsyncSequence.swift

@@ -8,31 +8,38 @@
 import Dispatch
 import KMPNativeCoroutinesCore
 
-/// Wraps the `NativeFlow` in a `NativeFlowAsyncSequence`.
+internal let RETURN_TYPE_SWIFT_ASYNC_SEQUENCE = "swift-async-sequence"
+
+/// Wraps the `NativeFlow` in an `AsyncSequence`.
 /// - Parameter nativeFlow: The native flow to collect.
-/// - Returns: A `NativeFlowAsyncSequence` that yields the collected values.
-public func asyncSequence<Output, Failure: Error, Unit>(
-    for nativeFlow: @escaping NativeFlow<Output, Failure, Unit>
-) -> NativeFlowAsyncSequence<Output, Error, Unit> {
-    return NativeFlowAsyncSequence(nativeFlow: nativeFlow)
+/// - Returns: An `AsyncSequence` that yields the collected values.
+public func asyncSequence<Output, Failure: Error>(
+    for nativeFlow: @escaping NativeFlow<Output, Failure>
+) -> AnyAsyncSequence<Output> {
+    if let sequence = nativeFlow(RETURN_TYPE_SWIFT_ASYNC_SEQUENCE, EmptyNativeCallback2, EmptyNativeCallback1, EmptyNativeCallback1)() {
+        return sequence as! AnyAsyncSequence<Output>
+    }
+    return AnyAsyncSequence(NativeFlowAsyncSequence(nativeFlow: nativeFlow))
 }
 
-public struct NativeFlowAsyncSequence<Output, Failure: Error, Unit>: AsyncSequence {
+private struct NativeFlowAsyncSequence<Output, Failure: Error>: AsyncSequence {
+    typealias AsyncIterator = Iterator
+
     public typealias Element = Output
 
-    var nativeFlow: NativeFlow<Output, Failure, Unit>
+    var nativeFlow: NativeFlow<Output, Failure>
 
     public class Iterator: AsyncIteratorProtocol, @unchecked Sendable {
 
         private let semaphore = DispatchSemaphore(value: 1)
-        private var nativeCancellable: NativeCancellable<Unit>?
-        private var item: (Output, () -> Unit)? = nil
+        private var nativeCancellable: NativeCancellable?
+        private var item: (Output, NativeCallback)? = nil
         private var result: Failure?? = Optional.none
         private var cancellationError: Failure? = nil
         private var continuation: UnsafeContinuation<Output?, Error>? = nil
 
-        init(nativeFlow: NativeFlow<Output, Failure, Unit>) {
-            nativeCancellable = nativeFlow({ item, next, unit in
+        init(nativeFlow: NativeFlow<Output, Failure>) {
+            nativeCancellable = nativeFlow(nil, { item, next in
                 self.semaphore.wait()
                 defer { self.semaphore.signal() }
                 if let continuation = self.continuation {
@@ -41,9 +48,9 @@ public struct NativeFlowAsyncSequence<Output, Failure: Error, Unit>: AsyncSequen
                     return next()
                 } else {
                     self.item = (item, next)
-                    return unit
+                    return nil
                 }
-            }, { error, unit in
+            }, { error in
                 self.semaphore.wait()
                 defer { self.semaphore.signal() }
                 self.result = Optional.some(error)
@@ -56,8 +63,8 @@ public struct NativeFlowAsyncSequence<Output, Failure: Error, Unit>: AsyncSequen
                     self.continuation = nil
                 }
                 self.nativeCancellable = nil
-                return unit
-            }, { cancellationError, unit in
+                return nil
+            }, { cancellationError in
                 self.semaphore.wait()
                 defer { self.semaphore.signal() }
                 self.cancellationError = cancellationError
@@ -66,7 +73,7 @@ public struct NativeFlowAsyncSequence<Output, Failure: Error, Unit>: AsyncSequen
                     self.continuation = nil
                 }
                 self.nativeCancellable = nil
-                return unit
+                return nil
             })
         }
 
@@ -105,4 +112,3 @@ public struct NativeFlowAsyncSequence<Output, Failure: Error, Unit>: AsyncSequen
         return Iterator(nativeFlow: nativeFlow)
     }
 }
-

KMPNativeCoroutinesAsync/NativeFlow.swift

@@ -0,0 +1,51 @@
+//
+//  NativeFlow.swift
+//  KMPNativeCoroutinesAsync
+//
+//  Created by Rick Clephas on 04/09/2023.
+//
+
+import KMPNativeCoroutinesCore
+
+public extension AsyncSequence {
+    /// Creates a `NativeFlow` for this `AsyncSequence`.
+    /// - Parameter priority: The priority of the task collecting this `AsyncSequence`.
+    func asNativeFlow(priority: TaskPriority? = nil) -> NativeFlow<Element, Error> {
+        return { returnType, onItem, onComplete, onCancelled in
+            if returnType == RETURN_TYPE_SWIFT_ASYNC_SEQUENCE {
+                return { AnyAsyncSequence(self) }
+            } else if returnType != nil {
+                return { nil }
+            }
+            let task = Task(priority: priority) {
+                do {
+                    for try await value in self {
+                        await withUnsafeContinuation { continuation in
+                            _ = onItem(value, {
+                                continuation.resume()
+                                return nil
+                            })
+                        }
+                    }
+                    try Task.checkCancellation()
+                    _ = onComplete(nil)
+                } catch {
+                    if error is CancellationError {
+                        _ = onCancelled(error)
+                    } else {
+                        _ = onComplete(error)
+                    }
+                }
+            }
+            return task.asNativeCancellable()
+        }
+    }
+}
+
+public extension AsyncSequence where Element == Void {
+    /// Creates a `NativeFlow` for this `AsyncSequence`.
+    /// - Parameter priority: The priority of the task collecting this `AsyncSequence`.
+    func asNativeFlow(priority: TaskPriority? = nil) -> NativeFlow<NativeUnit?, Error> {
+        map { nil }.asNativeFlow(priority: priority)
+    }
+}

KMPNativeCoroutinesAsync/NativeSuspend.swift

@@ -0,0 +1,53 @@
+//
+//  NativeSuspend.swift
+//  KMPNativeCoroutinesAsync
+//
+//  Created by Rick Clephas on 04/09/2023.
+//
+
+import KMPNativeCoroutinesCore
+
+/// Creates a `NativeSuspend` for the provided async operation.
+/// - Parameters:
+///     - priority: The priority of the task executing the operation.
+///     - operation: The async operation to execute.
+public func nativeSuspend<Result>(
+    priority: TaskPriority? = nil,
+    operation: @escaping @Sendable () async throws -> Result
+) -> NativeSuspend<Result, Error> {
+    return { returnType, onResult, onError, onCancelled in
+        if returnType == RETURN_TYPE_SWIFT_ASYNC {
+            return { operation }
+        } else if returnType != nil {
+            return { nil }
+        }
+        let task = Task(priority: priority) {
+            do {
+                let result = try await operation()
+                try Task.checkCancellation()
+                _ = onResult(result)
+            } catch {
+                if error is CancellationError {
+                    _ = onCancelled(error)
+                } else {
+                    _ = onError(error)
+                }
+            }
+        }
+        return task.asNativeCancellable()
+    }
+}
+
+/// Creates a `NativeSuspend` for the provided async operation.
+/// - Parameters:
+///     - priority: The priority of the task executing the operation.
+///     - operation: The async operation to execute.
+public func nativeSuspend(
+    priority: TaskPriority? = nil,
+    operation: @escaping @Sendable () async throws -> Void
+) -> NativeSuspend<NativeUnit?, Error> {
+    nativeSuspend(priority: priority) {
+        try await operation()
+        return nil
+    }
+}

KMPNativeCoroutinesAsync/Task.swift

@@ -0,0 +1,18 @@
+//
+//  Task.swift
+//  KMPNativeCoroutinesAsync
+//
+//  Created by Rick Clephas on 02/09/2023.
+//
+
+import KMPNativeCoroutinesCore
+
+internal extension Task {
+    /// Creates a `NativeCancellable` for this `Task`.
+    func asNativeCancellable() -> NativeCancellable {
+        return {
+            self.cancel()
+            return nil
+        }
+    }
+}