scala case class hashcode with circular references - scala

Question

As Scala documentation says, "Case classes are compared by structure and not by reference".
I was trying to create a linked list with a loop in it, then add a node from this looped list to a mutable set. When using a regular class, it succeeded, but with a case class I hit a stack overflow.
I'm curious why Scala doesn't first check for reference before checking for structure. My thinking is that that if the reference is the same then the structure is guaranteed to be the same, so this can be a shortcut as well as allow for circular references.
Code:
object CaseClassHashcodeExample {
def main(args: Array[String]): Unit = {
val head = new ListNode(0)
head.appendToTail(1)
head.appendToTail(2)
head.appendToTail(3)
head.next.next.next = head.next
val set = collection.mutable.Set[ListNode]()
set.add(head)
assert(set(head))
}
}
case class ListNode(var data: Int, var next: ListNode = null) {
def appendToTail(d: Int): Unit = {
val end = new ListNode(d)
var cur = this
while (cur.next != null)
cur = cur.next
cur.next = end
}
}

Answer 1

I'm curious why Scala doesn't first check for reference before checking for structure
Well, what exactly do you want it to check? The current generated code looks something like
def hashCode() = 31 * data.hashCode() + next.hashCode()
One thing you could try is
def hashCode() = 31 * data.hashCode() + (if (next eq this) 0 else next.hashCode())
but it wouldn't actually help: in your case it isn't next which is the same as this, it's next.next.
next.hashCode doesn't know it's called from this.hashCode and so can't compare its own next to this.
You could create a helper method taking a set of "seen" objects into account:
def hashCode() = hashCode(Nil)
def hashCode(seen: List[ListNode]) = if (seen.exists(_ eq this)) 0 else 31 * data.hashCode() + next.hashCode(this :: seen)
But this both greatly slows down the common case, and is hard to actually get right.
EDIT: for equals, reference equality is checked first in case classes.
class NeverEq {
override def equals(other: Any) = false
}
case class Test(x: NeverEq)
val x = Test(new NeverEq())
println(x == x)
prints true and would be false if only structure was compared.
But it doesn't actually help with circular references. Let's say you have a ListNode type without data to simplify which implements equality like this:
def equals(other: Any) = (this eq other) || (other match {
case other: ListNode => this.next == other.next
})
and want to check if node1 == node2 where node1.next is node2 and vice versa:
node1 <--> node2
node1 == node2 reduces to (node1 eq node2) || (node1.next == node2.next).
node1 eq node2 is false, so that reduces to node1.next == node2.next, that is node2 == node1.
node2 eq node1 is false, so that reduces to node2.next == node1.next, that is node1 == node2...