Have you ever wanted something like a case class, that magically provides decent (for some definition of decent) implementations of methods like equals and hashCode, but without all of the restrictions? I know that I have. Frequently. And recently I ran into an answer on StackOverflow that gave me an idea for how to do it. The trick is to play with Products. I'm not sure how good of an idea it is, but I figure the Internet will tell me. Here's the basic idea:
import scala.runtime.ScalaRunTime
trait ProductMixin extends Product {
def canEqual(other: Any) = toProduct(other) ne null
protected def equalityClass = getClass
protected def equalityClassCheck(cls: Class[_]) = equalityClass.isAssignableFrom(cls)
protected def toProduct(a: Any): Product = a match {
case a: Product if productArity == a.productArity && equalityClassCheck(a.getClass) => a
case _ => null
}
override def equals(other: Any) = toProduct(other) match {
case null => false
case p if p eq this => true
case p => {
var i = 0
var r = true
while(i < productArity && r) {
if (productElement(i) != p.productElement(i)) r = false
i += 1
}
r
}
}
override def productPrefix = try {
getClass.getSimpleName()
} catch {
//workaround for #4118, so classes can be defined in the REPL that extend ProductMixin
case e: InternalError if e.getMessage == "Malformed class name" => getClass.getName()
}
override def hashCode = ScalaRunTime._hashCode(this)
override def toString = ScalaRunTime._toString(this)
}
Basic Usage
There's a couple ways to use ProductMixin. The first, and probably the simplest, is to extends one of the ProductN classes and provide the appropriate defs:
class Cat(val name: String, val age: Int) extends Product2[String, Int] with ProductMixin {
def _1 = name
def _2 = age
}
The second way is to provide them yourself:
class Dog(val name: String, age: Int) extends ProductMixin {
def productArity = 2
def productElement(i: Int) = i match {
case 0 => name
case 1 => age
}
}
Either way, the result is something that has many of the benefits of case classes but allows for more flexibility. Here's some sample usage:
scala> val c1 = new Cat("Felix", 2)
val c1 = new Cat("Felix", 2)
c1: Cat = Cat(Felix,2)
scala> val c2 = new Cat("Alley Cat", 1)
val c2 = new Cat("Alley Cat", 1)
c2: Cat = Cat(Alley Cat,1)
scala> val c3 = new Cat("Alley Cat", 1)
val c3 = new Cat("Alley Cat", 1)
c3: Cat = Cat(Alley Cat,1)
scala> c2 == c3
c2 == c3
res0: Boolean = true
scala> c1 == c2
c1 == c2
res1: Boolean = false
Dealing with Inheritance
Equality in the presence of inheritance is very tricky. But, possibly foolishly, ProductMixin makes it easy! Let's say you have a hierarchy, and you want all the classes under some root class to be able to equal each other. Here's how it would be done by overriding the equalityClass so that it is the root of the hierarchy (using a not-so-good example):
scala> abstract class Animal(val name: String, val age: Int) extends Product2[String, Int] with ProductMixin {
| override protected def equalityClass = classOf[Animal]
| def _1 = name
| def _2 = age
| }
defined class Animal
scala> class Dog(name: String, age: Int) extends Animal(name, age)
class Dog(name: String, age: Int) extends Animal(name, age)
defined class Dog
scala> class Cat(name: String, age: Int) extends Animal(name, age)
class Cat(name: String, age: Int) extends Animal(name, age)
defined class Cat
scala> val c = new Cat("Felix", 1)
val c = new Cat("Felix", 1)
c: Cat = Cat(Felix,1)
scala> val d = new Dog("Felix", 1)
val d = new Dog("Felix", 1)
d: Dog = Dog(Felix,1)
scala> c == d
c == d
res0: Boolean = true
The reverse can also be accomplished by overriding equalityClassCheck such that it checks that the classes are equal instead of using isAssignableFrom. That would mean two objects could be equal if and only if they are the same class.
Wrapup
I don't know to what extent this is a good idea. I've only tested it a bit in the REPL. It's neat, but there is one problem that comes to mind: performance. Any primitive members that are elements of the product will end up being boxed prior to usage in the hashCode and equality methods, the extra layers of indirection aren't free, and neither is the loop. That being said, case classes use the exact same method for hashing, so in what way they pay the same penalty, and unless code is really hashing and equality heavy it probably wouldn't be noticeable.
Sphere: Related Content
