Rename Eq -> Eql

Eq is already used with a slightly different meaning as a unary typeclass,
e.g. cats.Eq.

Author: odersky

compiler/src/dotty/tools/dotc/core/Definitions.scala

@@ -730,11 +730,11 @@ class Definitions {
   lazy val TastyReflectionModule: TermSymbol = ctx.requiredModule("scala.tasty.Reflection")
     lazy val TastyReflection_macroContext: TermSymbol = TastyReflectionModule.requiredMethod("macroContext")
 
-  lazy val EqType: TypeRef = ctx.requiredClassRef("scala.Eq")
-  def EqClass(implicit ctx: Context): ClassSymbol = EqType.symbol.asClass
-  def EqModule(implicit ctx: Context): Symbol = EqClass.companionModule
+  lazy val EqlType: TypeRef = ctx.requiredClassRef("scala.Eql")
+  def EqlClass(implicit ctx: Context): ClassSymbol = EqlType.symbol.asClass
+  def EqlModule(implicit ctx: Context): Symbol = EqlClass.companionModule
 
-    def Eq_eqAny(implicit ctx: Context): TermSymbol = EqModule.requiredMethod(nme.eqAny)
+    def Eql_eqlAny(implicit ctx: Context): TermSymbol = EqlModule.requiredMethod(nme.eqlAny)
 
   lazy val NotType: TypeRef = ctx.requiredClassRef("scala.implicits.Not")
   def NotClass(implicit ctx: Context): ClassSymbol = NotType.symbol.asClass

compiler/src/dotty/tools/dotc/core/Denotations.scala

@@ -67,7 +67,7 @@ import collection.mutable.ListBuffer
  */
 object Denotations {
 
-  implicit def eqDenotation: Eq[Denotation, Denotation] = Eq.derived
+  implicit def eqDenotation: Eql[Denotation, Denotation] = Eql.derived
 
   /** A PreDenotation represents a group of single denotations or a single multi-denotation
    *  It is used as an optimization to avoid forming MultiDenotations too eagerly.

compiler/src/dotty/tools/dotc/core/Names.scala

@@ -25,7 +25,7 @@ object Names {
     def toTermName: TermName
   }
 
-  implicit def eqName: Eq[Name, Name] = Eq.derived
+  implicit def eqName: Eql[Name, Name] = Eql.derived
 
   /** A common superclass of Name and Symbol. After bootstrap, this should be
    *  just the type alias Name | Symbol

compiler/src/dotty/tools/dotc/core/StdNames.scala

@@ -417,7 +417,7 @@ object StdNames {
     val equals_ : N             = "equals"
     val error: N                = "error"
     val eval: N                 = "eval"
-    val eqAny: N                = "eqAny"
+    val eqlAny: N               = "eqlAny"
     val ex: N                   = "ex"
     val experimental: N         = "experimental"
     val f: N                    = "f"

compiler/src/dotty/tools/dotc/core/Symbols.scala

@@ -406,7 +406,7 @@ trait Symbols { this: Context =>
 
 object Symbols {
 
-  implicit def eqSymbol: Eq[Symbol, Symbol] = Eq.derived
+  implicit def eqSymbol: Eql[Symbol, Symbol] = Eql.derived
 
   /** Tree attachment containing the identifiers in a tree as a sorted array */
   val Ids: Property.Key[Array[String]] = new Property.Key

compiler/src/dotty/tools/dotc/core/Types.scala

@@ -40,7 +40,7 @@ object Types {
 
   @sharable private[this] var nextId = 0
 
-  implicit def eqType: Eq[Type, Type] = Eq.derived
+  implicit def eqType: Eql[Type, Type] = Eql.derived
 
   /** Main class representing types.
    *

compiler/src/dotty/tools/dotc/typer/Implicits.scala

@@ -698,18 +698,18 @@ trait Implicits { self: Typer =>
       if (ctx.inInlineMethod || enclosingInlineds.nonEmpty) ref(defn.TastyReflection_macroContext)
       else EmptyTree
 
-    /** If `formal` is of the form Eq[T, U], try to synthesize an
-     *  `Eq.eqAny[T, U]` as solution.
+    /** If `formal` is of the form Eql[T, U], try to synthesize an
+     *  `Eql.eqlAny[T, U]` as solution.
      */
     def synthesizedEq(formal: Type)(implicit ctx: Context): Tree = {
 
       /** Is there an `Eql[T, T]` instance, assuming -strictEquality? */
       def hasEq(tp: Type)(implicit ctx: Context): Boolean = {
-        val inst = inferImplicitArg(defn.EqType.appliedTo(tp, tp), span)
+        val inst = inferImplicitArg(defn.EqlType.appliedTo(tp, tp), span)
         !inst.isEmpty && !inst.tpe.isError
       }
 
-      /** Can we assume the eqAny instance for `tp1`, `tp2`?
+      /** Can we assume the eqlAny instance for `tp1`, `tp2`?
        *  This is the case if assumedCanEqual(tp1, tp2), or
        *  one of `tp1`, `tp2` has a reflexive `Eql` instance.
        */
@@ -755,7 +755,7 @@ trait Implicits { self: Typer =>
               ||
               !strictEquality &&
               ctx.test(implicit ctx => validEqAnyArgs(arg1, arg2)))
-            ref(defn.Eq_eqAny).appliedToTypes(args).withSpan(span)
+            ref(defn.Eql_eqlAny).appliedToTypes(args).withSpan(span)
           else EmptyTree
         case _ =>
           EmptyTree
@@ -816,7 +816,7 @@ trait Implicits { self: Typer =>
             trySpecialCase(defn.QuotedTypeClass, synthesizedTypeTag,
               trySpecialCase(defn.GenericClass, synthesizedGeneric,
                 trySpecialCase(defn.TastyReflectionClass, synthesizedTastyContext,
-                  trySpecialCase(defn.EqClass, synthesizedEq,
+                  trySpecialCase(defn.EqlClass, synthesizedEq,
                     trySpecialCase(defn.ValueOfClass, synthesizedValueOf, failed))))))
     }
   }
@@ -962,8 +962,8 @@ trait Implicits { self: Typer =>
   /** Check that equality tests between types `ltp` and `rtp` make sense */
   def checkCanEqual(ltp: Type, rtp: Type, span: Span)(implicit ctx: Context): Unit =
     if (!ctx.isAfterTyper && !assumedCanEqual(ltp, rtp)) {
-      val res = implicitArgTree(defn.EqType.appliedTo(ltp, rtp), span)
-      implicits.println(i"Eq witness found for $ltp / $rtp: $res: ${res.tpe}")
+      val res = implicitArgTree(defn.EqlType.appliedTo(ltp, rtp), span)
+      implicits.println(i"Eql witness found for $ltp / $rtp: $res: ${res.tpe}")
     }
 
   /** Find an implicit parameter or conversion.
@@ -1031,7 +1031,7 @@ trait Implicits { self: Typer =>
       if (argument.isEmpty) f(resultType) else ViewProto(f(argument.tpe.widen), f(resultType))
         // Not clear whether we need to drop the `.widen` here. All tests pass with it in place, though.
 
-    private def isCoherent = pt.isRef(defn.EqClass)
+    private def isCoherent = pt.isRef(defn.EqlClass)
 
     private val cmpContext = nestedContext()
     private val cmpCandidates = (c1: Candidate, c2: Candidate) => compare(c1.ref, c2.ref, c1.level, c2.level)(cmpContext)

compiler/src/dotty/tools/dotc/util/SourceFile.scala

@@ -190,7 +190,7 @@ class SourceFile(val file: AbstractFile, computeContent: => Array[Char]) extends
   }
 }
 object SourceFile {
-  implicit def eqSource: Eq[SourceFile, SourceFile] = Eq.derived
+  implicit def eqSource: Eql[SourceFile, SourceFile] = Eql.derived
 
   implicit def fromContext(implicit ctx: Context): SourceFile = ctx.source
 

compiler/test-resources/repl/i4184

@@ -2,8 +2,8 @@ scala> object foo { class Foo }
 // defined object foo
 scala> object bar { class Foo }
 // defined object bar
-scala> implicit def eqFoo: Eq[foo.Foo, foo.Foo] = Eq.derived
-def eqFoo: Eq[foo.Foo, foo.Foo]
+scala> implicit def eqFoo: Eql[foo.Foo, foo.Foo] = Eql.derived
+def eqFoo: Eql[foo.Foo, foo.Foo]
 scala> object Bar { new foo.Foo == new bar.Foo }
 1 | object Bar { new foo.Foo == new bar.Foo }
   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^

docs/docs/reference/enums/desugarEnums.md

@@ -134,15 +134,6 @@ map into case classes or vals.
    where `n` is the ordinal number of the case in the companion object,
    starting from 0.
 
-### Equality
-
-An `enum` type contains a `scala.Eq` instance that restricts values of the `enum` type to
-be compared only to other values of the same enum type. Furtermore, generic
-`enum` types are comparable only if their type arguments are. For instance the
-`Option` enum type will get the following definition in its companion object:
-
-    implicit def eqOption[T, U](implicit ev1: Eq[T, U]): Eq[Option[T], Option[U]] = Eq
-
 ### Translation of Enumerations
 
 Non-generic enums `E` that define one or more singleton cases

library/src/scala/Eq.scala renamed to library/src/scala/Eql.scala

@@ -5,33 +5,33 @@ import scala.collection.{GenSeq, Set}
 
 /** A marker trait indicating that values of type `L` can be compared to values of type `R`. */
 @implicitNotFound("Values of types ${L} and ${R} cannot be compared with == or !=")
-sealed trait Eq[-L, -R]
+sealed trait Eql[-L, -R]
 
 /** Companion object containing a few universally known `Eql` instances.
  *  Eql instances involving primitive types or the Null type are handled directly in
  *  the compiler (see Implicits.synthesizedEq), so they are not included here.
  */
-object Eq {
+object Eql {
   /** A non-implied universal `Eql` instance. */
-  object derived extends Eq[Any, Any]
+  object derived extends Eql[Any, Any]
 
   /** A fall-back instance to compare values of any types.
    *  Even though this method is not declared implied, the compiler will
    *  compute implied instances as solutions to `Eql[T, U]` queries if
    *  the rules of multiversal equality require it.
    */
-  def eqAny[L, R]: Eq[L, R] = derived
+  def eqlAny[L, R]: Eql[L, R] = derived
 
-  // Instances of `Eq` for common Java types
-  implicit def eqNumber   : Eq[Number, Number] = derived
-  implicit def eqString   : Eq[String, String] = derived
+  // Instances of `Eql` for common Java types
+  implicit def eqlNumber   : Eql[Number, Number] = derived
+  implicit def eqlString   : Eql[String, String] = derived
 
   // The next three definitions can go into the companion objects of classes
   // Seq, Set, and Proxy. For now they are here in order not to have to touch the
   // source code of these classes
-  implicit def eqSeq[T, U](implicit eq: Eq[T, U]): Eq[GenSeq[T], GenSeq[U]] = derived
-  implicit def eqSet[T, U](implicit eq: Eq[T, U]): Eq[Set[T], Set[U]] = derived
+  implicit def eqlSeq[T, U](implicit eq: Eql[T, U]): Eql[GenSeq[T], GenSeq[U]] = derived
+  implicit def eqlSet[T, U](implicit eq: Eql[T, U]): Eql[Set[T], Set[U]] = derived
 
   // true asymmetry, modeling the (somewhat problematic) nature of equals on Proxies
-  implicit def eqProxy    : Eq[Proxy, AnyRef]  = derived
+  implicit def eqlProxy    : Eql[Proxy, AnyRef]  = derived
 }

tests/neg/EqualityStrawman1.scala

@@ -3,22 +3,22 @@ import annotation.implicitNotFound
 
 object EqualityStrawman1 {
 
-  trait Eq[-T]
+  trait Eql[-T]
 
   @implicitNotFound("cannot compare value of type ${T} with a value outside its equality class")
   trait Impossible[T]
 
-  object Eq {
-    object derived extends Eq[Any]
+  object Eql {
+    object derived extends Eql[Any]
   }
-  
+
   trait Base {
     def === (other: Any): Boolean = this.equals(other)
     def === [T <: CondEquals](other: T)(implicit ce: Impossible[T]): Boolean = ???
   }
 
   trait CondEquals extends Base {
-    def === [T >: this.type <: CondEquals](other: T)(implicit ce: Eq[T]): Boolean = this.equals(other)
+    def === [T >: this.type <: CondEquals](other: T)(implicit ce: Eql[T]): Boolean = this.equals(other)
     def === [T](other: T)(implicit ce: Impossible[T]): Boolean = ???
   }
 
@@ -34,11 +34,11 @@ object EqualityStrawman1 {
   case class Some[+T](x: T) extends Option[T]
   case object None extends Option[Nothing]
 
-  implicit def eqStr: Eq[Str] = Eq.derived
-  //implicit def eqNum: Eq[Num] = Eq.derived
-  implicit def eqOption[T: Eq]: Eq[Option[T]] = Eq.derived
+  implicit def eqStr: Eql[Str] = Eql.derived
+  //implicit def eqNum: Eql[Num] = Eql.derived
+  implicit def eqOption[T: Eql]: Eql[Option[T]] = Eql.derived
 
-  implicit def eqEq[T <: Equals[T]]: Eq[T] = Eq.derived
+  implicit def eqEq[T <: Equals[T]]: Eql[T] = Eql.derived
 
   def main(args: Array[String]): Unit = {
     val x = Str("abc")
@@ -59,7 +59,7 @@ object EqualityStrawman1 {
     None === z
 
 
-    def ddistinct[T <: Base: Eq](xs: List[T]): List[T] = xs match {
+    def ddistinct[T <: Base: Eql](xs: List[T]): List[T] = xs match {
       case Nil => Nil
       case x :: xs => x :: xs.filterNot(x === _)
     }

tests/neg/derive-eq.scala

@@ -1,20 +1,20 @@
 
-case class One() derives Eq
-case class Two() derives Eq
+case class One() derives Eql
+case class Two() derives Eql
 
-implied for Eq[One, Two] = Eq.derived
+implied for Eql[One, Two] = Eql.derived
 
-enum Lst[T] derives Eq {
+enum Lst[T] derives Eql {
   case Cons(x: T, xs: Lst[T])
   case Nil()
 }
 
-case class Triple[S, T, U] derives Eq
+case class Triple[S, T, U] derives Eql
 
 
 object Test extends App {
-  implicitly[Eq[Lst[Lst[One]], Lst[Lst[Two]]]]
-  implicitly[Eq[Triple[One, One, One],
+  implicitly[Eql[Lst[Lst[One]], Lst[Lst[Two]]]]
+  implicitly[Eql[Triple[One, One, One],
                 Triple[Two, Two, Two]]]
 
   val x: Triple[List[One], One, Two] = ???

tests/neg/enums.scala

@@ -24,7 +24,7 @@ enum E4 {
 case class C4() extends E4 // error: cannot extend enum
 case object O4 extends E4 // error: cannot extend enum
 
-enum Option[+T] derives Eq {
+enum Option[+T] derives Eql {
   case Some(x: T)
   case None
 }

tests/neg/equality.scala

@@ -10,20 +10,20 @@ object equality {
   case class Some[+T](x: T) extends Option[T]
   case object None extends Option[Nothing]
 
-  implicit def eqStr: Eq[Str, Str] = Eq.derived
-  implicit def eqNum: Eq[Num, Num] = Eq.derived
-  implicit def eqOption[T, U](implicit e: Eq[T, U]): Eq[Option[T], Option[U]] = Eq.derived
+  implicit def eqStr: Eql[Str, Str] = Eql.derived
+  implicit def eqNum: Eql[Num, Num] = Eql.derived
+  implicit def eqOption[T, U](implicit e: Eql[T, U]): Eql[Option[T], Option[U]] = Eql.derived
 
   case class PString(a: String) extends Proxy {
     def self = a
   }
 
 /*
-  implicit def eqString: Eq[String, String] = Eq.derived
-  implicit def eqInt: Eq[Int, Int] = Eq.derived
-  implicit def eqNumber: Eq[Number, Number] = Eq.derived
-  implicit def eqIntNumber: Eq[Int, Number] = Eq.derived
-  implicit def eqNumberInt: Eq[Number, Int] = Eq.derived
+  implicit def eqString: Eql[String, String] = Eql.derived
+  implicit def eqInt: Eql[Int, Int] = Eql.derived
+  implicit def eqNumber: Eql[Number, Number] = Eql.derived
+  implicit def eqIntNumber: Eql[Int, Number] = Eql.derived
+  implicit def eqNumberInt: Eql[Number, Int] = Eql.derived
 */
   def main(args: Array[String]): Unit = {
     Some(Other(3)) == None
@@ -64,7 +64,7 @@ object equality {
     1 == null    // error
 
 
-    class Fruit derives Eq
+    class Fruit derives Eql
 
     class Apple extends Fruit
     class Pear extends Fruit

tests/neg/i3976.scala

@@ -1,5 +1,5 @@
 object Test {
-  enum Hoge[F[_]] derives Eq {
+  enum Hoge[F[_]] derives Eql {
     case A extends Hoge[List]
     case B extends Hoge[[X] => String]
   }
@@ -8,7 +8,7 @@ object Test {
   A == A
   A == (B: Hoge[_])
 
-  A == B // should be error: cannot be compared, needs proper typeclass drivation of `Eq` to get there.
+  A == B // should be error: cannot be compared, needs proper typeclass drivation of `Eql` to get there.
 
   class C
 
@@ -18,7 +18,7 @@ object Test {
 }
 
 object Test2 {
-  enum Hoge[F[G[_]]] derives Eq {
+  enum Hoge[F[G[_]]] derives Eql {
     case A extends Hoge[[F[_]] => F[Int]]
     case B extends Hoge[[F[_]] => F[String]]
   }
@@ -37,7 +37,7 @@ object Test2 {
 }
 
 object Test3 {
-  enum Hoge[F[G[_]]] derives Eq {
+  enum Hoge[F[G[_]]] derives Eql {
     case A extends Hoge[[X] => List]   // error: wrong kind
     case B extends Hoge[[X] => [Y] => String]  // error: wrong kind
   }

tests/neg/i4470b.scala

@@ -1,10 +1,10 @@
 object RepeatedExtendEnum {
 
-  enum Maybe[T] derives Eq { // error // error
+  enum Maybe[T] derives Eql { // error // error
     case Foo extends Maybe[Int]
   }
 
-  enum Maybe[T] derives Eq { // error
+  enum Maybe[T] derives Eql { // error
     case Foo extends Maybe[Int]
   }
 }

tests/neg/i5546.scala

@@ -8,11 +8,11 @@ object O {
     val m: Meters = 1.0
     assert(m == 1.0)   // OK
   }
-  implicit def eqM: Eq[Meters, Meters] = Eq.derived
+  implicit def eqM: Eql[Meters, Meters] = Eql.derived
 
   opaque type Feet = Double
   object Feet { def apply(d: Double): Feet = d }
-  implicit def eqF: Eq[Feet, Feet] = Eq.derived
+  implicit def eqF: Eql[Feet, Feet] = Eql.derived
 
   def main(args: Array[String]): Unit = {
     println(Feet(3) == Meters(3)) // error: cannot compare