KEEP VS kotlin-result

`Either foo()` and `Foo foo() throws MyError` and are pretty much isomorphic.

https://github.com/Kotlin/KEEP/blob/master/proposals/stdlib/...

Nice. So for example, it looks like Kotlin has a nearly identical feature at the language level which will be optimizable when Valhalla ships: https://github.com/Kotlin/KEEP/blob/master/notes/value-class...

> In the future, in a Valhalla-capable JVM, JVM primitive classes will enable efficient representation of Kotlin value classes with an arbitrary number of underlying fields on JVM.

Most other languages agree that checked exceptions are not good by not having them.

As for alternatives, Try/Result and similar monads have decent adoption even in Java, but personally I quite like the Kotlin philosophy [1] to not have generic error containers and either use runtime exceptions or make failures of the return type.

[1] https://github.com/Kotlin/KEEP/blob/master/proposals/stdlib/...

If you want to read more and don't want to google it: https://github.com/Kotlin/KEEP/blob/data-objects/proposals/data-objects.md

Under the hood: https://github.com/Kotlin/KEEP/blob/master/proposals/coroutines.md .

you can check more here

You can use explicit API mode, then everything needs explicit visibility

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