diff options
author | Martin Odersky <odersky@gmail.com> | 2016-04-21 15:38:42 +0200 |
---|---|---|
committer | Martin Odersky <odersky@gmail.com> | 2016-04-21 15:38:42 +0200 |
commit | f320ac848ae418b0ed9a1870c0afd7b6420d31c1 (patch) | |
tree | 2768d3249fc26376356c5289894736cbce1248c3 /tests/neg | |
parent | 3c38a6baccc5343f55985347c0f58d184d6becee (diff) | |
download | dotty-f320ac848ae418b0ed9a1870c0afd7b6420d31c1.tar.gz dotty-f320ac848ae418b0ed9a1870c0afd7b6420d31c1.tar.bz2 dotty-f320ac848ae418b0ed9a1870c0afd7b6420d31c1.zip |
Straw man for multiversal equality.
This test shows how we can make equality non-universal in Scala. It also
exhibited the two bugs fixed in the previous two commits.
Also related: SI-9763.
Diffstat (limited to 'tests/neg')
-rw-r--r-- | tests/neg/EqualityStrawman1.scala | 76 |
1 files changed, 76 insertions, 0 deletions
diff --git a/tests/neg/EqualityStrawman1.scala b/tests/neg/EqualityStrawman1.scala new file mode 100644 index 000000000..8c9b435e4 --- /dev/null +++ b/tests/neg/EqualityStrawman1.scala @@ -0,0 +1,76 @@ +package strawman.equality + +object EqualityStrawman1 { + + trait Eq[-T] + trait Impossible + + object Eq extends Eq[Any] + + trait Base { + def === (other: Any): Boolean = this.equals(other) + def === (other: CondEquals)(implicit ce: Impossible): Boolean = ??? + } + + trait CondEquals extends Base { + def === [T >: this.type <: CondEquals](other: T)(implicit ce: Eq[T]): Boolean = this.equals(other) + def === (other: Any)(implicit ce: Impossible): Boolean = ??? + } + + trait Equals[-T] extends CondEquals + + case class Str(str: String) extends CondEquals + + case class Num(x: Int) extends Equals[Num] + + case class Other(x: Int) extends Base + + trait Option[+T] extends CondEquals + case class Some[+T](x: T) extends Option[T] + case object None extends Option[Nothing] + + implicit def eqStr: Eq[Str] = Eq + //implicit def eqNum: Eq[Num] = Eq + implicit def eqOption[T: Eq]: Eq[Option[T]] = Eq + + implicit def eqEq[T <: Equals[T]]: Eq[T] = Eq + + def main(args: Array[String]): Unit = { + val x = Str("abc") + x === x + + val n = Num(2) + val m = Num(3) + n === m + + Other(1) === Other(2) + + Some(x) === None + Some(x) === Some(Str("")) + val z: Option[Str] = Some(Str("abc")) + z === Some(x) + z === None + Some(x) === z + None === z + + + def ddistinct[T <: Base: Eq](xs: List[T]): List[T] = xs match { + case Nil => Nil + case x :: xs => x :: xs.filterNot(x === _) + } + + ddistinct(List(z, z, z)) + + x === n // error + n === x // error + x === Other(1) // error + Other(2) === x // error + z === Some(n) // error + z === n // error + Some(n) === z // error + n === z // error + Other(1) === z // error + z === Other(1) // error + ddistinct(List(z, n)) // error + } +} |