Scala: referencing companion object from a child class

Question

I'm thinking of a following Scala class layout. I have a basic trait that represents an Item - an interface of what ought to be an immutable object that we can query for name, weight and do some object-specific stuff by invoking methods like equip:

trait Item {
  def name: String
  def weight: Int
  def equip // ... more abstract methods
}

I can create Item implementations, creating case classes by hand, but I'd like to have some sort of "dictionary"-based items - i.e. a static map holds mapping from type ID to values, name and weight methods just query the dictionary with a stored type ID:

object Weapon {
  final val NameDict = Map(1 -> "short sword", 2 -> "long sword")
  final val WeightDict = Map(1 -> 15, 2 -> 30)
}
case class Weapon(typ: Int) extends Item {
  import Weapon._
  def name = NameDict(typ)
  def weight = WeightDict(typ)
  def equip = ... // implementation for weapon
}

So far, so good. I can use Weapon(1) to reference an item object for "short sword". However, the same basic principle applies to any other item types, such as Armor, which uses exactly the same name and weight implementation, but completely different equip and other abstract methods implementation, for example:

object Armor {
  final val NameDict = Map(3 -> "bronze armor", 4 -> "iron armor")
  final val WeightDict = Map(3 -> 100, 4 -> 200)
}
case class Armor(typ: Int) extends Item {
  import Armor._
  def name = NameDict(typ)
  def weight = WeightDict(typ)
  def equip = ... // implementation for armor
}

Looks pretty similar to Weapon, isn't it? I'd like to factor out the common pattern (i.e. implementation of lookups in companion object dictionaries and common typ value) in something like that:

abstract class DictionaryItem(typ: Int) extends Item {
  def name = ???.NameDict(typ)
  def weight = ???.WeightDict(typ)
}

object Weapon {
  final val NameDict = Map(1 -> "sword", 2 -> "bow")
  final val WeightDict = Map(1 -> 15, 2 -> 30)
}
case class Weapon(typ: Int) extends DictionaryItem(typ) {
  def equip = ... // implementation for weapon
}

But how do I reference a children's companion object (like Weapon.NameDict) from parent class - i.e. what should I use instead of ???.NameDict(typ) and how do I explain to the compiler that children's companion object must include these dictionaries? Is there a better, more Scala-esque approach to such a problem?

Perhaps this is a related question you want to check out http://stackoverflow.com/questions/12179092/typing-over-companion-object-in-scala — Kane, Dec 01 '12 at 15:51

score 4 · Accepted Answer · edited May 23 '17 at 12:14

Instead of looking up the names and weights of items in maps, you could make use of instances of your case classes. In fact there are some good reasons you might want to take this approach:

Avoid Complexity: It's simple enough, you might not have needed to post this question about how inheritance works with companion classes.

Avoid Repetition: Using case classes, you would only have to define your items once.

Avoid Errors: Using synthetic keys, would require you to use the correct key in both the name and weight dictionaries. See item 2.

Write Idiomatic Code: Scala is both object-oriented and functional. In this case, orient yourself around the Item.

Avoid Overhead: Get all the item's properties with a single lookup.

Here's a different take in which Item plays the starring role:

package object items {
  val weapons = Weapon("halbred", 25) :: Weapon("pike", 35) :: Nil
  val armor = Armor("plate", 65) :: Armor("chainmail", 40) :: Nil
  val dictionary = (weapons ::: armor) map(item => item.name -> item) toMap
}

Notice that the names and weights are packaged in the instances instead of packaged as values in a map. And there are no indexes to manage. However, if you needed an index for some reason you could easily use the item's position in the list of equipment or add a property to the Item trait.

And, you might use it like this:

> items dictionary("halbred")        // Weapon(halbred, 25)
> items dictionary("plate") weight   // 65

One final note, the final keyword in the Scala word is kind of anachronistic. When you define a val in Scala, it's already immutable: Why are `private val` and `private final val` different?

Thanks for a full and concise answer - you see to be right, I've overengineered that stuff with maps! — GreyCat, Dec 03 '12 at 20:57
When you enumerate something (like kinds of weapons), you should encode it as an enumeration (in Scala, some prefer case objects). When you realize halbred should be halberd, you'll have to global replace (see item #2). Also, it's usual to use def in the trait; access is always via an accessor, so it's the same. (If you want interesting mix-ins later, using vals in traits is problematic. You can override def with val.) — som-snytt, Dec 04 '12 at 02:29
You're right, in either case the evaluation is the same since the case classes override the properties as vals. I have modified the answer to reflect this. It may be more appropriate to use case objects. — yakshaver, Dec 04 '12 at 04:38

score 2 · Answer 2 · answered Dec 01 '12 at 04:06

som-snytt is right - just make the Armor and Weapon objects extend a trait, say, Dictionary which has NameDict and WeightDict members, then have DictionaryItem(typ: Dictionary).

It seems like a pretty convoluted way of doing things though, and it's easy to make mistakes and hard to refactor if you make all your properties lookups by number. The more natural way would be to put the actual objects in the map, something like:

case class Weapon(name: String, weight: Int, equip: ...) extends Item
case class Armor(name: String, weight: Int, equip: ...) extends Item

val ShortSword = Weapon(name = "short sword",
                        weight = 15,
                        equip = ...)

val LongSword = Weapon("long sword", 20, ...)

val Weapons = Map(
  1 -> ShortSword,
  2 -> LongSword
)

so you'd write for example Weapons(1).name rather than Weapon.NameDict(1). Or, you could just write ShortSword.name. Or, if you only need to refer to them via their index, you could define the items directly in the Map.

score 1 · Answer 3 · answered Dec 01 '12 at 01:37

1

I think you want object Weapon extends Dictionary. I once called it an Armory, to mean a factory for arms. But any -ory or -ary will do. I would also change the integral typ to an Enumeration. Then define Weapon.apply(kind: Kind) to return a Sword when you Weapon(Kinds.Sword).

This pattern of factory methods on traits to be implemented by companion objects is used by the collections framework, which is educational.

answered Dec 01 '12 at 01:37

som-snytt

39,429
2
47
129

Thanks for showing object `extends` method - I'm really glad to see it working :) – GreyCat Dec 03 '12 at 20:59

Scala: referencing companion object from a child class

3 Answers3