Redefine equals for Lst

Author: odersky

tests/run/lst/Lst.scala

@@ -448,23 +448,27 @@ class Lst[+T](val elems: Any) extends AnyVal { self =>
       }
     }
 
-  def === [U](that: Lst[U]) =
-    (this `eqLst` that) || {
-      elems match {
-        case elems1: Arr =>
-          that.elems match {
-            case elems2: Arr =>
-              val len = elems1.length
-              len == elems2.length && {
-                var i = 0
-                while (i < len && elems1(i).equals(elems2(i))) i += 1
-                i == len
-              }
-            case _ => false
-          }
-        case elem => elem == that.elems
+  override def equals(that: Any) = that match {
+    case that: Lst[_] =>
+      (this `eqLst` that) || {
+        elems match {
+          case elems1: Arr =>
+            that.elems match {
+              case elems2: Arr =>
+                val len = elems1.length
+                len == elems2.length && {
+                  var i = 0
+                  while (i < len && elems1(i).equals(elems2(i))) i += 1
+                  i == len
+                }
+              case _ => false
+            }
+          case elem => elem == that.elems
+        }
       }
-    }
+    case _ =>
+      false
+  }
 
   def eqLst[U](that: Lst[U]) = eq(elems, that.elems)
 

tests/run/lst/LstTest.scala

@@ -178,7 +178,7 @@ object Test extends App {
     val ys1a = xs1.filterNot(_.head >= 'c')
     assert(ys1a `eqLst` xs1)
     val ys5 = xs5.filter(_.head % 2 != 0)
-    assert(ys5 === Lst("a", "c", "e"), ys5)
+    assert(ys5 == Lst("a", "c", "e"), ys5)
 
     val js0 = is0.filter(_ > 3)
     assert(js0.isEmpty)
@@ -187,7 +187,7 @@ object Test extends App {
     val js1a = is1.filterNot(_ > 3)
     assert(js1a `eqLst` is1)
     val js5 = is5.filter(_ % 2 != 0)
-    assert(js5 === Lst(1, 3, 5), js5)
+    assert(js5 == Lst(1, 3, 5), js5)
 
     val yss0 = xss0.filter(_.nonEmpty)
     assert(yss0.isEmpty)
@@ -196,9 +196,9 @@ object Test extends App {
     val yss1a = xss1.filterNot(_.head.head >= 'c')
     assert(yss1a `eqLst` xss1)
     val yss5 = xss5.filter(_.head.head % 2 != 0)
-    assert(yss5 === Lst(Lst("a"), Lst("c"), Lst("e")), yss5)
+    assert(yss5 == Lst(Lst("a"), Lst("c"), Lst("e")), yss5)
     val yss5a = xss5.map(_.filter(_.head % 2 != 0))
-    assert(yss5a === Lst(Lst("a"), Lst(), Lst("c"), Lst(), Lst("e")), yss5)
+    assert(yss5a == Lst(Lst("a"), Lst(), Lst("c"), Lst(), Lst("e")), yss5)
   }
 
   def existsTest() = {
@@ -267,23 +267,23 @@ object Test extends App {
     assert(is1.reduceLeft(_ + _) == 1)
     assert(is3.reduceLeft(_ + _) == 6)
 
-    assert(xss0.foldLeft(Lst("x"))(_ ++ _) === Lst("x"))
-    assert(xss1.foldLeft(Lst("x"))(_ ++ _) === Lst("x", "a"))
-    assert(xss2.foldLeft(Lst(): Lst[String])(_ ++ _) === Lst("a", "b"))
-    assert(xss3.foldLeft(Lst.Empty: Lst[String])(_ ++ _) === Lst("a", "b", "c"))
-    assert((Lst("x") /: xss0)(_ ++ _) === Lst("x"))
-    assert((Lst("x") /: xss1)(_ ++ _) === Lst("x", "a"))
-    assert((Lst("x") /: xss2)(_ ++ _) === Lst("x", "a", "b"))
-    assert((Lst("x") /: xss3)(_ ++ _) === Lst("x", "a", "b", "c"))
-    assert(xss1.reduceLeft(_ ++ _) === Lst("a"))
-    assert(xss3.reduceLeft(_ ++ _) === Lst("a", "b", "c"))
+    assert(xss0.foldLeft(Lst("x"))(_ ++ _) == Lst("x"))
+    assert(xss1.foldLeft(Lst("x"))(_ ++ _) == Lst("x", "a"))
+    assert(xss2.foldLeft(Lst(): Lst[String])(_ ++ _) == Lst("a", "b"))
+    assert(xss3.foldLeft(Lst.Empty: Lst[String])(_ ++ _) == Lst("a", "b", "c"))
+    assert((Lst("x") /: xss0)(_ ++ _) == Lst("x"))
+    assert((Lst("x") /: xss1)(_ ++ _) == Lst("x", "a"))
+    assert((Lst("x") /: xss2)(_ ++ _) == Lst("x", "a", "b"))
+    assert((Lst("x") /: xss3)(_ ++ _) == Lst("x", "a", "b", "c"))
+    assert(xss1.reduceLeft(_ ++ _) == Lst("a"))
+    assert(xss3.reduceLeft(_ ++ _) == Lst("a", "b", "c"))
   }
 
   def reverseTest() = {
-    assert(xs0.reverse === xs0)
-    assert(xs1.reverse === xs1)
+    assert(xs0.reverse == xs0)
+    assert(xs1.reverse == xs1)
     assert(xs3.reverse.mkString == "c, b, a", xs3.reverse.mkString)
-    assert(xs4.reverse.reverse === xs4, xs4.reverse.reverse)
+    assert(xs4.reverse.reverse == xs4, xs4.reverse.reverse)
   }
 
   def applyTest() = {
@@ -304,15 +304,15 @@ object Test extends App {
   }
 
   def sliceTest() = {
-    assert(xs5.slice(2, 4) === Lst("c", "d"))
-    assert(xs5.drop(4) === Lst("e"))
+    assert(xs5.slice(2, 4) == Lst("c", "d"))
+    assert(xs5.drop(4) == Lst("e"))
     assert(xs5.take(4).mkString("") == "abcd")
     assert(xs5.drop(-1) `eqLst` xs5)
     assert(xs1.take(1) `eqLst` xs1)
     assert(xs0.take(10).length == 0)
 
-    assert(is5.slice(2, 4) === Lst(3, 4))
-    assert(is5.drop(4) === Lst(5))
+    assert(is5.slice(2, 4) == Lst(3, 4))
+    assert(is5.drop(4) == Lst(5))
     assert(is5.take(4).mkString("") == "1234")
     assert(is5.drop(-1) `eqLst` is5)
     assert(is1.take(1) `eqLst` is1)
@@ -323,34 +323,34 @@ object Test extends App {
     val ys4a = xs4.zipWith(xs5)(_ + _)
     val ys4b = xs5.zipWith(xs4)(_ + _)
     assert(ys4a.mkString("") == "aabbccdd", ys4a)
-    assert(ys4a === ys4b)
+    assert(ys4a == ys4b)
     val ys1a = xs1.zipWith(xs1)(_ + _)
-    assert(ys1a === Lst("aa"))
+    assert(ys1a == Lst("aa"))
     val ys1b = xs1.zipWith(xs2)(_ + _)
-    assert(ys1b === Lst("aa"))
+    assert(ys1b == Lst("aa"))
     val ys1c = xs2.zipWith(xs1)(_ + _)
-    assert(ys1c === Lst("aa"))
+    assert(ys1c == Lst("aa"))
     val ys0a = xs1.zipWith(xs0)(_ + _)
     val ys0b = xs0.zipWith(xs1)(_ + _)
     assert((ys0a ++ ys0b).isEmpty)
     val ys3i = xs3.zipWithIndex.map((x, y) => (x, y + 1))
-    assert(ys3i === Lst(("a", 1), ("b", 2), ("c", 3)), ys3i)
+    assert(ys3i == Lst(("a", 1), ("b", 2), ("c", 3)), ys3i)
 
     val js4a = is4.zipWith(is5)(_ + _)
     val js4b = is5.zipWith(is4)(_ + _)
     assert(js4a.mkString("") == "2468", js4a)
-    assert(js4a === js4b)
+    assert(js4a == js4b)
     val js1a = is1.zipWith(is1)(_ + _)
-    assert(js1a === Lst(2))
+    assert(js1a == Lst(2))
     val js1b = is1.zipWith(is2)(_ + _)
-    assert(js1b === Lst(2))
+    assert(js1b == Lst(2))
     val js1c = is2.zipWith(is1)(_ + _)
-    assert(js1c === Lst(2))
+    assert(js1c == Lst(2))
     val js0a = is1.zipWith(is0)(_ + _)
     val js0b = is0.zipWith(is1)(_ + _)
     assert((js0a ++ js0b).isEmpty)
     val js3i = is3.zipWithIndex.map((x, y) => (x, y + 1))
-    assert(js3i === Lst((1, 1), (2, 2), (3, 3)), js3i)
+    assert(js3i == Lst((1, 1), (2, 2), (3, 3)), js3i)
     assert(js3i.forall(_ == _))
   }
 
@@ -380,7 +380,7 @@ object Test extends App {
     { val b = new Lst.Buffer[String]
       b += "a"
       assert(b.size == 1)
-      assert(b.toLst === Lst("a"))
+      assert(b.toLst == Lst("a"))
       b += "aa"
       b ++= Lst.fill(20)("a")
       assert(b.toLst.mkString("") == "a" * 23)
@@ -390,7 +390,7 @@ object Test extends App {
     { val b = new Lst.Buffer[Int]
       b += 1
       assert(b.size == 1)
-      assert(b.toLst === Lst(1))
+      assert(b.toLst == Lst(1))
       b += 11
       b ++= Lst.fill(20)(1)
       assert(b.toLst.mkString("") == "1" * 23)
@@ -400,7 +400,7 @@ object Test extends App {
     { val b = new Lst.Buffer[Lst[String]]
       b += Lst("a")
       assert(b.size == 1)
-      assert(b.toLst === Lst(Lst("a")))
+      assert(b.toLst == Lst(Lst("a")))
       b += Lst("aa")
       b ++= Lst.fill(20)(Lst("a"))
       assert(b.toLst.map(_.mkString("")).mkString("") == "a" * 23)