Android-CleanArchitecture-Kotlin VS kotlin-result

This article specifically says not to create a "domain layer module" and "data layer module" https://fernandocejas.com/2018/05/07/architecting-android-reloaded/

As per the latest Clean Architecture guide, this is what clean arch recommendations look like https://github.com/android10/Android-CleanArchitecture-Kotlin/tree/main/app/src/main/kotlin/com/fernandocejas/sample/features/movies

Original article at https://fernandocejas.com/2018/05/07/architecting-android-reloaded/

or you can do clean architecture like it shows in this clean architecture repo :D

Nice! The implementation that I used was based on Fernando Cejas' "Android clean architecture", specifically this.

Author here. I have no idea what you could possibly mean with this comment. The coroutineBinding implementation correctly uses the coroutines API for parallel decomposition of Result bindings, exactly how the Kotlin Corotines guide tells you to (backed by a [Mutex](https://github.com/michaelbull/kotlin-result/blob/master/kot...)). The coroutineBinding isn't even the main selling point of the library, you can use it without using this feature entirely.

Please could you elaborate on what "looking thread safe" means to you? The only portion of the library that supports concurrency *is* thread safe - the unit tests prove it and the use of concurrency primitives such as Kotlin's Mutex are indicative of this. I truly have no idea how you've judged the entirely of the lbirary on whether it's "thread safe" when there is a single function that's related to concurrency and it is very clearly using concurrency primitives.

Sealed classes in combination with a library like https://github.com/michaelbull/kotlin-result will get you what you need. Essentially at that point you'll be doing error handling the way you would in Rust, where a 1-level deep sealed class containing data classes as children act as the root error type and each of its variants. If you have errors coming from two different domains you just create a wrapper error type for each domain.

This is a great result lib: https://github.com/michaelbull/kotlin-result

Lastly I do not like kotlin's Result and we use the kotlin-result library which is more expressive and not tied to Throwable (similar to Arrow's Either).

In my own code, I started to use explicit error handling. I'm currently experimenting with Result (from https://github.com/michaelbull/kotlin-result) and Raise (from https://arrow-kt.io/).

un-related to multiplatform i've found it extremely helpful to wrap things in a Result type. If something can throw an error, it get's a Result return type. It sounds like that would help your use case too. The built in Result may be useful too

This is a better impl.

Using a result type can help to differentiate quite nicely. https://github.com/michaelbull/kotlin-result

kotlin-result