Steps

1. How to create an Enumeration
As a reminder, and as per the Scala documentation, the Enumeration class is designed to be fairly lightweight as opposed to using case classes. To define an enumeration for a given domain, you basically need to extend the Enumeration class. In the example below, we are making use of a Singleton Object named Donut, which extends Enumeration, and thereafter provides various distinct values that make up different types of Donut.

println("Step 1: How to create an enumeration")
object Donut extends Enumeration {
  type Donut = Value

  val Glazed      = Value("Glazed")
  val Strawberry  = Value("Strawberry")
  val Plain       = Value("Plain")
  val Vanilla     = Value("Vanilla")
}

You can access each corresponding value explicitly, such as, Donut.Vanilla. You can further add an import statement - that is, import Donut._ - and then access each of the values directly. In addition, you benefit from a built-in id property, and it identifies a given value from the underlying enumerated values.

println(s"Vanilla Donut string value = ${Donut.Vanilla}")
println(s"Vanilla Donut's id = ${Donut.Vanilla.id}")

You should see the following output when you run your Scala application in IntelliJ:

Step 1: How to create and use an enumeration 
Vanilla Donut string value = Vanilla
Vanilla Donut’s id = 3

It is worth noting that the Vanilla id is at location 3 because the initial index for the enumerated values is zero based. That is, val Glazed is at index 0, val Strawberry is at index 1, and val Plain is at index 2, respectively.

2. Defining Algebraic Data Types using sealed traits

In most real-world production Scala code, the above Enumeration class has faced a fair bit of criticism over the years. Amongst others, perhaps a compelling one is that you do not benefit from the relevant type safety over exhaustive checking against valid enumerated values. After all, Scala is all about type safety as a first class citizen in the programming language.

As an alternative, and especially if you are modeling a particular Algebraic Data Type, short for ADT, you can use a sealed trait paired with case object. This approach will take full advantage of the compile time exhaustive checking, and can therefore be rather practical in, say, Pattern Matching. For illustration purposes, we show an ADT from our Akka tutorial. The ADT is designed for message passing with an Akka Actor using, say, Akka’s Tell Pattern. Consider, for instance, sending a BakeDonut event to an Actor named donutActor - that is, donutActor ! BakeDonut. That being said, we define a base sealed trait named BakingEvents, and represent each enumerated value using case object that extends the base trait.

println("\nStep2: Defining Algebraic Data Types using sealed traits")
sealed trait BakingEvents 
final case object BakeDonut extends BakingEvents 
final case object AddTopping extends BakingEvents 
final case object StopBaking extends BakingEvents 

Next, we create a method that will Patter Match on BakingEvents, and will output the corresponding event.

def prettyPrintBakingEvent(bakingEvent: BakingEvents): Unit = bakingEvent match{ 
case BakeDonut => println("BakeDonut event was used in Pattern Matching")
case AddTopping => println("AddTopping event was used in Pattern Matching") 
case StopBaking => println("StopBaking event was used in Pattern Matching") 
} 

And, finally, you can call the above method, such as, prettyPrintBakingEvent(BakeDonut).
You should see the following output when you run your Scala application in IntelliJ:

Step 2: Defining Algebraic Data Types using sealed traits 
BakeDonut event was used in Pattern Matching

3. Upcoming Scala 3 enum keyword

As we've previously mentioned, Scala 3 will bring forward a new enum keyword to facilitate enum, or enumeration, or ADT creation. For instance, in Scala 3, we should be able to model the above BakingEvents ADT as follows:

enum BakingEvents {
  case BakeDonut, AddTopping, StopBaking
}

And that is without any doubt a lot simpler and much nicer to use, while retaining the full functionality of an enumeration. Besides, you will be able to, for instance, change the default zero based index of the subsequent enumerated types as follows:

enum BakingEvents(val index: Int) {
  case BakeDonut extends BakingEvents(1)
  case AddTopping extends BakingEvents(2)
  case StopBaking extends BakingEvents(3)
}