Type Class Derivation Does Not Work With Contravariant Types

Compiler version

3.0.1

Minimized code

import scala.deriving.*
import scala.compiletime.{erasedValue, summonInline}

inline def summonAll[T <: Tuple]: List[Eq[_]] =
  inline erasedValue[T] match
    case _: EmptyTuple => Nil
    case _: (t *: ts) => summonInline[Eq[t]] :: summonAll[ts]

trait Eq[-T]:
  def eqv(x: T, y: T): Boolean

object Eq:
  given Eq[Int] with
    def eqv(x: Int, y: Int) = x == y

  def check(elem: Eq[_])(x: Any, y: Any): Boolean =
    elem.asInstanceOf[Eq[Any]].eqv(x, y)

  def iterator[T](p: T) = p.asInstanceOf[Product].productIterator

  def eqSum[T](s: Mirror.SumOf[T], elems: => List[Eq[_]]): Eq[T] =
    new Eq[T]:
      def eqv(x: T, y: T): Boolean =
        val ordx = s.ordinal(x)
        (s.ordinal(y) == ordx) && check(elems(ordx))(x, y)

  def eqProduct[T](p: Mirror.ProductOf[T], elems: => List[Eq[_]]): Eq[T] =
    new Eq[T]:
      def eqv(x: T, y: T): Boolean =
        iterator(x).zip(iterator(y)).zip(elems.iterator).forall {
          case ((x, y), elem) => check(elem)(x, y)
        }

  inline given derived[T](using m: Mirror.Of[T]): Eq[T] =
    lazy val elemInstances = summonAll[m.MirroredElemTypes]
    inline m match
      case s: Mirror.SumOf[T]     => eqSum(s, elemInstances)
      case p: Mirror.ProductOf[T] => eqProduct(p, elemInstances)
end Eq

enum Opt[+T] derives Eq:
  case Sm(t: T)
  case Nn

@main def test(): Unit =
  import Opt.*
  val eqoi = summon[Eq[Opt[Int]]]
  assert(eqoi.eqv(Sm(23), Sm(23)))
  assert(!eqoi.eqv(Sm(23), Sm(13)))
  assert(!eqoi.eqv(Sm(23), Nn))

Output

no implicit argument of type deriving.Mirror.Of[T] was found for parameter m of given instance derived in object Eq

where:    T is a type variable with constraint >: Opt[T]

Expectation

This example from the documentation does not work when Eq is contravariant instead of invariant.

[adamgfraser]

@odersky I’m not sure what you mean when you say “Eq is invariant anyway”. Eq is not defined in the Scala standard library. It is defined as invariant in some libraries and is defined as contravariant in other libraries, for example here, along with a variety of other functional abstractions.

Furthermore, I would argue that this reflects the natural variance of this data type. It only accepts A values as inputs and never produces them. Covariance and contravariance are two sides of the same coin so seems like a significant limitation that it would work for one and not the other.

Would love to use this feature to support derivation of functional abstractions in ZIO Prelude if we can fix this.

[bishabosha]

after a lot of experimentation I have come up with a good way to break the recursive implicit search, while being efficient with generated code:

/** `P` is supplied from `Eq.derived`, it is the outer sum/product */
inline def summonAll[P, T <: Tuple]: List[Eq[_]] =
  inline erasedValue[T] match
    case _: EmptyTuple => Nil
    case _: (t *: ts) => loopBreaker[P, t] :: summonAll[P, ts]

/** loopBreaker stops summoning a derived typeclass instance from inside its own definition
 *  @note aparently it needs to be defined separately from `summonAll` to avoid an infinite loop
 *  in inlining.
 */
inline def loopBreaker[P, T]: Eq[T] = compiletime.summonFrom {
  case infiniteRecursion: (T =:= P) => compiletime.error("cannot derive Eq, it will cause an infinite loop")
  case recursiveEvidence: (T <:< P) =>
    // summonInline will work because to get here `P` must also have a Mirror instance
    Eq.derived[T](using summonInline[Mirror.Of[T]])

  case existing: Eq[T] => existing
}

This means I can go ahead with a PR to fix the mirror synthesis