Kotlin Arrow: padroneggiare la navigazione nella monade Either

Publié le 24 September 2024

Introduzione

Pubblico destinatario : Sviluppatori Kotlin di livello intermedio-avanzato.

Nel mondo della programmazione funzionale in Kotlin, la libreria Arrow offre strumenti potenti per gestire gli errori e i casi alternativi. Tra questi strumenti, la monade`Either`si distingue per la sua capacità di rappresentare due stati possibili: successo (Right) o fallimento (Left). Ma come navigare efficacemente tra questi due stati? Questo è ciò che esploreremo in questo articolo.

Che cosa è la monade Either ?

La monade`Either`è una struttura di dati che rappresenta due possibilità mutualmente esclusive. In Kotlin con Arrow, è spesso utilizzata per gestire i casi di successo e di fallimento di un’operazione, offrendo un’alternativa elegante alle eccezioni tradizionali.

Perché utilizzare Either ?

  1. Gestione esplicita degli errori: obbliga lo sviluppatore a considerare i casi di fallimento.

  2. Composizione funzionale : Facilita il concatenamento di operazioni che possono fallire.

  3. Type-safety: gli errori sono tipizzati, il che aiuta a gestirli in modo più preciso.

  4. Nessuna eccezione: evita gli effetti collaterali e le interruzioni inaspettate del flusso di esecuzione.

Contesto

Immaginiamo che tu stia sviluppando un’API REST conhttps://spring.io/projects/spring-boot/[Spring Boot,windows=read-later] et Kotlin, utilizzando la libreriahttps://arrow-kt.io/[Arrow,windows=read-later]. Hai una funzione`findOneUserByEmail`che restituisce un`Either<Throwable, User>`. Come puoi trattare questo risultato in modo elegante e funzionale ?

Abbiamo una classe User :

@file:Suppress(
    "RemoveRedundantQualifierName",
    "MemberVisibilityCanBePrivate",
    "SqlNoDataSourceInspection"
)

package webapp.users

import arrow.core.Either
import arrow.core.left
import arrow.core.right
import com.fasterxml.jackson.annotation.JsonIgnore
import com.fasterxml.jackson.databind.ObjectMapper
import jakarta.validation.constraints.NotNull
import jakarta.validation.constraints.Pattern
import jakarta.validation.constraints.Size
import org.springframework.beans.factory.getBean
import org.springframework.context.ApplicationContext
import org.springframework.data.r2dbc.core.R2dbcEntityTemplate
import org.springframework.r2dbc.core.DatabaseClient
import org.springframework.r2dbc.core.awaitOne
import org.springframework.r2dbc.core.awaitRowsUpdated
import webapp.core.property.ANONYMOUS_USER
import webapp.core.property.EMPTY_STRING
import webapp.core.utils.AppUtils.cleanField
import webapp.users.EntityModel.Companion.ID_MEMBER
import webapp.users.User.UserDao.Attributes.EMAIL_ATTR
import webapp.users.User.UserDao.Attributes.ID_ATTR
import webapp.users.User.UserDao.Attributes.LANG_KEY_ATTR
import webapp.users.User.UserDao.Attributes.LOGIN_ATTR
import webapp.users.User.UserDao.Attributes.PASSWORD_ATTR
import webapp.users.User.UserDao.Attributes.VERSION_ATTR
import webapp.users.User.UserDao.Constraints.LOGIN_REGEX
import webapp.users.User.UserDao.Fields.EMAIL_FIELD
import webapp.users.User.UserDao.Fields.ID_FIELD
import webapp.users.User.UserDao.Fields.LANG_KEY_FIELD
import webapp.users.User.UserDao.Fields.LOGIN_FIELD
import webapp.users.User.UserDao.Fields.PASSWORD_FIELD
import webapp.users.User.UserDao.Fields.VERSION_FIELD
import webapp.users.User.UserDao.Relations.INSERT
import webapp.users.security.Role
import webapp.users.security.Role.RoleDao
import webapp.users.security.UserRole.UserRoleDao
import java.util.*
import jakarta.validation.constraints.Email as EmailConstraint

data class User(
    override val id: UUID? = null,

    @field:NotNull
    @field:Pattern(regexp = LOGIN_REGEX)
    @field:Size(min = 1, max = 50)
    val login: String,

    @JsonIgnore
    @field:NotNull
    @field:Size(min = 60, max = 60)
    val password: String = EMPTY_STRING,

    @field:EmailConstraint
    @field:Size(min = 5, max = 254)
    val email: String = EMPTY_STRING,

    @JsonIgnore
    val roles: MutableSet<Role> = mutableSetOf(Role(ANONYMOUS_USER)),

    @field:Size(min = 2, max = 10)
    val langKey: String = EMPTY_STRING,

    @JsonIgnore
    val version: Long = -1,
) : EntityModel<UUID>() {

    companion object {
        @JvmStatic
        fun main(args: Array<String>) = println(UserDao.Relations.sqlScript)
    }

    object UserDao {
        object Constraints {
            // Regex for acceptable logins
            const val LOGIN_REGEX =
                "^(?>[a-zA-Z0-9!$&*+=?^_`{|}~.-]+@[a-zA-Z0-9-]+(?:\\.[a-zA-Z0-9-]+)*)|(?>[_.@A-Za-z0-9-]+)$"
            const val PASSWORD_MIN: Int = 4
            const val PASSWORD_MAX: Int = 16
            const val IMAGE_URL_DEFAULT = "https://placehold.it/50x50"
            const val PHONE_REGEX = "^(\\+|00)?[1-9]\\d{0,49}\$"
        }

        object Members {
            const val PASSWORD_MEMBER = "password"
            const val ROLES_MEMBER = "roles"
        }

        object Fields {
            const val ID_FIELD = "`id`"
            const val LOGIN_FIELD = "`login`"
            const val PASSWORD_FIELD = "`password`"
            const val EMAIL_FIELD = "`email`"
            const val LANG_KEY_FIELD = "`lang_key`"
            const val VERSION_FIELD = "`version`"
        }

        object Attributes {
            val ID_ATTR = ID_FIELD.cleanField()
            val LOGIN_ATTR = LOGIN_FIELD.cleanField()
            val PASSWORD_ATTR = PASSWORD_FIELD.cleanField()
            val EMAIL_ATTR = EMAIL_FIELD.cleanField()
            const val LANG_KEY_ATTR = "langKey"
            val VERSION_ATTR = VERSION_FIELD.cleanField()
        }

        object Relations {
            const val TABLE_NAME = "`user`"
            const val SQL_SCRIPT = """
            CREATE TABLE IF NOT EXISTS $TABLE_NAME (
                $ID_FIELD                     UUID default random_uuid() PRIMARY KEY,
                $LOGIN_FIELD                  VARCHAR,
                $PASSWORD_FIELD               VARCHAR,
                $EMAIL_FIELD                  VARCHAR,
                $LANG_KEY_FIELD               VARCHAR,
                $VERSION_FIELD                bigint
            );
            CREATE UNIQUE INDEX IF NOT EXISTS `uniq_idx_user_login`
            ON $TABLE_NAME ($LOGIN_FIELD);
            CREATE UNIQUE INDEX IF NOT EXISTS `uniq_idx_user_email`
            ON $TABLE_NAME ($EMAIL_FIELD);
"""

            @Suppress("SqlDialectInspection")
            const val INSERT = """
            insert into $TABLE_NAME (
                $LOGIN_FIELD, $EMAIL_FIELD,
                $PASSWORD_FIELD, $LANG_KEY_FIELD,
                $VERSION_FIELD
            ) values ( :login, :email, :password, :langKey, :version)"""

            @JvmStatic
            val sqlScript: String
                get() = setOf(
                    UserDao.Relations.SQL_SCRIPT,
                    RoleDao.Relations.SQL_SCRIPT,
                    UserRoleDao.Relations.SQL_SCRIPT
                ).joinToString("")
                    .trimMargin()
        }

        object Dao {
            val Pair<User, ApplicationContext>.toJson: String
                get() = second.getBean<ObjectMapper>().writeValueAsString(first)

            suspend fun Pair<User, ApplicationContext>.save(): Either<Throwable, Long> = try {
                second.getBean<R2dbcEntityTemplate>()
                    .databaseClient
                    .sql(INSERT)
                    .bind(LOGIN_ATTR, first.login)
                    .bind(EMAIL_ATTR, first.email)
                    .bind(PASSWORD_ATTR, first.password)
                    .bind(LANG_KEY_ATTR, first.langKey)
                    .bind(VERSION_ATTR, first.version)
                    .fetch()
                    .awaitRowsUpdated()
                    .right()
            } catch (e: Throwable) {
                e.left()
            }


            suspend fun ApplicationContext.findOneUserByEmail(
                email: String
            ): Either<Throwable, User> = try {
                getBean<DatabaseClient>()
                    .sql("SELECT * FROM `user` WHERE LOWER(email) = LOWER(:email)")
                    .bind("email", email)
                    .fetch()
                    .awaitOne()
                    .let { row ->
                        User(
                            id = row[ID_ATTR] as UUID?,
                            login = row[LOGIN_ATTR] as String,
                            password = row[PASSWORD_ATTR] as String,
                            email = row[EMAIL_ATTR] as String,
                            langKey = row[LANG_KEY_ATTR] as String,
                            version = row[VERSION_ATTR] as Long
                        )
                    }.right()
            } catch (e: Throwable) {
                e.left()
            }
        }
    }

    /** Account REST API URIs */
    object UserRestApis {
        const val API_AUTHORITY = "/api/authorities"
        const val API_USERS = "/api/users"
        const val API_SIGNUP = "/signup"
        const val API_SIGNUP_PATH = "$API_USERS$API_SIGNUP"
        const val API_ACTIVATE = "/activate"
        const val API_ACTIVATE_PATH = "$API_USERS$API_ACTIVATE?key="
        const val API_ACTIVATE_PARAM = "{activationKey}"
        const val API_ACTIVATE_KEY = "key"
        const val API_RESET_INIT = "/reset-password/init"
        const val API_RESET_FINISH = "/reset-password/finish"
        const val API_CHANGE = "/change-password"
        const val API_CHANGE_PATH = "$API_USERS$API_CHANGE"
    }
}

// Abstract entity model with Generic ID, which can be of any type
abstract class EntityModel<T>(
    open val id: T? = null
) {
    companion object {
        const val ID_MEMBER = "id"
    }
}

// Generic extension function that allows the ID to be applied to any EntityModel type
inline fun <reified T : EntityModel<ID>, ID> T.withId(id: ID): T {
    // Use reflection to create a copy with the passed ID
    return this::class.constructors.first { it.parameters.any { param -> param.name == ID_MEMBER } }
        .call(id, *this::class.constructors.first().parameters.drop(1).map { param ->
            this::class.members.first { member -> member.name == param.name }.call(this)
        }.toTypedArray())
}

Le diverse approcci

L’approccio classico con `when

val user: User by lazy { userFactory(USER) }

val result: Either<Throwable, User> = context.findOneUserByEmail(user.email)

when (result) {
    is Either.Left -> {
        val error = result.value
        println("Erreur : ${error.message}")
    }
    is Either.Right -> {
        val user = result.value
        println("Utilisateur trouvé : ${user.login}")
    }
}

Questa metodo, sebbene semplice e leggibile, non sfrutta appieno le capacità funzionali di Arrow.

Utilizzo di fold per un approccio più conciso

result.fold(
{ error -> println("Erreur : ${error.message}") },
{ user -> println("Utilisateur trouvé : ${user.login}") }
)

`fold`permette di definire delle azioni per i due casi (Left e Right) in modo conciso ed elegante.

Trasformazione con map e `mapLeft

val processedResult = result
    .map { user -> "Utilisateur trouvé : ${user.login}" }
    .mapLeft { error -> "Erreur : ${error.message}" }

println(processedResult.merge())

Questo approccio permette di trasformare i valori contenuti in Either preservandone la struttura, ideale per catene di elaborazione più complesse.

Gestione degli errori con `getOrElse

val user = result.getOrElse { error ->
    println("Erreur : ${error.message}")
    User(login = "default", email = "[email protected]") // utilisateur par défaut
}
println("Login : ${user.login}")

`getOrElse`offre una gestione elegante degli errori consentendo di fornire un valore predefinito.

Azioni laterali con onLeft e `onRight

result.onLeft { error -> println("Erreur : ${error.message}") }
.onRight { user -> println("Utilisateur trouvé : ${user.login}") }

Questi metodi permettono di eseguire azioni su ogni lato senza modificare l’Either, perfetto per il logging o gli effetti collaterali leggeri.

Concatenamento di operazioni con `flatMap

fun findUser(email: String): Either<Throwable, User> = // ... implémentation

fun getUserPermissions(user: User): Either<Throwable, List<String>> = // ... implémentation

val userPermissions = findUser("[email protected]")
    .flatMap { user -> getUserPermissions(user) }

flatMap`è utile per concatenare operazioni che restituiscono a loro volta degli`Either, evitando così gli`Either`annidati.

Trasformazione bidirezionale con `bimap

val result: Either<Throwable, User> = // ... obtention du résultat
val processedResult = result.bimap(
    { error -> "Erreur: ${error.message}" },
    { user -> "Utilisateur: ${user.login}" }
)

`bimap`permette di trasformare sia il lato sinistro che il lato destro in una singola operazione.

Inversione dei lati con `swap

val result: Either<Throwable, User> = // ... obtention du résultat
val swapped = result.swap()

swap`è utile quando vuoi invertire i lati di un`Either, ad esempio per adattare l’interfaccia di una funzione a un’altra.

Utilizzo di tap e tapLeft :

result.tap { user -> println("Utilisateur trouvé : ${user.login}") }
.tapLeft { error -> println("Erreur : ${error.message}") }

Simile a`onLeft` et onRight, ma questi metodi restituiscono l’Either originale, il che è utile per il concatenamento di operazioni.

Utilizzo di recover:

val recoveredUser = result.recover { error ->
    println("Erreur récupérée : ${error.message}")
    User(login = "recovered", email = "[email protected]")
}
println("Login : ${recoveredUser.login}")

Questo metodo permette di trasformare un Either.Left in Either.Right fornendo un valore di sostituzione.

Casi d’uso pratici

  • Utilizzi`fold`per operazioni semplici che richiedono un trattamento per ogni caso. - Preferisci`map` et mapLeft`per trasformazioni di dati senza cambiare la struttura dell`Either. Scegli`flatMap`durante il concatenamento di operazioni che possono fallire - Utilizzate`recover`per fornire un valore predefinito in caso di errore. - Scegli`onLeft` et onRight (ou tap et tapLeft) per effetti collaterali come il logging - Utilizzate`bimap`per trasformare entrambi i lati in un’unica operazione. - Applicate`swap`quando devi adattare l’interfaccia di una funzione a un’altra.

Conclusion

Ognuno di questi approcci ha i suoi vantaggi a seconda del contesto d’uso. I metodi come`fold`, map(empty)mapLeft, et `recover`sono particolarmente utili quando volete concatenare più operazioni o trasformare i dati in modo funzionale.

La monade`Either`d’Arrow offre una flessibilità notevole per gestire i casi di successo e di errore nelle tue applicazioni Kotlin. Padroneggiando questi diversi approcci, potrai scrivere un codice più robusto, più leggibile e più funzionale.

Nel tuo prossimo progetto, non esitare a esplorare queste tecniche per sfruttare al meglio la programmazione funzionale con Kotlin e Arrow!

Per andare oltre

  • Documentazione ufficiale di Arrow :https://arrow-kt.io/docs/apidocs/arrow-core/arrow.core/-either/[Arrow Either] - Kotlin Coroutines con Arrow :https://arrow-kt.io/docs/fx/[Arrow Fx Coroutines]

Non dimenticare di condividere le tue esperienze e le tue tecniche preferite per lavorare con`Either`nei commenti qui sotto!

Articoli correlati

HyperFrames-Gradle: Converti l'AsciiDoc in video MP4
31 May 2026
L'architettura « Plugin Indipendente + Radice Consumatore » : Perché i miei build Gradle si duplicano
14 May 2026
Il Knowledge Graph come motore di raccomandazione: come ho ucciso gli « articoli correlati » cronologici
12 May 2026
Cumulare Due Abbonamenti Ollama Pro sulla Stessa Macchina con Docker
08 May 2026