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

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