Creating an object builder with error handling using Arrow - Pattern match multiple Eithers

Question

I have class A:

class A (private var z: String, private var y: String, private var x: Int)

I want to create a failsafe builder for it. The builder should return Either the list of Exceptions (e.g. when values are missing) or the created values. What is the recommended way to create something like this? Or is there a conceptually better approach?

---

My own approach to it:

sealed class ABuilderException {
    object MissingXValue : ABuilderException()
    object MissingYValue : ABuilderException()
    object MissingZValue : ABuilderException()
}

import arrow.core.Either
import arrow.core.Option
import arrow.core.none
import arrow.core.some

class ABuilder {
    private var x : Option<Int> = none()
    private var y : Option<String> = none()
    private var z : Option<String> = none()

    fun withX(x : Int) : ABuilder {
        this.x = x.some();
        return this;
    }
    fun withY(y : String) : ABuilder {
        this.y = y.some();
        return this;
    }
    fun withZ(z : String) : ABuilder {
        this.z = z.some();
        return this;
    }
    
    fun build() : Either<A, List<ABuilderException>> {
        var xEither = x.toEither { ABuilderException.MissingXValue }
        var yEither = y.toEither { ABuilderException.MissingYValue }
        var zEither = z.toEither { ABuilderException.MissingZValue }
        // If all values are not an exception, create A
        // otherwise: Return the list of exceptions
    }

}

How could I best complete the build code?

I favor a solution that avoids deep nesting (e.g. orElse or similar methods) and avoids repeating values (e.g. by recreating Tuples), because this may lead to typos and makes it harder to add/remove properties later.

Answer 1

First you need to change the signature of build to:

fun build() : Either<List<ABuilderException>, A>

The reason for doing that is because Either is right biased - functions like map, flatMap etc operate on the Right value and are no-op in case the value is Left.

For combining Either values you can use zip:

val e1 = 2.right()
val e2 = 3.right()

// By default it gives you a `Pair` of the two
val c1 = e1.zip(e2) // Either.Right((2, 3))

// Or you can pass a custom combine function
val c2 = e1.zip(e2) { two, three -> two + three } // Either.Right(5)

However there is an issue here, in case of an error (one of them is Left) it will fail fast and give you only the first one.

To accumulate the errors we can use Validated:

val x = none<Int>()
val y = none<String>()
val z = none<String>()

// Validated<String, Int>
val xa = Validated.fromOption(x) { "X is missing" }

// Validated<String, String>
val ya = Validated.fromOption(y) { "Y is missing" }

// Validated<String, String>
val za = Validated.fromOption(z) { "Z is missing" }
    
xa.toValidatedNel().zip(
    ya.toValidatedNel(),
    za.toValidatedNel()
) { x, y, z -> TODO() }

Validated, like Either has a zip function for combining values. The difference is that Validated will accumulate the errors. In the lambda you have access to the valid values (Int, String, String) and you can create your valid object.

toValidatedNel() here converts from Validated<String, String> to Validated<Nel<String>, String> where Nel is a list that can NOT be empty. Accumulating errors as a List is common so it's built in.

For more you can check the Error Handling tutorial in the docs.