Is there a way to implement a hierarchical enumeration in scala? - scala

Question

I am working in a project in which I need to tag the type of the received messages. Messages can come from different sources, but all these sources generate messages with the same conceptual type (so, the same meaning) but written in different ways.
For example from source1 I can receive
Source1:
{
"message_type": "typeA",
"value": 3
...
}
or
{
"message_type": "typeB",
"value": 3
...
}
But also from source2 I can receive
Source2:
{
"message_type": "A",
"value": 5
...
}
or
{
"message_type": "B",
"value": 2
...
}
I want to maximize the code reuse so I tried this solution.
The first scala file I created is a trait:
trait MessageType extends Enumeration {
val TYPE_A: Value
val TYPE_B: Value
}
then I implemented it in two object files:
object Source1MessageType extends MessageType{
override val TYPE_A: Value("typeA")
override val TYPE_B: Value("typeB")
object Source2MessageType extends MessageType{
override val TYPE_A: Value("A")
override val TYPE_B: Value("B")
So now what I want is to check the type of the message without knowing the source type, like this:
def foo(type: MessageType.Value) {
type match{
case MessageType.TYPE_A => ...do A action...
case MessageType.TYPE_B => ...do B action...
}
}
But if I write this code, the IDE (IntelliJ) highlights the parameter in red but it gives me no info about the error. It seems like I can use only Source1MessageType or Source2MessageType as parameter type.
I think the error is because Scala doesn't see the trait as an enumeration so I cannot access to the values of the enumeration.
Do you have any solution for that?

Answer 1

yes you can do hierarchical enumerations. So generally I would recommend against using Enumeration. Here's an article with why it's bad
https://medium.com/#yuriigorbylov/scala-enumerations-hell-5bdba2c1216
The most idiomatic way to do this is by leveraging sealed traits like this:
sealed trait MessageType{
def value:String
}
sealed trait MessageType1 extends MessageType
final case object TypeA extends MessageType1{
override def value:String = "typeA"
}
final case object TypeB extends MessageType1{
override def value:String = "typeB"
}
sealed trait MessageType2 extends MessageType
final case object A extends MessageType2{
override def value:String = "A"
}
final case object B extends MessageType2{
override def value:String = "B"
}
Note that all these definitions need to be in the same file. Now this works because sealed and final tells the compiler that inheritance can only happen in this file.
This means that given an instance of MessageType2 the compiler knows that it can only be either the object A or B it cannot be anything else (because of the sealed/final)
This gives you enums with exhaustiveness checks in patternmatching etc.

Answer 2

If "A" and "typeA" are names for the same message type then you need to deal with this when you read in the data. This means that you don't need any nesting in your enumeration.
trait MessageType
case object MessageTypeA extends MessageType
case object MessageTypeB extends MessageType
object MessageType {
def apply(s: String): MessageType =
s match {
case "A" | "typeA" => MessageTypeA
case "B" | "typeB" => MessageTypeB
case _ => throw BadMessageType
}
}
case class Message(msgType: MessageType, value: Int)
You can create the message type with MessageType(<string>) and it will return MessageTypeA or MessageTypeB as appropriate. You can use a normal match to determine which message type you have.
If you need to preserve the original string that generated the MessageType then you can store that as abstract value in the MessageType trait and fill it in when the appropriate instance is created:
trait MessageType {
def origin: String
}
case class MessageTypeA(origin: String) extends MessageType
case class MessageTypeB(origin: String) extends MessageType
object MessageType {
def apply(s: String): MessageType =
s match {
case "A" | "typeA" => MessageTypeA(s)
case "B" | "typeB" => MessageTypeB(s)
case _ => throw BadMessageType
}
}