Merge pull request #12 from scala/universal-equals

Add universal equality

Author: julienrf

src/main/scala/strawman/collection/Iterable.scala

@@ -6,6 +6,7 @@ import scala.reflect.ClassTag
 import scala.{Int, Boolean, Array, Any, Unit, StringContext}
 import java.lang.{String, UnsupportedOperationException}
 import strawman.collection.mutable.{ArrayBuffer, StringBuilder}
+import java.lang.String
 
 /** Base trait for generic collections */
 trait Iterable[+A] extends IterableOnce[A] with IterableLike[A, Iterable] {
@@ -53,7 +54,7 @@ trait IterableFactory[+C[X] <: Iterable[X]] extends FromIterable[C] {
   */
 trait IterableOps[+A] extends Any {
   protected def coll: Iterable[A]
-  private def iterator() = coll.iterator()
+  private def iterator(): Iterator[A] = coll.iterator()
 
   /** Apply `f` to each element for its side effects
    *  Note: [U] parameter needed to help scalac's type inference.
@@ -138,8 +139,10 @@ trait IterableOps[+A] extends Any {
   }
 
   override def toString = s"$className(${mkString(", ")})"
+
 }
 
+
 /** Type-preserving transforms over iterables.
   *  Operations defined here return in their result iterables of the same type
   *  as the one they are invoked on.

src/main/scala/strawman/collection/Iterator.scala

@@ -97,6 +97,15 @@ trait Iterator[+A] extends IterableOnce[A] { self =>
     def hasNext = self.hasNext && thatIterator.hasNext
     def next() = (self.next(), thatIterator.next())
   }
+  def sameElements[B >: A](that: IterableOnce[B]): Boolean = {
+    val those = that.iterator()
+    while (hasNext && those.hasNext)
+      if (next() != those.next())
+        return false
+    // At that point we know that *at least one* iterator has no next element
+    // If *both* of them have no elements then the collections are the same
+    hasNext == those.hasNext
+  }
 }
 
 object Iterator {

src/main/scala/strawman/collection/Seq.scala

@@ -1,9 +1,10 @@
 package strawman.collection
 
-import scala.{Any, Boolean, Int, IndexOutOfBoundsException}
+import scala.{Any, Boolean, Equals, IndexOutOfBoundsException, Int}
 import strawman.collection.immutable.{List, Nil}
 
 import scala.annotation.unchecked.uncheckedVariance
+import scala.util.hashing.MurmurHash3
 
 /** Base trait for sequence collections */
 trait Seq[+A] extends Iterable[A] with SeqLike[A, Seq] with ArrayLike[A]
@@ -51,6 +52,50 @@ trait IndexedSeq[+A] extends Seq[A] { self =>
 trait SeqLike[+A, +C[X] <: Seq[X]]
   extends IterableLike[A, C]
     with SeqMonoTransforms[A, C[A @uncheckedVariance]] // sound bcs of VarianceNote
+    with Equals {
+
+  protected def coll: C[A @uncheckedVariance]
+
+  /** Do the elements of this collection are the same (and in the same order)
+    * as those of `that`?
+    */
+  def sameElements[B >: A](that: IterableOnce[B]): Boolean =
+    coll.iterator().sameElements(that)
+
+  /** Method called from equality methods, so that user-defined subclasses can
+    *  refuse to be equal to other collections of the same kind.
+    *  @param   that   The object with which this $coll should be compared
+    *  @return  `true`, if this $coll can possibly equal `that`, `false` otherwise. The test
+    *           takes into consideration only the run-time types of objects but ignores their elements.
+    */
+  def canEqual(that: Any): Boolean = true
+
+  override def equals(o: scala.Any): Boolean =
+    o match {
+      case it: Seq[A] => (it canEqual this) && sameElements(it)
+      case _ => false
+    }
+
+  override def hashCode(): Int =
+    Seq.stableIterableHash(coll)
+
+}
+
+// Temporary: TODO move to MurmurHash3.scala
+object Seq {
+
+  final def stableIterableHash(xs: Seq[_]): Int = {
+    var n = 0
+    var h = "Seq".##
+    val it = xs.iterator()
+    while (it.hasNext) {
+      h = MurmurHash3.mix(h, it.next().##)
+      n += 1
+    }
+    MurmurHash3.finalizeHash(h, n)
+  }
+
+}
 
 /** Base trait for linear Seq operations */
 trait LinearSeqLike[+A, +C[X] <: LinearSeq[X]] extends SeqLike[A, C] {

src/main/scala/strawman/collection/Set.scala

@@ -1,4 +1,63 @@
 package strawman
 package collection
 
-trait Set[A] extends Iterable[A] {}
+import scala.{Any, Boolean, Equals, Int}
+import scala.util.hashing.MurmurHash3
+
+trait Set[A]
+  extends Iterable[A]
+    with SetLike[A, Set]
+
+trait SetLike[A, +C[X] <: Set[X]]
+  extends SetOps[A]
+    with Equals {
+
+  protected def coll: C[A]
+
+  def canEqual(that: Any) = true
+
+  override def equals(that: Any): Boolean =
+    that match {
+      case set: Set[A] =>
+        (this eq set) ||
+        (set canEqual this) &&
+        (coll.size == set.size) &&
+        (this subsetOf set)
+      case _ => false
+    }
+
+  override def hashCode(): Int = Set.setHash(coll)
+
+}
+
+trait SetOps[A] extends Any {
+
+  protected def coll: Set[A]
+
+  def subsetOf(that: Set[A]): Boolean
+
+}
+
+// Temporary, TODO move to MurmurHash3
+object Set {
+
+  def setHash(xs: Set[_]): Int = unorderedHash(xs, "Set".##)
+
+  final def unorderedHash(xs: Iterable[_], seed: Int): Int = {
+    var a, b, n = 0
+    var c = 1
+    xs foreach { x =>
+      val h = x.##
+      a += h
+      b ^= h
+      if (h != 0) c *= h
+      n += 1
+    }
+    var h = seed
+    h = MurmurHash3.mix(h, a)
+    h = MurmurHash3.mix(h, b)
+    h = MurmurHash3.mixLast(h, c)
+    MurmurHash3.finalizeHash(h, n)
+  }
+
+}

src/test/scala/strawman/collection/test/Test.scala

@@ -2,7 +2,7 @@ package strawman.collection.test
 
 import java.lang.String
 import scala.{Int, Unit, Array, StringContext, Boolean, Any, Char}
-import scala.Predef.{println, charWrapper}
+import scala.Predef.{assert, println, charWrapper}
 
 import strawman.collection.immutable._
 import strawman.collection.mutable._
@@ -288,6 +288,19 @@ class StrawmanTest {
     println(xs17.to(List))
   }
 
+  def equality(): Unit = {
+    val list = List(1, 2, 3)
+    val lazyList = LazyList(1, 2, 3)
+    val buffer = ArrayBuffer(1, 2, 3)
+    assert(list == lazyList)
+    assert(list.## == lazyList.##)
+    assert(list == buffer)
+    assert(list.## == buffer.##)
+    buffer += 4
+    assert(list != buffer)
+    assert(list.## != buffer.##)
+  }
+
   @Test
   def mainTest: Unit = {
     val ints = List(1, 2, 3)
@@ -301,5 +314,6 @@ class StrawmanTest {
     stringOps("abc")
     arrayOps(Array(1, 2, 3))
     lazyListOps(LazyList(1, 2, 3))
+    equality()
   }
 }