Nel

list.parTraverseValidated(Nel.semigroup(), ::foobar)

Queue

IO

Schedule

List<Either<Error, Id>>

Either<Error, List<Id>>

Either.Left

TimeoutCancellationException

CancellationException

Either.catch

793a51edce

andThen

withEither

Validated.catch { "0".toInt() }.toValidatedNel().withEither { it.flatMap { Either.catch { 1 / it } }

fun <E,A, B> Validated<E, A>.andThen(f: (A) -> Validated<E, B>) :Validated<E, B> {
  return when(this){
    is Valid -> f(value)
    is Invalid -> this
  }
}

Validated.catch { "0".toInt() }.toValidatedNel().andThen { Validated.catch { 1/it } }

.map

.flatMap

ValidatedNel<Error, List<Result>>

@optics

data class

data class Foo(val list: List<Bar>)

arrow/arrow-site/vendor/bundle/ruby/3.0.0/gems/kramdown-1.17.0/lib/kramdown/parser/html.rb:10:in `require': cannot load such file -- rexml/parsers/baseparser (LoadError)

() -> Either<Failure, Result>

(Failure) -> Error

() -> Either<Error, Result

Either

List<Validated<Foo, Unit>>

Validated<Bar, Unit>

val failed = values().map {
    it.validate(vehicleSettingEntity, states) // a Validated<ValidationError, Unit>
}.filterIsInstance<Validated.Invalid<ValidationError>>().map { it.value }
return when {
    failed.isEmpty() -> Unit.valid()
    else -> ValidationResult(failed).invalid()
}

fold

personalData.validate().zip(
    Semigroup.nonEmptyList<ValidationError>(),
    taxData.validate(),
    productData.validate()
) { personData, taxData, productData -> Person(...) }

personalData.validate() -> ValidatedNel<ValidationError, PersonalData>

taxData.validate() -> ValidatedNel<ValidationError, TaxData>

val validatedPersonalData = when (val result = personalData.validate()) {
    is Valid -> result.value
    is Invalid -> validationErrors.addAll(result.value)
}

return if (validationErrors.isNotEmpty()) 
    validationErrors.invalidNel()
else
    Person(validatedPersonalData, validatedTaxData, validatedProductData)

Either<Error, x>

class A
class B
class C(
    val val1: String,
    val val2: String,
    val val3: String,
    val a: A,
    val b: B,
)

fun getA(val1: String): Either<Exception, A> = Either.Right(A())
fun getB(val1: String): Either<Exception, B> = Either.Right(B())
fun getCs(): Either<Exception, List<CBuilder>> = Either.Right(listOf(CBuilder("val1", "val2", "val3")))

class CBuilder(
    val val1: String,
    val val2: String,
    val val3: String,
)

class EitherTest {

    @Test
    fun buildC() {
        getCs().flatMap { builders ->
            builders.map { builder ->
                getA(builder.val1).flatMap { a ->
                    getB(builder.val1).map { b ->
                        C(builder.val1, builder.val2, builder.val3, a, b)
                    }
                }
            }.sequenceEither()
        }
    }
}

map

map

flatmap

bifoldLeft

left

fold

bifold

WriterT

Const

widen

widen

Endo

Sequence

Either

ReaderT IO

Sequence

Either

ap

location.ap(name.map(action))

location

name

Either<String, String>

action

(String) -> (String) -> String

fun saveSession(session: Session): Either<Throwable, Unit>
fun getSession(id: SessionID): Either<Throwable, Session>

fun saveSession(connection: RedisConnection, session: Session): Either<Throwable, Unit>
fun getSession(connection: ResdisConnection, id: SessionID): Either<Throwable, Session>

class RedisSessionManager(connection: RedisConnection): SessionManager {
fun saveSession(session: Session): Either<Throwable, Unit>
fun getSession(id: SessionID): Either<Throwable, Session>
}

ValidatedNel

fun buildMyObjectObject(token: String?, name: String?): ValidatedNel<Error, MyObject> =
    Validated.fromNullable(token, { MissingField("token")  }).toValidatedNel().zip(
            Validated.fromNullable(name, { MissingField("name")  }).toValidatedNel()) { token, name ->
      MyObject(token, name)
    }

toValidatedNel

Validated

Coproduct