I'm looking for a way to have classes that behave just like case classes, but that are automatically [hash consed](http://en.wikipedia.org/wiki/Hash_consing).

One way to achieve this for integer lists would be:

```
import scala.collection.mutable.{Map=>MutableMap}

sealed abstract class List
class Cons(val head: Int, val tail: List) extends List
case object Nil extends List

object Cons {
  val cache : MutableMap[(Int,List),Cons] = MutableMap.empty
  def apply(head : Int, tail : List) = cache.getOrElse((head,tail), {
    val newCons = new Cons(head, tail)
    cache((head,tail)) = newCons
    newCons
  })
  def unapply(lst : List) : Option[(Int,List)] = {
    if (lst != null && lst.isInstanceOf[Cons]) {
      val asCons = lst.asInstanceOf[Cons]
      Some((asCons.head, asCons.tail))
    } else None
  }
}

```

And, for instance, while 

```
scala> (5 :: 4 :: scala.Nil) eq (5 :: 4 :: scala.Nil)
resN: Boolean = false

```

we get

```
scala> Cons(5, Cons(4, Nil)) eq Cons(5, Cons(4, Nil))
resN: Boolean = true

```

Now what I'm looking for is a *generic* way to achieve this (or something very similar). Ideally, I don't want to have to type much more than:

```
class Cons(val head : Int, val tail : List) extends List with HashConsed2[Int,List]

```

(or similar). Can someone come up with some type system voodoo to help me, or will I have to wait for the macro language to be available?