Should I create traits to represent enum values for my models? - scala

Question

Say I have a model like:
case class User(
id: Int,
name: String,
userType: Int)
Should I then do this:
sealed trait UserType
case object Member() extends UserType
case object Anonymous() extends UserType
I should also somehow associate a value for each UserType.
I would then change the User case class to have a UserType property instead of the int?
I guess then I would create a implicit converter for slick, which I believe would be a MappedColumnType from int to UserType.
Update
This is for using slick db access.

Answer 1

I would do it the other way around. I would have a type for the user depending on the scenario that extends User:
sealed trait User
case class NormalUser(name: String, id: Int) extends User
case class SuperUser(name: String, id: Int, superPowers: Map[String, String]) extends User
And then pattern match on the actual User type when needed.

Answer 2

I'd go with enum:
object UserType extends Enumeration {
type UserType = Value
val Member = Value("Member")
val Anonymous = Value("Anonymous")
}
And the converter as you said:
implicit val userTypeColumnType = MappedColumnType.base[UserType, String](
userType => userType.toString,
UserType.withName
)
Then you can use userType: UserType in your User case class.
In table definition you can have def userType = column[UserType]("user_type")
Update
One of the reasons for choosing enum over trait is that slick is not able to find this implicit converter when you do not put the supertype explicitly.
E.g.
.filter(_.userType === Member)
yields
type mismatch;
[error] found : Member.type
[error] required: slick.lifted.Rep[?]
[error] .filter(_.userType === Member).result
But the following works
.filter(_.userType === Member.asInstanceOf[UserType])
.filter(_.userType === (Member : UserType))

Answer 3

As #Michal Tomanski mentioned below - there are certain problems when using trait / case objects. What you would need to do is this:
sealed trait UserType {
val code: Int
}
case object Member extends UserType {
override val code: Int = 0
}
case object Anonymous extends UserType {
override val code: Int = 1
}
object UserType {
def byId(id: Int): UserType = id match {
case Member.code => Member
case Anonymous.code => Anonymous
case _ => throw new IllegalArgumentException("...")
}
}
implicit val enumColumnType = MappedColumnType.base[UserType, Int](
e => e.code,
i => UserType.byId(i)
)
Above would allow you to do query like this:
UserTable
.filter(_.userType === (Member :: UserType))
.result
This is precisely what #Michal Tomanski pointed out. You can do small trick however to smoothen this up a little bit.
Just modify your trait like this:
sealed trait UserType {
val code: Int
// I added field below
val base: UserType = this
}
and then you can have your query like this:
UserTable
.filter(_.userType === Member.base)
.result
It may be slightly better alternative than casting.
Other than that - I'd follow #Michal Tomanski answer (using Enumeration) assuming that it is sufficient for your case (perhaps solution with trait / case objects is more flexible, but on the other hand there is more plumbing you need to do as can be seen in this answer).