idiomatic scala/FP way of expressing similar value objects - scala

Question

I am wondering what is the idiomatic way to express similar messages (value objects)
Let's say I have some messages that I want to send : UserEnter, UserLeft, UserSendGreeting etc'. I hope that the following can express my dilemma
there are two options that I think one can express it :
trait UserAction
case class UserEnter (username:String,hour:Long,day:WeekDay,room:Int)
case class UserLeft (username:String,hour:Long,day:WeekDay,room:Int)
case class UserSendGreeting (username:String,,hour:Long,day:WeekDay,greeting:String)
def foo(userActions:List[UserAction]) = {
userActions match {
case UserEnter(userName)::tail =>
sendWelcomeMessage(userName)
handleOtherActions(tail)
case UserLeft::tail => "must enter first"
case _ => "do something else"
}
another way is :
trait Action
case class Enter(room:Int) extends Action
case object Left(room:Int) extends Action
case object Greet(msg:String) extends Action
case class UserAction(username:String,action:Action,,hour:Long,day:WeekDay)
def foo(userActions:List[UserAction]) = {
userActions match {
case head::tail if head.action == Enter =>
sendWelcomeMessage(head.userName)
handleOtherActions(tail)
case head::tail if head.action == Left => "must enter first"
case _ => "do something else"
}
The 1st option is more explicit and easier to pattern match but more repetitive code.
The other one is more explicit on the action itself but pattern match is more verbose
which way is better ?

Answer 1

Don't overcomplicate things. If you need to have a pair of User (in your case string name) and Action, use Tuple. Also it makes sense to gather all "...other attributes" inside corresponding Action.
type User = String
sealed trait Action
case class Enter(room:Int) extends Action
case class Left(room:Int) extends Action
case class Greet(msg:String) extends Action
def foo(userActions:List[(User, Action)]) = userActions match {
case (username, _:Enter)::tail =>
sendWelcomeMessage(username)
handleOtherActions(tail)
case (username, _:Left)::tail => "must enter first"
case _ => "do something else"
}
Also don't forget, that pattern matching allows you to unapply hierarchies of arbitrary depth:
case (username, Enter(room))::tail =>

Answer 2

I think the 1 way is better but you can make a constraint on UserAction trait to have username field:
trait UserAction {
def username: String
}
case class UserEnter(username:String, room:Int)
case class UserLeft(username:String, room:Int)
case class UserSendGreeting(username:String, greeting:String)
This way it is easy to
1) pattern match
2) use generic UserAction to get username field

Answer 3

How about: case class UserAction(user: User, action: Action)
def foo(actions: Seq[UserActions]) = actions match {
case UserAction(user, _: EnterAction)::tail =>
processEnter(user)
handleOtherActions(tail)
case UserExit(user, _: ExitAction)::tail => processExit(user)
...
}
Or even better
def foo(actions: Seq[UserAction]) = actions.find { ua =>
!ua.action.process(ua.user)
}
Or, maybe, just
def foo(action: Seq[UserAction]) = actions.find { !_.process }