Deriving typeclass instances for generic classes

[adamw]

Let's say we'd like to implement a Show typeclass which gives the most precise name of the type of a given instance (including generic parameters!). For example, for:

case class M[A](x: A)

println(summon[Show[M[Int]]].show(M(10))) should give M[Int].

This is quite easy to do:

trait Show[A]:
  def show(a: A): String

object Show:
  inline def derived[T]: Show[T] = ${derivedImpl[T]}

  def derivedImpl[T](using quotes: Quotes, t: Type[T]): Expr[Show[T]] =
    import quotes.reflect.*
    '{
      new Show[T]:
        override def show(a: T): String = ${Expr[String](TypeTree.of[T].show)}
    }

There are two problems when it comes to using the above in combination with derives. First, an attempt to simply adding the derives to Ms definition fails:

case class M[A](x: A) derives Show

println(summon[Show[M[Int]]].show(M(10)))

// [error] 10 |    println(summon[Show[M[Int]]].show(M(10)))
// [error]    |                                ^
// [error]    |no implicit argument of type Show[M[Int]] was found for parameter x of method summon in object Predef.

Second, even if it did work, as far as I understand it would generate the following code:

// (*)
object M:
  given showSize[A]: Show[M[A]] = Show.derived

which also won't work, as the derived macro is called too early (when the showSize method is defined, not when it is called), causing our test program to output M[A]. To properly implement this, the given needs to be inlined:

case class M[A](x: A)

object M:
  given inline showSize[A]: Show[M[A]] = Show.derived

println(summon[Show[M[Int]]].show(M(10)))

This works as expected.

But two questions remain:

1. shouldn't case class M[A](x: A) derives Show compile - maybe there is an issue for that, but I haven't been able to find one. My intuition is that it should generate code as in (*)
2. stil if derives did generate the code, it wouldn't work as expected. I suppose, we would need a way to tell the compiler to generate an inline given in such a case. Moreover, this should be tied to the definition of the typeclass, not at usage-site. Would sth like @inlineDerives trait Show[A] { def show(a: A): String } be theoretically possible?

The example here is rather simplistic, but of course it comes from a more complicated use-case, here the use-case being derivation of Schema instances in tapir.

[bishabosha]

The following snippet compiles, unfortunately the result of the cached derived instance is always fixed to the type class, not the result of derives (so subclasses are lost):

import scala.quoted.*

trait Show[A]:
  inline def show(a: A): String

object Show:

  given Show[Int] = new:
    inline def show(a: Int): String = "Int"

  inline def derived[T]: ShowGen[T] = ShowGen[T]()

  class ShowGen[T] extends Show[T]:
    inline def show(a: T): String = ${derivedImpl[T]}

  def derivedImpl[T](using Quotes, Type[T]): Expr[String] =
    Expr(Type.show[T])

Ideally the desugared code for case class M[A](x: A) derives Show would look like:

case class M[A](x: A)

object M:
  given Show_derived[A](using Show[A]): Show.ShowGen[M[A]] = Show.derived

@main def Test =
  println(M.Show_derived.show(M(1)))

[adamw]

@bishabosha Thanks, right, but this requires some non-trivial code on the usage side: given Show_derived[A](using Show[A]): Show.ShowGen[M[A]] = .... What I'd like to achieve is to to have good "developer experience" so that the only thing you need to derive a typeclass is adding ... derives Show. Otherwise people need to understand how the typeclass is implemented, and nobody is going to do that ;).

[nicolasstucki]

Small side note

- import quotes.reflect.*
- TypeTree.of[T].show
+ Type.show[T]

[bishabosha]

thanks!