Composición de dominios
Construir modelos más grandes
Composición de dominios es una lección gratuita de Scala for Backend Engineering & Functional Programming 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 Scala for Backend Engineering & Functional Programming, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Scala for Backend Engineering & Functional Programming incluye 4 lecciones en total.
Construir modelos más grandes
Los dominios reales se construyen a partir de piezas más pequeñas. Componer dominios significa combinar ADT, newtypes y valores validados bien modelados en estructuras mayores que siguen siendo correctas.
- Los tipos pequeños y centrados se combinan para formar otros mayores.
- Cada pieza conserva sus propias invariantes.
case class Money(cents: Long)
case class Product(name: String, price: Money)
object Main:
def main(args: Array[String]): Unit =
println(Product("Book", Money(1999)))Anidar productos
Componga tipos producto anidando case classes. Cada nivel añade estructura sin perder legibilidad.
case class Address(city: String, zip: String)
case class Customer(name: String, address: Address)
object Main:
def main(args: Array[String]): Unit =
val c = Customer("Ada", Address("London", "E1"))
println(c.address.city)Componer con colecciones
Use List, Map y Set para modelar relaciones de uno a muchos dentro del dominio.
case class Item(name: String, qty: Int)
case class Order(id: Int, items: List[Item])
object Main:
def main(args: Array[String]): Unit =
val order = Order(1, List(Item("pen", 2), Item("ink", 1)))
println(order.items.map(_.qty).sum)Componer tipos suma
Las elecciones grandes combinan otras más pequeñas. Una variante de enum puede contener a su vez otro ADT, formando capas de decisiones.
enum Payment:
case Card(last4: String)
case Cash
enum Checkout:
case Completed(payment: Payment)
case Abandoned
object Main:
def main(args: Array[String]): Unit =
val c: Checkout = Checkout.Completed(Payment.Card("1234"))
println(c)Funciones que componen dominios
Las operaciones del dominio son funciones puras que transforman tipos de entrada en tipos de salida. Componerlas permite construir flujos de trabajo.
case class Cart(total: Long)
case class Receipt(total: Long, tax: Long)
object Main:
def checkout(c: Cart): Receipt =
Receipt(c.total, (c.total * 0.2).toLong)
def main(args: Array[String]): Unit =
println(checkout(Cart(1000)))Componer validaciones
Cuando cada campo se construye mediante un constructor inteligente, puede combinarlos con una expresión for. El objeto completo solo se crea si todas las partes superan la validación.
object V:
def name(s: String): Option[String] = if s.nonEmpty then Some(s) else None
def age(n: Int): Option[Int] = if n >= 0 then Some(n) else None
case class Person(name: String, age: Int)
object Main:
def make(n: String, a: Int): Option[Person] =
for nm <- V.name(n); ag <- V.age(a) yield Person(nm, ag)
def main(args: Array[String]): Unit =
println(Main.make("Bob", 30))
println(Main.make("", 30))Plegar datos compuestos
Agregue estructuras compuestas con fold o con map más sum. La forma de los datos guía el cálculo.
case class Line(price: Long, qty: Int)
case class Invoice(lines: List[Line])
object Main:
def total(inv: Invoice): Long =
inv.lines.foldLeft(0L)((acc, l) => acc + l.price * l.qty)
def main(args: Array[String]): Unit =
val inv = Invoice(List(Line(100, 2), Line(50, 4)))
println(total(inv))Actualizar modelos inmutables
Componga cambios con copy, que devuelve un valor nuevo con determinados campos reemplazados. El original permanece intacto.
case class Account(id: Int, balance: Long)
object Main:
def deposit(a: Account, amt: Long): Account =
a.copy(balance = a.balance + amt)
def main(args: Array[String]): Unit =
val a = Account(1, 100)
println(deposit(a, 50))Modelar una máquina de estados
Combine tipos suma y funciones de transición para modelar una máquina de estados en la que solo existan transiciones válidas.
enum Light:
case Red, Green, Yellow
object Main:
def next(l: Light): Light = l match
case Light.Red => Light.Green
case Light.Green => Light.Yellow
case Light.Yellow => Light.Red
def main(args: Array[String]): Unit =
println(next(Light.Red))
println(next(Light.Green))Separar el dominio y las operaciones por capas
Mantenga puros los tipos de datos y coloque el comportamiento en funciones o métodos. Un modelo compuesto junto con un conjunto de transformaciones forma una pequeña biblioteca de dominio.
case class Temp(celsius: Double):
def toF: Double = celsius * 9 / 5 + 32
object Main:
def main(args: Array[String]): Unit =
val t = Temp(25.0)
println(t.toF)Integrarlo todo
Un modelo completo combina newtypes, productos, sumas, colecciones y construcción validada. El resultado es difícil de usar incorrectamente y fácil de comprender.
- Construya primero tipos pequeños.
- Combínelos para formar agregados.
- Exprese las operaciones como funciones puras.
case class Sku(value: String)
case class Line(sku: Sku, qty: Int)
case class Basket(lines: List[Line]):
def count: Int = lines.map(_.qty).sum
object Main:
def main(args: Array[String]): Unit =
val b = Basket(List(Line(Sku("A"), 2), Line(Sku("B"), 3)))
println(b.count)Comprobación rápida
Compruebe su comprensión de la composición de dominios.
Resumen
Ha aprendido a componer dominios.
- Anide productos y sumas para modelar estructuras complejas.
- Use colecciones para las relaciones de uno a muchos.
- Componga validaciones con expresiones
for. - Actualice de forma inmutable mediante
copy. - Mantenga puros los datos y exprese las operaciones como funciones.
case class User(id: Int, name: String)
case class Post(author: User, text: String)
object Main:
def main(args: Array[String]): Unit =
val p = Post(User(1, "Ada"), "hello")
println(p.copy(text = "hi"))
Aprende Scala con un tutor de IA — gratis
Escribe y ejecuta código real en tu navegador, obtén ayuda instantánea de un tutor de IA disponible 24/7 y continúa donde lo dejaste en la web o en la aplicación.
- Cursos
- 39
- Lecciones
- 143
Preguntas frecuentes
¿La lección «Composición de dominios» es gratis?
Sí — el texto completo de «Composición de dominios» 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 Scala for Backend Engineering & Functional Programming, actualiza a CoddyKit PRO. El curso de Scala for Backend Engineering & Functional Programming incluye 4 lecciones en total.
¿Qué aprenderé en «Composición de dominios»?
Construir modelos más grandes Practicas Scala for Backend Engineering & Functional Programming 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 Scala for Backend Engineering & Functional Programming?
No se requiere experiencia previa. Scala for Backend Engineering & Functional Programming 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 «Composición de dominios»?
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 Scala for Backend Engineering & Functional Programming?
Sí. Cada lección de Scala for Backend Engineering & Functional Programming 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
- Modelado con ADT
- Constructores inteligentes
- Newtypes
- Composición de dominios