Provide default implicit parameters in `derives` when Case Class with type parameters

[djx314]

Now there is a product environment.

case class Foo[T](model: Option[T], message: String)

like I use play-json. Then I can

case class Foo[T](model: Option[T], message: String) derives Reads

Then perhaps when in the code summon[Foo[String]], I need to provide the Reads[Option[T]].
In play-json, it needs to provide a special Reads for Option[String].

But now I write a common [T] =>> Reads[Option[T]] in my project and I don't want to import it in the target code when it finally need Reads[Option[T]]. I want to do something like.

import special.given
case class Foo[T](model: Option[T], message: String) derives(using Reads[T]) Reads

// target code
Json.toJson(Foo(Option(21), 3))

But not

case class Foo[T](model: Option[T], message: String) derives Reads

// target code
import special.given
Json.toJson(Foo(Option(21), 3))

To be short, some transformation details of given should be manually enclosed when the case class is defined.

[djx314]

It's the same problem as the code in Scala2.
We should write

case class Foo[T](model: Option[T], message: String)
object Foo {
  implicit def model1Encoder(implicit enc: Encoder[T]): Encoder[Foo[T]] = derivesEncoder
}

But not

case class Foo[T](model: Option[T], message: String)
object Foo {
  implicit def model1Encoder(implicit enc: Encoder[Option[T]]): Encoder[Foo[T]] = derivesEncoder
}

In fact, if derives can provide implicit parameters, the derived method implemented can even no need to consider with type parameters.

[djx314]

And further, I think implicit enc: Encoder[T] and implicit enc: Encoder[Option[T]] is both necessary. Because it's not only List[T] and Option[T], but also YourTypeClass[T]. This is too heavy a burden for macro.

[makkarpov]

Moreover, there are cases where that [T] is not significant. I.e. your actual typeclass implementation does not depend on that T. Consider the following example:

trait Shape[S] {
  def inlets(shape: S): Set[Inlet[?]]
  def outlets(shape: S): Set[Outlet[?]]
}

case class FlowShape[A, B](in: Inlet[A], out: Outlet[B]) derives Shape

// expected derivation:
given Shape[FlowShape] with {
  def inlets(s: FlowShape): Set[Inlet[?]] = Set(s.in)
  def outlets(s: FlowShape): Set[Outlet[?]] = Set(s.out)
}

Shape does not depend neither on A nor B (they could be arbitrary types), and automatic requirement for Shape[A] and Shape[B] is a blocker here. You just cannot use derives to derive that kind of type classes, as it will produce unusable code.

Derivation mechanism should be more flexible in cases like this.