A modern programming language that makes developers happier.

kotlinlang

Is there a way in the stdlib to reduce a bunch of `Result` instances into a single Result? I can write it myself but a shame to repeat it.

I want roughly the following:
```data class Foo(val a: String, val b: Int)

val resultA: Result&lt;String&gt; = TODO()
val resultB: Result&lt;Int&gt; = TODO()

val foo: Result&lt;Foo&gt; = reduce(resultA, resultB, ::Foo)```
So the function would look something like:
```fun &lt;A, B, T&gt; reduce(a: Result&lt;A&gt;, b: Result&lt;B&gt;, work: (A, B) -&gt; T): Result&lt;T&gt;```
But obviously it would need loads of overloads.

I don't think there is any facilities for this. The built-in `Result` class is not meant to be used in business code, it's mostly targeted to framework code that need to report/transfer errors in a special way (such as the coroutine library). That's why I believe there is no real incentive to add convenience facilities on top of this class in the stdlib.

OK - what do people who like the `Either` style of error reporting do in this case?

From the <https://github.com/Kotlin/KEEP/blob/master/proposals/stdlib/result.md#similar-api-review|design document> of `Result` (after a paragraph mentioning the Arrow library and kittinunf's `Result&lt;T,E&gt;`):

&gt; Note, that both of the libraries above promote "Railway Oriented Programming" style with monads and their transformations, which heavily relies on functions returning `Try`, `Result`, etc. This programming style can be implemented and used in Kotlin via libraries as the above examples demonstrate. However, core Kotlin language and its Standard Library are designed around a _direct_ programming <https://github.com/Kotlin/KEEP/blob/master/proposals/stdlib/result.md#error-handling-style-and-exceptions|style> in mind. The general approach in Kotlin is that alternative programming styles should be provided as 3rd party libraries and DSLs.
So I guess people who like the railway style are encouraged to use libraries like Arrow

Also in the same doc, on the topic of special built-in language syntax for `Result`:

&gt; UPDATE: We have reached a decision of not following this road for a foreseeable future and will not pursue integration of any special constructions into the language that are tied to the `Result` type. As a part of the standard library a `Result` type will stay narrowly-focused on the use-cases that are described at the beginning of this document, abandoning ambitions to become any kind of universal error-handling primitive. We are working in other directions of making signalling error handling more pleasant to use in Kotlin.
It's unclear whether we can conclude that it's unlikely we'll get extensive helper functions for `Result`, but I would tend to think so.

Cool, thanks. I'll look at Arrow's stuff.

Seems <https://arrow-kt.io/docs/patterns/error_handling/> has some useful thoughts.

If you're looking for a direct replacement of Result (without all of the extra Arrow functionality), check out kotlin-result: <https://github.com/michaelbull/kotlin-result>

Cool, `binding` looks like exactly what I want.

yep map/bind depending which return signature you need