# How to write a type class `derived` method using macros

In the main derivation documentation page, we explained the details behind `Mirror`

s and type class derivation. Here we demonstrate how to implement a type class `derived`

method using macros only. We follow the same example of deriving `Eq`

instances and for simplicity we support a `Product`

type e.g., a case class `Person`

. The low-level technique that we will use to implement the `derived`

method exploits quotes, splices of both expressions and types and the `scala.quoted.Expr.summon`

method which is the equivalent of `scala.compiletime.summonFrom`

. The former is suitable for use in a quote context, used within macros.

As in the original code, the type class definition is the same:

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

We need to implement an inline method `Eq.derived`

on the companion object of `Eq`

that calls into a macro to produce a quoted instance for `Eq[T]`

. Here is a possible signature:

```
inline def derived[T]: Eq[T] = ${ derivedMacro[T] }
def derivedMacro[T: Type](using Quotes): Expr[Eq[T]] = ???
```

Note, that since a type is used in a subsequent macro compilation stage it will need to be lifted to a `quoted.Type`

by using the corresponding context bound (seen in `derivedMacro`

).

For comparison, here is the signature of the inline `derived`

method from the main derivation page:

```
inline def derived[T](using m: Mirror.Of[T]): Eq[T] = ???
```

Note that the macro-based `derived`

signature does not have a `Mirror`

parameter. This is because we can summon the `Mirror`

inside the body of `derivedMacro`

thus we can omit it from the signature.

One additional possibility with the body of `derivedMacro`

here as opposed to the one with `inline`

is that with macros it is simpler to create a fully optimised method body for `eqv`

.

Let's say we wanted to derive an `Eq`

instance for the following case class `Person`

,

```
case class Person(name: String, age: Int) derives Eq
```

the equality check we are going to generate is the following:

```
(x: Person, y: Person) =>
summon[Eq[String]].eqv(x.productElement(0), y.productElement(0))
&& summon[Eq[Int]].eqv(x.productElement(1), y.productElement(1))
```

Note that it is possible, by using the reflection API, to further optimise and directly reference the fields of

`Person`

, but for clear understanding we will only use quoted expressions.

The code to generates this body can be seen in the `eqProductBody`

method, shown here as part of the definition for the `derivedMacro`

method:

```
def derivedMacro[T: Type](using Quotes): Expr[Eq[T]] =
val ev: Expr[Mirror.Of[T]] = Expr.summon[Mirror.Of[T]].get
ev match
case '{ $m: Mirror.ProductOf[T] { type MirroredElemTypes = elementTypes }} =>
val elemInstances = summonInstances[T, elementTypes]
def eqProductBody(x: Expr[Product], y: Expr[Product])(using Quotes): Expr[Boolean] = {
if elemInstances.isEmpty then
Expr(true)
else
elemInstances.zipWithIndex.map {
case ('{ $elem: Eq[t] }, index) =>
val indexExpr = Expr(index)
val e1 = '{ $x.productElement($indexExpr).asInstanceOf[t] }
val e2 = '{ $y.productElement($indexExpr).asInstanceOf[t] }
'{ $elem.eqv($e1, $e2) }
}.reduce((acc, elem) => '{ $acc && $elem })
end if
}
'{ eqProduct((x: T, y: T) => ${eqProductBody('x.asExprOf[Product], 'y.asExprOf[Product])}) }
// case for Mirror.SumOf[T] ...
```

Note, that in the version without macros, we can merely write `summonInstances[T, m.MirroredElemTypes]`

inside the inline method but here, since `Expr.summon`

is required, we can extract the element types in a macro fashion. Being inside a macro, our first reaction would be to write the code below:

```
'{
summonInstances[T, $m.MirroredElemTypes]
}
```

However, since the path inside the type argument is not stable this cannot be used. Instead we extract the tuple-type for element types using pattern matching over quotes and more specifically of the refined type:

```
case '{ $m: Mirror.ProductOf[T] { type MirroredElemTypes = elementTypes }} => ...
```

Shown below is the implementation of `summonInstances`

as a macro, which for each type `elem`

in the tuple type, calls `deriveOrSummon[T, elem]`

.

To understand `deriveOrSummon`

, consider that if `elem`

derives from the parent `T`

type, then it is a recursive derivation. Recursive derivation usually happens for types such as `scala.collection.immutable.::`

. If `elem`

does not derive from `T`

, then there must exist a contextual `Eq[elem]`

instance.

```
def summonInstances[T: Type, Elems: Type](using Quotes): List[Expr[Eq[?]]] =
Type.of[Elems] match
case '[elem *: elems] => deriveOrSummon[T, elem] :: summonInstances[T, elems]
case '[EmptyTuple] => Nil
def deriveOrSummon[T: Type, Elem: Type](using Quotes): Expr[Eq[Elem]] =
Type.of[Elem] match
case '[T] => deriveRec[T, Elem]
case _ => '{ summonInline[Eq[Elem]] }
def deriveRec[T: Type, Elem: Type](using Quotes): Expr[Eq[Elem]] =
Type.of[T] match
case '[Elem] => '{ error("infinite recursive derivation") }
case _ => derivedMacro[Elem] // recursive derivation
```

The full code is shown below:

```
import compiletime.*
import scala.deriving.*
import scala.quoted.*
trait Eq[T]:
def eqv(x: T, y: T): Boolean
object Eq:
given Eq[String] with
def eqv(x: String, y: String) = x == y
given Eq[Int] with
def eqv(x: Int, y: Int) = x == y
def eqProduct[T](body: (T, T) => Boolean): Eq[T] =
new Eq[T]:
def eqv(x: T, y: T): Boolean = body(x, y)
def eqSum[T](body: (T, T) => Boolean): Eq[T] =
new Eq[T]:
def eqv(x: T, y: T): Boolean = body(x, y)
def summonInstances[T: Type, Elems: Type](using Quotes): List[Expr[Eq[?]]] =
Type.of[Elems] match
case '[elem *: elems] => deriveOrSummon[T, elem] :: summonInstances[T, elems]
case '[EmptyTuple] => Nil
def deriveOrSummon[T: Type, Elem: Type](using Quotes): Expr[Eq[Elem]] =
Type.of[Elem] match
case '[T] => deriveRec[T, Elem]
case _ => '{ summonInline[Eq[Elem]] }
def deriveRec[T: Type, Elem: Type](using Quotes): Expr[Eq[Elem]] =
Type.of[T] match
case '[Elem] => '{ error("infinite recursive derivation") }
case _ => derivedMacro[Elem] // recursive derivation
inline def derived[T]: Eq[T] = ${ derivedMacro[T] }
def derivedMacro[T: Type](using Quotes): Expr[Eq[T]] =
val ev: Expr[Mirror.Of[T]] = Expr.summon[Mirror.Of[T]].get
ev match
case '{ $m: Mirror.ProductOf[T] { type MirroredElemTypes = elementTypes }} =>
val elemInstances = summonInstances[T, elementTypes]
def eqProductBody(x: Expr[Product], y: Expr[Product])(using Quotes): Expr[Boolean] = {
if elemInstances.isEmpty then
Expr(true)
else
elemInstances.zipWithIndex.map {
case ('{ $elem: Eq[t] }, index) =>
val indexExpr = Expr(index)
val e1 = '{ $x.productElement($indexExpr).asInstanceOf[t] }
val e2 = '{ $y.productElement($indexExpr).asInstanceOf[t] }
'{ $elem.eqv($e1, $e2) }
}.reduce((acc, elem) => '{ $acc && $elem })
end if
}
'{ eqProduct((x: T, y: T) => ${eqProductBody('x.asExprOf[Product], 'y.asExprOf[Product])}) }
case '{ $m: Mirror.SumOf[T] { type MirroredElemTypes = elementTypes }} =>
val elemInstances = summonInstances[T, elementTypes]
val elements = Expr.ofList(elemInstances)
def eqSumBody(x: Expr[T], y: Expr[T])(using Quotes): Expr[Boolean] =
val ordx = '{ $m.ordinal($x) }
val ordy = '{ $m.ordinal($y) }
'{ $ordx == $ordy && $elements($ordx).asInstanceOf[Eq[Any]].eqv($x, $y) }
'{ eqSum((x: T, y: T) => ${eqSumBody('x, 'y)}) }
end derivedMacro
end Eq
```