Enums

The enum class is abstract (new Season fails with error E042, "Season is abstract; it cannot be instantiated"), so the cases listed in the body are the only instances.

The cases are compared by identity: Season.valueOf("Spring") eq Season.Spring is true, and so is ==.

An enum extending another enum is rejected by the compiler ("extending enums is prohibited").

An enum is not Comparable and not Ordered. Order by ordinal, as the last line of the example does, or provide an Ordering in the companion (see below).

Every enum extends the trait scala.reflect.Enum, which declares ordinal. The cases are also Product and Serializable (both isInstanceOf tests are true on 3.10.0), which is why a case with fields has a case-class-like toString.

The parameters of the enum are visible as members only when declared val (or var, private val, and so on), as for any class. Here label and speedFactor are val`s, so `Surface.Gravel.label works.

A case with no arguments that does not call a constructor (case Spring) is allowed only when the enum has no constructor parameters. In an enum with parameters every case must supply arguments, either with extends Surface(...) or because the case has its own parameter list (see the next section). The compiler stops at the first case that omits them:

-- [E171] Type Error: k.scala:12:2
12 |  case Plain
   |  ^
   |missing argument for parameter mass of constructor Planet in class Planet: (mass: Double): trailhead.Planet

Members such as isLoose are defined in the enum body after the cases. They are normal members and are inherited by every case.

An enum may extend a trait or a class, as in enum Surface(val label: String) extends Describable. The members of the trait are then available on every case, and a case may override toString or other members through the enum body.

The enum body can be given a companion object Surface, which can hold helpers such as fromLabel. The companion coexists with the compiler-generated members values, valueOf and fromOrdinal.

derives CanEqual makes the enum usable under -language:strictEquality (see Multiversal Equality). Enums derive other type classes in the same way (see Type Class Derivation).

Overriding toString in the enum body changes the printed form of every case, because the cases inherit it. The example prints PAVED for Surface.Paved, not Paved, and valueOf still takes the case name "Paved".

Inside the companion, the cases are in scope unqualified (Summer in warm), and values can be called without a prefix.

A singleton case assigned to a val without an annotation is widened to the enum type. On 3.10.0 val w = Mode.Walk has the type Mode, and List(Mode.Walk, Mode.Ski(true)) has the element type Mode. A parameterized case such as Mode.Ski(true) is also typed as Mode.

The qualified name Mode.Walk.type exists, but a value typed as the enum is not a Mode.Walk.type. The compiler reports error E007 (type mismatch) with Found: Mode and Required: Mode.Walk.

Singleton cases print as their name, parameterized cases as Name(args).

An import import Mode.* brings every case into scope unqualified, and the enum cases can then be used as Walk or Ski(true). The case constructors can also be called without new, because the enum generates apply methods.

The cases form a closed set, so a match on the enum is checked for exhaustivity:

//> using scala 3.10.0

package trailhead

enum Mode:
  case Walk, Run
  case Ski(fast: Boolean)

def pace(m: Mode): Int = m match
  case Mode.Walk => 5
  case Mode.Run => 10

@main def run(): Unit =
  println(pace(Mode.Walk))

-- [E029] Pattern Match Exhaustivity Warning: e.scala:9:25
9 |def pace(m: Mode): Int = m match
  |                         ^
  |                      match may not be exhaustive.
  |
  |                      It would fail on pattern case: trailhead.Mode.Ski(_)
  |
  | longer explanation available when compiling with `-explain`
1 warning found
5

An enum is abstract: new Season fails with error E042, "Season is abstract; it cannot be instantiated".

An enum cannot be extended by another enum: the compiler reports "extending enums is prohibited".

In an enum with constructor parameters, every case must supply arguments (E171, shown above).

An enum that extends java.lang.Enum cannot have parameterized cases (shown below).

All cases of an enum that extends java.lang.Enum must be singletons. A parameterized case is rejected:

-- Error: m.scala:7:7
7 |  case High(n: Int)
  |  ^^^^^^^^^^^^^^^^^
  |  parameterized case is not allowed in an enum that extends java.lang.Enum

The enum can still declare parameters and members, as the simple enums above, as long as the cases are singletons.

Java APIs that take an Enum type, such as EnumMap and EnumSet in the example, accept Level. The Java side of this interaction is covered in Calling Scala from Java and the reverse direction, Java enums used from Scala, in Using Java from Scala.

A fixed list of constants, possibly with fields: simple or parameterized enum.

A closed set of alternatives where some carry data: a mixed enum or a sealed trait with case classes and case objects.

Alternatives that must be extended in other files or modules: a sealed trait cannot (it is limited to its file); use a non-sealed trait or an open class instead.

One record type: a case class (see Case Classes).

Interop with Java enum APIs (EnumMap, EnumSet, JPA, annotations): extends java.lang.Enum[E] with singleton cases only.

The enum construct, values, valueOf, fromOrdinal, ordinal, parameterized and Java-compatible enums, and the compiler messages quoted above come from Scala 3.0 and the 3.3 LTS line, and are the same on the 3.9 LTS and on 3.10.

The messages in this page were produced by 3.10.0. The exact wording and the error numbers (E007, E008, E029, E042, E171) may differ slightly between releases.

scala.Enumeration is still in the Scala API documentation and compiled unchanged on 3.10.0 in the run above.

Books written for Scala 2 teach Enumeration or sealed trait plus case object as the only forms. Both still work, but the enum keyword replaces them in new code.

Books that show enums with the values method on a mixed enum are wrong: values and valueOf exist only when all cases are singletons, as the E008 error above shows.

The braces around the case lines are optional in Scala 3, and the examples use the indentation form.

Scala 2.13 books describe Enumeration#Value ids as the way to order values; use ordinal and an Ordering in the companion for an enum.

Scala 3 Book: Domain modeling tools, enums

Scala 3 Book: Additional enum features

Scala 3 Book: Compatibility with Java enums

Scala 3 Reference: Enumerations

Scala 3 Reference: Algebraic data types

Scala 3 Reference: Translation of enums and ADTs

Scala 3 Reference: E007 Type Mismatch

Scala 3 Reference: E008 Not Found

Scala 3 Reference: E029 Pattern Match Exhaustivity

Scala 3 Reference: E042 Cannot Instantiate Abstract Class

Scala 3 Reference: E171 Missing Argument

Scala API: scala.Enumeration

Scala API: scala.reflect.Enum