val getId: (MyClass) -> String? = MyClass.somePath.id::getOrNull

::getOrNull

flatMap

ValidatedNel<E,A>

either.eager

fun InputRequest.validate(): Validated<IncorrectInput, InputRequest> =
    userType.validateMail(obj.inputEnum)
        .zip(username.validateUserName(), obj.validateObj()) {
                userType,
                userName,
                obj ->
            InputRequest(userType, userName, obj)
        }
        .mapLeft(::IncorrectInput)

fun String.validateUserType(enum: Enum):ValidatedNel<InvalidUserType, String> {
    val trimmed = trim()
    if(trimmed.isBlank()) {
        return "User type can't be empty".invalidNel().mapLeft(toInvalidField(::InvalidUserType))
    }
    if(trimmed == "other" && !(enum == Enum.E1 || enum == Enum.E2)) {
        return "Given user type is not supported with E1 and E2".invalidNel().mapLeft(toInvalidField(::InvalidMail))
    }
    return validNel()
}

validateUserType

Either

sealed class DataState<T> {

    class Loading<T> : DataState<T>()

    data class Error<T>(val error: CallError) : DataState<T>()

    data class DataLoaded<T>(
        val data: T
    ) : DataState<T>()
}

DataLoaded

Either.Right

flatMap()

Either.Left

flatMap()

either {}

.bind()

either {}

arrow.core.continuations.either

public suspend operator fun <E, A> invoke(f: suspend EffectScope<E>.() -> A): Either<E, A> =
    effect(f).toEither()

!= null

myVal1 != null || myVal2 != null || myVal3 != null

listOf(myVal1, myVal2, myVal3).anyNotNull()

bind()

Either

value

commonConnectorApi.renameControlDevice()

Either<CallError, Unit>

public fun <A, B, C> Either<A, B>.combine(SGA: Semigroup<A>, b: Either<A, C>): Either<A, Pair<B, C>>

plugins {
    id("com.google.devtools.ksp")
}

dependencies {
    implementation("io.arrow-kt:arrow-optics:$arrowVersion")
    ksp("io.arrow-kt:arrow-optics-ksp-plugin:$arrowVersion")
}

@optics
data class ConnectorWithSensors(
    val connector: Connector,
    val sensors: List<ItemSelection>,
) {
    companion object
}

@optics
data class ItemSelection(
    val id: String,
    val selected: Boolean,
) : {
    companion object
}

ConnectorWithSensors.sensors

parZip

either

suspend fun refresh(): Either<Throwable, Unit> = either {
    parZip(
        { refreshA().bind() },
        { refreshB().bind() }
    ) { dataA, dataB ->
        persistData(dataA, dataB).bind()
    }
}

ParZip.kt

f(a as A, b as B)

Option

None

None(Int)

Option

Failure

Result

Option

io.arrow-kt:arrow-core-retrofit

arrow-endpoint

MyClass.a.b.c.tap { println(it) }.d.e.f.set(state, newValue)

effect { ... }

fun function1: Effect<ErrorAdt, String> = effect {
  val val1: String = function2()
  val val2: String = function3()
  return val1 + val2
}

function2

function3

ErrorAdt

try/catch

resource {}

Arrow

Either

FP

Arrow

shift("boom")

class Test : FreeSpec({
    "should this throw?" {
        effect {
            result { error("💥") }.bind { "boom" }
        }.toEither() shouldBe Either.Left("boom")
    }
})

Either.catch({ "boom" }) { error("💥") }.bind()

@optics

companion object