0Pricing
Kotlin Academy · Lección

Modelado funcional de dominios con los tipos principales de Arrow

Modele dominios complejos utilizando Either, NonEmptyList y la acumulación de errores validados

Modelado funcional de dominios con los tipos principales de Arrow es una lección gratuita de Kotlin Academy en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Kotlin Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Kotlin Academy incluye 4 lecciones en total.

¿Qué es el modelado funcional del dominio?

El modelado funcional del dominio utiliza tipos algebraicos (Either, Option y clases selladas) para codificar las reglas de negocio en los tipos. Los estados no válidos se vuelven imposibles de representar en tiempo de compilación y los errores quedan explícitos en las firmas de las funciones, sin excepciones ocultas.

Objetos de valor con clases inline/de valor

Use clases de valor de Kotlin para envolver tipos primitivos y evitar la obsesión por los tipos primitivos. El sistema de tipos rechaza pasar un UserId cuando se espera un PostId:

@JvmInline value class UserId(val value: Long)
@JvmInline value class PostId(val value: Long)

fun findUser(id: UserId): Either<UserError, User> = TODO()
// findUser(PostId(1L))  // Compile error!

Clases selladas para errores del dominio

Modele los errores como jerarquías de clases selladas. Cada subclase contiene únicamente los datos relevantes para ese caso de error:

sealed class UserError {
    data class NotFound(val id: UserId) : UserError()
    data class EmailTaken(val email: String) : UserError()
    data class ValidationFailed(val field: String, val reason: String) : UserError()
}

Validated: acumulación de varios errores

Cuando quiera informar de todos los errores de validación a la vez, y no solo del primero, use Validated de Arrow (o zipOrAccumulate en el DSL de Raise). Los errores se acumulan en una NonEmptyList:

import arrow.core.Validated
import arrow.core.valid
import arrow.core.invalid

fun validateName(name: String): Validated<String, String> =
    if (name.isNotBlank()) name.valid() else "Name is blank".invalid()

Composición de validaciones

Use zip() para combinar varios resultados Validated. Si alguno es Invalid, se acumulan todos los errores:

val result: Validated<NonEmptyList<String>, User> =
    validateName(name).zip(validateEmail(email)) { n, e -> User(n, e) }
        .mapLeft { it }

Hacer que los estados no válidos sean imposibles de representar

En lugar de usar un User con un email anulable y una marca isVerified, use subclases selladas para que el sistema de tipos impida acceder al correo electrónico de un usuario no verificado:

sealed class User {
    data class Unverified(val id: UserId, val pendingEmail: String) : User()
    data class Verified(val id: UserId, val email: String) : User()
}

Constructores inteligentes

Use funciones de fábrica del objeto companion que devuelvan Either o Option en lugar de constructores públicos. Así se garantiza que las instancias siempre se encuentren en un estado válido:

class Email private constructor(val value: String) {
    companion object {
        fun of(raw: String): Either<String, Email> =
            if (raw.contains("@") && raw.length <= 255) Email(raw).right()
            else "Invalid email format".left()
    }
}

Combinar Either y Option en un pipeline

Una operación de dominio real normalmente encadena búsquedas en repositorios (Option) con validaciones (Either). Use el bloque either { } de Arrow con .bind() para componerlas de forma fluida:

fun createPost(authorId: UserId, title: String, body: String): Either<PostError, Post> = either {
    val author = userRepo.findById(authorId).toEither { PostError.AuthorNotFound }.bind()
    val validTitle = validateTitle(title).bind()
    postRepo.save(Post(author, validTitle, body))
}

Inmutabilidad y copy

Las entidades del dominio deben ser inmutables. Use clases de datos y copy() para derivar nuevos estados. El Lens de Arrow (de arrow-optics) permite actualizar estructuras anidadas de forma cómoda sin mutarlas:

val updated = user.copy(email = "new@example.com")
// Arrow Optics:
val emailLens = User.email
val updatedWithLens = emailLens.set(user, "new@example.com")

Configuración con seguridad de tipos mediante clases selladas

Modele las variantes de configuración de la aplicación con clases selladas para que el compilador le obligue a gestionar cada caso:

sealed class DbConfig {
    data class Postgres(val url: String, val user: String, val pass: String) : DbConfig()
    data class InMemory(val dbName: String = "test") : DbConfig()
}

Ventajas de un vistazo

El modelado funcional del dominio con los tipos principales de Arrow ofrece:

  • Ninguna excepción de puntero nulo en el código del dominio
  • Errores visibles en las firmas de las funciones
  • Comprobaciones exhaustivas de when en jerarquías selladas
  • Funciones puras fáciles de probar
  • Código autoexplicativo

Comprobación rápida

¿Cuál es la principal ventaja de usar una jerarquía de sealed class para los errores del dominio en lugar de lanzar excepciones?

Repaso: modelado funcional del dominio con los tipos principales de Arrow

Puntos clave:

  • Las clases de valor evitan la obsesión por los tipos primitivos
  • Las jerarquías de errores selladas hacen que los casos de fallo sean exhaustivos y seguros en cuanto a tipos
  • Los constructores inteligentes garantizan que las instancias sean válidas
  • either { }.bind() compone operaciones susceptibles de fallar de forma clara
  • Datos inmutables + copy() / Arrow Optics para transiciones de estado seguras

Preguntas frecuentes

¿La lección «Modelado funcional de dominios con los tipos principales de Arrow» es gratis?

Sí — el texto completo de «Modelado funcional de dominios con los tipos principales de Arrow» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Kotlin Academy, actualiza a CoddyKit PRO. El curso de Kotlin Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Modelado funcional de dominios con los tipos principales de Arrow»?

Modele dominios complejos utilizando Either, NonEmptyList y la acumulación de errores validados Practicas Kotlin Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Kotlin Academy?

No se requiere experiencia previa. Kotlin Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.

¿Cuánto tiempo toma la lección «Modelado funcional de dominios con los tipos principales de Arrow»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Kotlin Academy?

Sí. Cada lección de Kotlin Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Either : gestión de errores tipada sin excepciones
  2. DSL Raise de Arrow: composición de errores tipados
  3. Option y Nullable: cuándo utilizar cada uno
  4. Modelado funcional de dominios con los tipos principales de Arrow
← Volver a Kotlin Academy