Scala for Backend Engineering & Functional Programming · Aula

Enums no Scala 3

Nova sintaxe de enumeração

Enums no Scala 3 é uma aula grátis de Scala for Backend Engineering & Functional Programming no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Scala for Backend Engineering & Functional Programming, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Scala for Backend Engineering & Functional Programming inclui 4 aulas no total.

Partes desta aula ainda não foram traduzidas e aparecem em inglês.

The New enum Keyword

Scala 3 adds a first-class enum construct. It replaces the verbose sealed-trait-plus-case-objects pattern from Scala 2 with concise syntax.

Each case becomes a value of the enum type.
The compiler generates useful helpers automatically.

enum Color:
  case Red, Green, Blue

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

Listing All Values

Every simple enum gets a companion with values (an array of all cases) and valueOf (lookup by name).

enum Color:
  case Red, Green, Blue

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

Ordinal and Name

Each enum value has an ordinal (zero-based position) and a generated toString using its case name.

enum Color:
  case Red, Green, Blue

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

Enums with Parameters

Enum cases can take constructor parameters, giving each value associated data. This is useful for storing constants like RGB codes or planet masses.

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)

Methods on Enums

You can define methods inside an enum body. They are available on every value, like methods on a class.

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)

Generic ADT Enums

Enums can be generic and parameterized, letting you model algebraic data types. Here is a simplified Option type.

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)

Recursive ADT Enums

Enums shine for recursive structures. A binary tree or linked list reads cleanly as a set of cases.

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)

Pattern Matching on Enums

Because enums are sealed, the compiler can check exhaustiveness of a match. Missing a case triggers a warning.

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))

Java-Compatible Enums

Add extends java.lang.Enum behavior by deriving from scala.reflect.Enum automatically; for true Java interop, write enum X extends Enum[X]... but most code just uses the plain form which interops well with Java when needed.

enum Suit:
  case Hearts, Diamonds, Clubs, Spades

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

Combining Fields and Methods

You can mix parameterized cases with shared methods for rich domain models.

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))

When to Use enum

Reach for enum when you have a closed set of choices or an algebraic data type.

Simple cases for plain enumerations.
Parameterized cases for ADTs and sum types.
Free exhaustiveness checks make refactors safe.

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)

Quick Check

Test your understanding of Scala 3 enums.

Recap

You learned Scala 3 enums.

Concise enum replaces sealed-trait boilerplate.
Simple enums get values, valueOf, and ordinal.
Cases may take parameters for associated data.
Generic and recursive enums model ADTs.
Sealed nature enables exhaustive pattern matching.

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)

Perguntas Frequentes

A aula “Enums no Scala 3” é grátis?

Sim — o texto completo de “Enums no Scala 3” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Scala for Backend Engineering & Functional Programming, atualize para CoddyKit PRO. O curso de Scala for Backend Engineering & Functional Programming inclui 4 aulas no total.

O que vou aprender em “Enums no Scala 3”?

Nova sintaxe de enumeração Você pratica Scala for Backend Engineering & Functional Programming com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Scala for Backend Engineering & Functional Programming?

Nenhuma experiência prévia é necessária. Scala for Backend Engineering & Functional Programming no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “Enums no Scala 3”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Scala for Backend Engineering & Functional Programming?

Sim. Cada aula de Scala for Backend Engineering & Functional Programming inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Scala for Backend Engineering & Functional Programming