Scala for Backend Engineering & Functional Programming · Lección

Enums en Scala 3

Nueva sintaxis de enum

Enums en Scala 3 es una lección gratuita de Scala for Backend Engineering & Functional Programming en CoddyKit. Esta es la lección 2 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.

La nueva palabra clave enum

Scala 3 incorpora una construcción enum de primera clase. Sustituye el patrón más verboso de trait sellado más objetos case de Scala 2 por una sintaxis concisa.

Cada caso se convierte en un valor del tipo enum.
El compilador genera automáticamente utilidades prácticas.

enum Color:
  case Red, Green, Blue

object Main:
  def main(args: Array[String]): Unit =
    println(Color.Red)

Listado de todos los valores

Cada enum simple obtiene un companion con values (un array con todos los casos) y valueOf (búsqueda por nombre).

enum Color:
  case Red, Green, Blue

object Main:
  def main(args: Array[String]): Unit =
    Color.values.foreach(println)
    println(Color.valueOf("Green"))

Ordinal y nombre

Cada valor de un enum tiene un ordinal (posición basada en cero) y un toString generado que usa el nombre de su caso.

enum Color:
  case Red, Green, Blue

object Main:
  def main(args: Array[String]): Unit =
    println(Color.Blue.ordinal)
    println(Color.Red.ordinal)

Enums con parámetros

Los casos de un enum pueden aceptar parámetros del constructor, lo que permite asociar datos a cada valor. Esto resulta útil para almacenar constantes como códigos RGB o masas planetarias.

enum Planet(val mass: Double):
  case Earth extends Planet(5.97e24)
  case Mars  extends Planet(6.42e23)

object Main:
  def main(args: Array[String]): Unit =
    println(Planet.Earth.mass)
    println(Planet.Mars.mass)

Métodos en enums

Puede definir métodos dentro del cuerpo de un enum. Están disponibles en todos los valores, como los métodos de una clase.

enum Direction:
  case North, South, East, West
  def opposite: Direction = this match
    case North => South
    case South => North
    case East  => West
    case West  => East

object Main:
  def main(args: Array[String]): Unit =
    println(Direction.North.opposite)

Enums ADT genéricos

Los enums pueden ser genéricos y estar parametrizados, lo que permite modelar tipos de datos algebraicos. Este es un tipo Option simplificado.

enum Maybe[+A]:
  case Just(value: A)
  case Nothing

object Main:
  def main(args: Array[String]): Unit =
    val a: Maybe[Int] = Maybe.Just(42)
    println(a)

Enums ADT recursivos

Los enums resultan especialmente útiles para estructuras recursivas. Un árbol binario o una lista enlazada se expresa claramente como un conjunto de casos.

enum Tree[+A]:
  case Leaf(value: A)
  case Branch(left: Tree[A], right: Tree[A])

object Main:
  def main(args: Array[String]): Unit =
    val t = Tree.Branch(Tree.Leaf(1), Tree.Leaf(2))
    println(t)

Coincidencia de patrones en enums

Como los enums son sellados, el compilador puede comprobar que un match sea exhaustivo. Si falta un caso, se muestra una advertencia.

enum Light:
  case Red, Yellow, Green

object Main:
  def action(l: Light): String = l match
    case Light.Red    => "stop"
    case Light.Yellow => "slow"
    case Light.Green  => "go"

  def main(args: Array[String]): Unit =
    println(action(Light.Green))

Enums compatibles con Java

Añada el comportamiento de extends java.lang.Enum derivando automáticamente de scala.reflect.Enum; para una interoperabilidad real con Java, escriba enum X extends Enum[X]... pero la mayoría del código usa simplemente la forma normal, que ofrece una buena interoperabilidad con Java cuando es necesario.

enum Suit:
  case Hearts, Diamonds, Clubs, Spades

object Main:
  def main(args: Array[String]): Unit =
    println(Suit.values.length)
    println(Suit.Spades.ordinal)

Combinación de campos y métodos

Puede combinar casos parametrizados con métodos compartidos para crear modelos de dominio completos.

enum Currency(val symbol: String):
  case USD extends Currency("$")
  case EUR extends Currency("\u20ac")
  def format(amount: Double): String = s"$symbol$amount"

object Main:
  def main(args: Array[String]): Unit =
    println(Currency.USD.format(9.99))

Cuándo usar enum

Use enum cuando tenga un conjunto cerrado de opciones o un tipo de datos algebraico.

Casos simples para enumeraciones normales.
Casos parametrizados para ADT y tipos suma.
Las comprobaciones de exhaustividad integradas hacen que las refactorizaciones sean seguras.

enum Result[+E, +A]:
  case Ok(value: A)
  case Err(error: E)

object Main:
  def main(args: Array[String]): Unit =
    val r: Result[String, Int] = Result.Ok(7)
    println(r)

Comprobación rápida

Compruebe su comprensión de los enums de Scala 3.

Resumen

Ha aprendido los enums de Scala 3.

El enum conciso sustituye el código repetitivo de los traits sellados.
Los enums simples obtienen values, valueOf y ordinal.
Los casos pueden aceptar parámetros para asociar datos.
Los enums genéricos y recursivos permiten modelar ADT.
Su naturaleza sellada permite realizar coincidencias de patrones exhaustivas.

enum Weekday:
  case Mon, Tue, Wed, Thu, Fri
  def isStart: Boolean = this == Mon

object Main:
  def main(args: Array[String]): Unit =
    println(Weekday.Mon.isStart)
    println(Weekday.values.length)

Preguntas frecuentes

¿La lección «Enums en Scala 3» es gratis?

Sí — el texto completo de «Enums en Scala 3» 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 «Enums en Scala 3»?

Nueva sintaxis de enum 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 2 de 4.

¿Cuánto tiempo toma la lección «Enums en Scala 3»?

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

← Volver a Scala for Backend Engineering & Functional Programming