Damn this kind of breaks both my legs

Hi Lucas, It may not suit your needs but more recently I've switched to using new async/await etc provided in Swift 5.5. along with following library https://github.com/rickclephas/KMP-NativeCoroutines

Unfortunately concurrency interop is one of the biggest limitations (especially now we have Swift concurrency). IMO using wrappers is currently best “solution”. And… what @John O'Reilly said 😂 😇

a good number of the samples at following are using that library now https://github.com/joreilly

@John O'Reilly Do you think this library for kmp coroutines is production ready?

@Rick Clephas , as library author, can probably comment in more detail 🙂 , but fwiw seems to work great here. The integration with new swift async/await, AsyncStream etc is really nice ....particularly when mapping to flow in shared code and using appropriate hooks in SwiftUI to invoke async code along with automatic cancellation. you get (which is propagated down to flow)

I would say that the core of the library is production ready (meaning the way Flows/suspend functions are mapped to Swift types). However the compiler plugin that automatically generates the wrapper functions has some issues (it can cause recursion errors during compilation), but there are workarounds. Besides that there is only 1 thing I would really like to improve before officially calling it production ready: https://github.com/rickclephas/KMP-NativeCoroutines/pull/49 I have actually started tracking the these things here: https://github.com/rickclephas/KMP-NativeCoroutines/milestone/1

@Rick Clephas I'm curious to know what would it take to create the llvm bridge

Well there is 1 big challenge and that is the absence of kotlinx.coroutines (which is currently used to run/collect suspend functions and flows). Besides that it should be fairly straightforward (I think). During the ObjC header export coroutines functions/properties should be transformed into lambdas. After that the invocation of such declarations should should be intercepted and “transformed” into invocations to the wrapper functions (like nativeSuspend).

You can also check out Arkitekt library . It wraps flows and suspend functions in UseCases. I don't really see the point of wrapping flow to another stream 🤷

I think it just depends on the project and your requirements. The goal of KMP-NativeCoroutines is to improve the interop between Kotlin and Swift in terms of async code. Allowing Swift developers to use Kotlin async code in a "native" way, without making any assumptions about the application architecture. You could even use it with UseCases if you like.