Kotlin Arrow : Either 모나드 탐색 마스터하기

Sommaire

소개
Either 모나드가 무엇인가요?
- 왜 Either를 사용해야 하나요?
맥락
다양한 접근 방식
실용적인 사용 사례
결론
더 깊이

읽는 데 걸리는 시간 : 12~15분.

소개

대상 : 중급에서 고급 수준의 Kotlin 개발자.

Kotlin의 함수형 프로그래밍 세계에서 Arrow 라이브러리는 오류와 대체 사례를 처리하는 강력한 도구를 제공합니다. 이러한 도구들 중에서 모나드`Either`두 가지 가능한 상태: 성공(Right) 또는 실패(Left). 하지만 이 두 상태 사이에서 효율적으로 어떻게 탐색할 수 있을까요? 이것이 바로 이 글에서 우리가 탐구할 내용입니다.

Either 모나드가 무엇인가요?

모나드`Either`Either` 는 두 가지 상호 배타적인 가능성을 나타내는 데이터 구조입니다. Kotlin과 Arrow에서, 이는 작업의 성공 및 실패 사례를 처리하는 데 자주 사용되며, 전통적인 예외에 대한 우아한 대안을 제공합니다.

왜 Either를 사용해야 하나요?

명시적 오류 처리 : 개발자에게 실패 사례를 고려하도록 강요합니다.
함수형 구성: 실패할 수 있는 작업의 체이닝을 용이하게 합니다.
타입 안전성 : 오류가 타입 지정되어 있어 더 정확하게 처리하는 데 도움이 됩니다.
예외 없이: 부작용과 실행 흐름의 예기치 않은 중단을 피하라.

맥락

당신이 REST API를 개발하고 있다고 상상해 보세요https://spring.io/projects/spring-boot/[Spring Boot,windows=읽기-나중] et Kotlin, 라이브러리를 사용하여https://arrow-kt.io/[화살,창문=읽기-나중]. 당신은 하나의 기능이 있습니다.findOneUserByEmail`반환하는`Either<Throwable, User>. 이 결과를 우아하고 기능적으로 어떻게 처리할 수 있나요?

우리는 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())
}

다양한 접근 방식

클래식한 접근 방식과 `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}")
    }
}

이 방법은 간단하고 가독성이 좋지만, Arrow의 함수형 기능을 충분히 활용하지 못합니다.

fold`를 사용한 더 간결한 접근

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

`fold`두 경우(Left와 Right)에 대해 간결하고 우아하게 동작을 정의할 수 있습니다.

변환 `map`와 `mapLeft

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

println(processedResult.merge())

이 접근 방식은 Either에 포함된 값을 변환하면서 구조를 보존할 수 있게 하여, 보다 복잡한 처리 체인에 적합합니다.

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`기본 값을 제공함으로써 우아한 오류 관리를 제공합니다.

측면 동작에 `onLeft`와 `onRight

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

이러한 메서드는 Either를 수정하지 않고 각 쪽에서 작업을 수행할 수 있게 해 주며, 로깅이나 가벼운 부작용에 적합합니다.

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`연쇄적으로 실행되는 작업을 이어가기에 유용합니다. 즉, 작업을 실행하면 자신이 다시 작업을 반환합니다.`Either, 그렇게 하여 …을 피함`Either`중첩된.

bimap`을 사용한 양방향 변환

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

`bimap`양쪽을 동시에 한 번의 작업으로 변환할 수 있습니다.

swap` 로 측면 교환

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

swap`는 당신이 어떤 것의 옆을 뒤집고 싶을 때 유용합니다`Either, 예를 들어 한 함수의 인터페이스를 다른 함수에 맞게 조정하기 위해.

사용법 `tap` 그리고 `tapLeft` :

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

비슷한`onLeft` et onRight, 하지만 이러한 메서드는 원래의 Either를 반환하며, 이는 연산 체이닝에 유용합니다.

사용법 `recover` :

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

이 메서드는 대체 값을 제공하여 Either.Left를 Either.Right로 변환할 수 있습니다.

실용적인 사용 사례

사용하세요`fold`간단한 작업에 대해 각 경우에 처리가 필요한 경우. - 선호하세요`map` et mapLeft`데이터 변환을 위해 구조를 바꾸지 않고`Either. - 선택하세요`flatMap`실패할 수 있는 작업을 연쇄할 때 사용하세요`recover`오류 시 기본값을 제공하기 위해. - 선택하세요`onLeft` et onRight (ou tap et tapLeft) 부수적인 효과, 예를 들어 로깅과 같은 것을 위해. - 사용하세요`bimap`양쪽을 하나의 작업으로 변환하기. - 적용하세요`swap`함수의 인터페이스를 다른 함수의 인터페이스에 맞춰야 할 때.

결론

이러한 접근 방식 각각은 사용 맥락에 따라 장점이 있습니다. 방법과 같은`fold`, map/mapLeft, et `recover`는 여러 작업을 연결하거나 데이터를 함수형 방식으로 변환할 때 특히 유용합니다.

일원자`Either`dArrow는 Kotlin 애플리케이션에서 성공과 오류 사례를 처리하는 데 뛰어난 유연성을 제공합니다. 이러한 다양한 접근 방식을 숙달하면 더 견고하고 읽기 쉽고 기능적인 코드를 작성할 수 있습니다.

다음 프로젝트에서 이러한 기법을 탐색하여 Kotlin과 Arrow로 함수형 프로그래밍의 장점을 최대한 활용해 보세요 !

더 깊이

Arrow 공식 문서 :https://arrow-kt.io/docs/apidocs/arrow-core/arrow.core/-either/[Arrow Either] - Kotlin 코루틴과 Arrow :https://arrow-kt.io/docs/fx/[화살 이펙트 코루틴]

경험과 선호하는 기술을 공유하는 것을 잊지 마세요`Either`아래 댓글에서!

소개