Python scala enums adts

Python Enums & Dataclasses to Scala ADTs

Python Enum → Scala sealed abstract class + case objects

Python:

class TokenType(Enum):
    STRING = "string"
    NUMERIC = "numeric"

Scala (2.13 idiomatic):

sealed abstract class TokenType(val value: String)
object TokenType {
  case object STRING extends TokenType("string")
  case object NUMERIC extends TokenType("numeric")
}

Why sealed abstract class: Scala 2.13 doesn't have enum (that's Scala 3). A sealed hierarchy gives exhaustive match checking and is the standard Scala 2 pattern.

Python dataclass(frozen=True) → Scala case class

Python:

@dataclass(frozen=True)
class Token:
    value: str
    token_type: TokenType
    metadata: dict[str, Any] = field(default_factory=dict)

Scala:

case class Token(
  value: String,
  tokenType: TokenType,
  metadata: Map[String, Any] = Map.empty
)

Key differences:

• Case classes are immutable by default (no frozen needed)
• field(default_factory=dict) becomes = Map.empty — Scala's default args are evaluated fresh each call
• Use camelCase for field names per Scala convention
• copy() is auto-generated and replaces manual with_metadata style methods, though a convenience method can wrap it

Python @dataclass (mutable) → Scala class with vars or mutable buffer

For mutable state, use var fields or mutable collections, and throw IllegalStateException for state violations:

class MutableTokenBatch {
  private val _tokens = scala.collection.mutable.ListBuffer.empty[Token]
  private var _processed = false

  def add(token: Token): Unit = {
    if (_processed) throw new IllegalStateException("Batch already processed")
    _tokens += token
  }
}

Python Optional/Union → Scala Option/Either

• Optional[X] / X | None → Option[X]
• Union[A, B] → Either[A, B] or a sealed trait hierarchy
• dict[str, Any] → Map[String, Any]