Anidar y combinar jerarquías selladas
Construya máquinas de estados complejas anidando tipos sellados.
Anidar y combinar jerarquías selladas 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.
Componer árboles de estado
En el mundo real, el estado suele tener varias dimensiones. Anide tipos sealed o combine jerarquías independientes para modelar dominios complejos de forma clara.
Sealed class anidada
Declare tipos sealed secundarios dentro de un tipo sealed externo. El compilador seguirá garantizando la exhaustividad en todo el árbol.
sealed class UiState {
object Loading : UiState()
sealed class Loaded : UiState() {
data class Success(val items: List<String>) : Loaded()
data class Empty(val message: String) : Loaded()
}
data class Error(val msg: String) : UiState()
}
fun render(s: UiState) = when (s) {
UiState.Loading -> "loading"
is UiState.Loaded.Success -> "${s.items.size} items"
is UiState.Loaded.Empty -> "empty: ${s.message}"
is UiState.Error -> "err: ${s.msg}"
}
fun main() {
println(render(UiState.Loaded.Success(listOf("a", "b"))))
}Sealed interfaces para mixins
Utilice sealed interfaces cuando un estado tenga varios aspectos ortogonales: cada aspecto se representa mediante una interfaz diferente.
sealed interface Authenticated
data class User(val id: Int) : Authenticated
object Guest
sealed interface Permission
object Read : Permission
object Write : Permission
fun describe(a: Authenticated, p: Permission): String = when {
a is User && p is Write -> "user ${a.id} can write"
a is User -> "user ${a.id} can read"
else -> "?"
}
fun main() {
println(describe(User(1), Write))
}Combinar jerarquías
Pase dos valores sealed y evalúe su combinación; utilice un when con guardas.
sealed class Theme { object Light : Theme(); object Dark : Theme() }
sealed class Lang { object En : Lang(); object Tr : Lang() }
fun greet(theme: Theme, lang: Lang) = when {
theme is Theme.Dark && lang is Lang.Tr -> "Karanlik Merhaba"
theme is Theme.Light && lang is Lang.Tr -> "Aydinlik Merhaba"
theme is Theme.Dark -> "Dark Hello"
theme is Theme.Light -> "Light Hello"
else -> "?"
}
fun main() {
println(greet(Theme.Dark, Lang.Tr))
}Máquina de estados con variantes anidadas
Modele los flujos de trabajo de varios pasos como tipos sealed anidados; cada paso tiene sus propias variantes.
sealed class Checkout {
object Start : Checkout()
sealed class Payment : Checkout() {
object Pending : Payment()
data class Failed(val reason: String) : Payment()
object Captured : Payment()
}
object Shipped : Checkout()
object Delivered : Checkout()
}
fun describe(c: Checkout) = when (c) {
Checkout.Start -> "starting"
Checkout.Payment.Pending -> "awaiting payment"
is Checkout.Payment.Failed -> "payment failed: ${c.reason}"
Checkout.Payment.Captured -> "paid"
Checkout.Shipped -> "shipped"
Checkout.Delivered -> "delivered"
}
fun main() {
println(describe(Checkout.Payment.Failed("card declined")))
}Reutilizar jerarquías sealed entre módulos
Es mejor definir los tipos sealed por módulo. Para la composición entre módulos, exponga una sealed interface para que cada módulo pueda añadir sus propias implementaciones.
sealed interface Notification
data class Email(val to: String) : Notification
data class Sms(val phone: String) : Notification
fun send(n: Notification) = when (n) {
is Email -> "sending email to ${n.to}"
is Sms -> "texting ${n.phone}"
}
fun main() {
println(send(Email("a@example.com")))
}Propiedades base comunes
Las sealed classes pueden declarar propiedades comunes; todos los subtipos las heredan. Así se mantienen el estado y los metadatos sin duplicación.
sealed class HttpResponse(val code: Int) {
class Ok(val body: String) : HttpResponse(200)
class NotFound(val path: String) : HttpResponse(404)
class ServerError(val cause: String) : HttpResponse(500)
}
fun describe(r: HttpResponse) = "[${r.code}] " + when (r) {
is HttpResponse.Ok -> r.body
is HttpResponse.NotFound -> "not found: ${r.path}"
is HttpResponse.ServerError -> "fail: ${r.cause}"
}
fun main() {
println(describe(HttpResponse.Ok("hello")))
}Modelar árboles recursivos
Los tipos sealed describen de forma natural estructuras recursivas, como los árboles de expresiones.
sealed class Expr {
data class Num(val value: Int) : Expr()
data class Add(val left: Expr, val right: Expr) : Expr()
data class Mul(val left: Expr, val right: Expr) : Expr()
}
fun eval(e: Expr): Int = when (e) {
is Expr.Num -> e.value
is Expr.Add -> eval(e.left) + eval(e.right)
is Expr.Mul -> eval(e.left) * eval(e.right)
}
fun main() {
val expr = Expr.Add(Expr.Num(3), Expr.Mul(Expr.Num(4), Expr.Num(5)))
println(eval(expr)) // 23
}Combinar con genéricos
Los tipos sealed pueden ser genéricos, lo que permite crear contenedores de resultados tipados como Result<T>.
sealed class ApiResult<out T> {
data class Success<T>(val data: T) : ApiResult<T>()
data class Failure(val message: String) : ApiResult<Nothing>()
}
fun handle(r: ApiResult<String>) = when (r) {
is ApiResult.Success -> "got ${r.data}"
is ApiResult.Failure -> "err: ${r.message}"
}
fun main() {
println(handle(ApiResult.Success("hi")))
println(handle(ApiResult.Failure("nope")))
}Antipatrón: anidamiento excesivo
El anidamiento profundo oculta la intención. Si un árbol sealed tiene más de dos niveles, considere aplanarlo o extraer los subárboles a sus propios archivos.
sealed class Top {
sealed class Mid : Top() {
sealed class Deep : Mid() {
object Leaf : Deep()
}
}
}
fun main() {
val l = Top.Mid.Deep.Leaf
println(l::class.simpleName)
}Combinar mediante composición
Cuando dos dimensiones del estado son independientes, prefiera la composición (una data class que envuelva dos valores sealed) a las jerarquías profundamente anidadas.
sealed class Loading { object Active : Loading(); object Idle : Loading() }
sealed class Auth { data class Signed(val id: Int) : Auth(); object Anon : Auth() }
data class AppState(val loading: Loading, val auth: Auth)
fun main() {
val s = AppState(Loading.Active, Auth.Signed(1))
println(s)
}Comprobación rápida
¿Cuál es el enfoque recomendado cuando dos dimensiones del estado son independientes?
Resumen
Anide tipos sealed para representar estados en forma de árbol; combine jerarquías sealed independientes mediante composición (una data class envolvente). Añada propiedades comunes a una base sealed, utilice genéricos para obtener resultados tipados y modele las estructuras recursivas de forma natural. Mantenga el anidamiento superficial.
Preguntas frecuentes
¿La lección «Anidar y combinar jerarquías selladas» es gratis?
Sí — el texto completo de «Anidar y combinar jerarquías selladas» 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 «Anidar y combinar jerarquías selladas»?
Construya máquinas de estados complejas anidando tipos sellados. 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 «Anidar y combinar jerarquías selladas»?
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
- sealed class frente a sealed interface: cuándo usar cada una
- when exhaustivo con jerarquías selladas
- Modelar el estado de la interfaz con clases selladas
- Anidar y combinar jerarquías selladas