Scala: How to define a method that returns a instance of subclass

Question

In the project that I am working on, there is some code that is essentially as follows:

sealed trait Character {
  def tags: Seq[String]
  def life: Int
  // other defs
}
object Character {
  def addTag[T <: Character](character: T, tag: String): T = {
    val newTags = character.tags :+ tag
//    character.copy(tags = newTags)  // this doesn't compile

    character match {
      case c: Person => c.copy(tags = newTags).asInstanceOf[T]
      case c: Beast => c.copy(tags = newTags).asInstanceOf[T]
      // ten more cases to match each subclass
      ......
      case _ => character
    }
  }
}

case class Person(title: String,
                  firstName: String,
                  lastName: String,
                  tags: Seq[String],
                  life: Int,
                  weapon: String
                 ) extends Character
case class Beast(name: String,
                 tags: Seq[String],
                 life: Int,
                 weight: Int
                ) extends Character
// ten other case classes that extends Character
......

The code works, but the addTag method doesn't look very pretty for two reasons: first, it uses asInstanceOf; second, it has many lines of case c: ...... each of which are almost the same.

Is there a way to make the code better?

Answer 1

Since the copy method is specific to each case class (takes different parameters) it can't be used from a superclass. What you could do is:

  sealed trait Character {
    def tags: Seq[String]

    def life: Int

    // other defs
  }

  trait Taggable[T <: Character] {
    def addTags(t: T, newTags: Seq[String]): T
  }

  object Character {
    def addTag[T <: Character: Taggable](character: T, tag: String): T = {
      val newTags = character.tags :+ tag
      implicitly[Taggable[T]].addTags(character, newTags)
    }
  }

  case class Person(title: String,
                    firstName: String,
                    lastName: String,
                    tags: Seq[String],
                    life: Int,
                    weapon: String
                   ) extends Character

  object Person {
    implicit val taggable: Taggable[Person] = new Taggable[Person] {
      override def addTags(t: Person, newTags: Seq[String]): Person = t.copy(tags = newTags)
    }
  }

  case class Beast(name: String,
                   tags: Seq[String],
                   life: Int,
                   weight: Int
                  ) extends Character

  Character.addTag(Person("", "", "", Seq(), 1, ""), "")
//  Character.addTag(Beast("", Seq(), 1, 1) // needs implicit as well

This uses the Taggable typeclass that must be implemented by every subclass.