kotlin-result

> But it feels a bit weird to client side construct an Exception only to stuff it into a Result.error(...) instead of actually throwing it yep, `kotlin.Result` constraining your error type to `Throwable` is a real headache as it forces you to still model your domain logic via exceptions. it also means people can still accidentally throw these exceptions. not to mention the overhead of creating stack traces per instantiation unless you disable that on every subclass. i recommend using https://github.com/michaelbull/kotlin-result?tab=readme-ov-f... (which has a nice breakdown of all the other reasons to avoid `kotlin.Result`)

Nice, what's the KMP plan there? We currently use https://github.com/michaelbull/kotlin-result , which officially should work on KMP, but has some issues.

there's an official template here: https://github.com/detekt/detekt-custom-rule-template/tree/m... and here's the diff for a 'real world' rule I implemented: https://github.com/michaelbull/kotlin-result/compare/master....

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 Coroutines guide tells you to, backed by a Mutex[1]. 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[2] prove it and the use of concurrency primitives such as Kotlin's Mutex[3] are indicative of this. I truly have no idea how you've judged the entirely of the library on whether it's "thread safe" when there is a single function (in an extension library, not the core one) that's related to conc

I have a hard time agreeing that exceptions (as they exist in kotlin, unchecked) are superior. There is no way to communicate (outside of docs) to callers that a function is possibly unsafe and that they should handle it. Good callout on the stdlib `Result`, a lot of people aren't aware of the `CancellationException` issue. Another pain point is that the error is constrained to `Throwable`, which is rather obtuse for general business logic (and you're likely generating stack traces needlessly unless you disable `writableStackTrace` on your custom throwables). I'm a fan of https://github.com/michaelbull/kotlin-result which has a fantastic API and supports monad comprehension which helps avoid the "arrowheads" from not having a built in operator.

Maybe I'm missing something but why does this not work with Java? Is it the fact you would put your xs.map call in a mapper or something? Because I know for sure you can do it in Kotlin: https://github.com/michaelbull/kotlin-result But I don't see reified generics as a requirement for what you describe, and that's the main Kotlin-only feature I see being used