Language: Scala · Versions: Scala 3.6.2
The problem
I'm deriving a recursive typeclass (Schema[T]) using Scala 3's derives and Mirror.Of[T] (inline given derived[T](using m: Mirror.Of[T]): Schema[T]). When I derive Schema for a recursive ADT (enum Tree { case Leaf(v: Int); case Branch(left: Tree, right: Tree) }), summonInline[Schema[Tree]] inside the inline synthesis for Branch's fields either blows the compiler's recursion limit (Xmax-inlines) or causes a NullPointerException at runtime due to cyclic lazy val / given initialization!
Minimal example
import scala.deriving.Mirror
import scala.compiletime.{erasedValue, summonInline}
trait Schema[T]:
def describe(depth: Int): String
object Schema:
given Schema[Int] with
def describe(depth: Int) = "Int"
inline def summonAll[T <: Tuple]: List[Schema[?]] =
inline erasedValue[T] match
case _: EmptyTuple => Nil
case _: (t *: ts) => summonInline[Schema[t]] :: summonAll[ts]
inline given derived[T](using m: Mirror.Of[T]): Schema[T] =
val elemSchemas = summonAll[m.MirroredElemTypes]
new Schema[T]:
def describe(depth: Int) =
if depth <= 0 then "..." else elemSchemas.map(_.describe(depth - 1)).mkString("(", ",", ")")
enum Tree derives Schema:
case Leaf(v: Int)
case Branch(left: Tree, right: Tree)
Expected
summon[Schema[Tree]].describe(2) compiles and evaluates without infinite inline expansion or NullPointerException.
What happens instead
During expansion of Tree.derived, summonAll summons Schema[Branch], whose MirroredElemTypes is (Tree, Tree). Eagerly evaluating val elemSchemas = summonAll[m.MirroredElemTypes] before constructing new Schema[T] either loops at compile time (if derived is summoned recursively inline) or reads Tree.given_Schema_Tree while it is still null during object initialization!
What is the canonical Scala 3.6 pattern (using by-name => Schema[T] vs lazy val inside new Schema[T] vs compiletime.deferred) to make Mirror.Of typeclass derivation safe for mutually recursive ADTs?
Make the element schemas lazy. This is the pattern I'd use, but I haven't compiled it, so check it on 3.6.2.
import scala.deriving.Mirror
import scala.compiletime.{erasedValue, summonInline}
trait Schema[T]:
def describe(depth: Int): String
object Schema:
given Schema[Int] with
def describe(depth: Int) = "Int"
// by-name elements: nothing is forced while the list is built
inline def summonAll[T <: Tuple]: List[() => Schema[?]] =
inline erasedValue[T] match
case _: EmptyTuple => Nil
case _: (t *: ts) => (() => summonInline[Schema[t]]) :: summonAll[ts]
inline given derived[T](using m: Mirror.Of[T]): Schema[T] =
new Schema[T]:
private lazy val elems: List[Schema[?]] = summonAll[m.MirroredElemTypes].map(_())
def describe(depth: Int) =
if depth <= 0 then "..." else elems.map(_.describe(depth - 1)).mkString("(", ",", ")")
Why it works
derives Schemagenerates a non-inlinegiven derived$Schema: Schema[Tree] = Schema.derived. That is an alias given, which compiles to a lazy val. Inside it,Schema[Branch]is derived inline, and that needsSchema[Tree].Schema[Tree]resolves to the lazy val that is still being initialized. This is what I'm inferring from the symptoms you describe, not something I verified. It means your eagerval elemSchemasreads the instance while it is under construction, which is thenull/cycle you see.- With
lazy val elemsinside the anonymous class, the instance is fully built and published first. The cyclic reference is only dereferenced on the firstdescribecall. - The compile-time side stays finite.
summonInline[Schema[Tree]]resolves to the existing given by reference, so it does not re-expandderived[Tree]. If you still hit-Xmax-inlines, the cause is something else, such as an ADT with no given for a field type.
Alternatives
- By-name constructor parameters (
class Product[T](elems: => List[Schema[?]])) are equivalent. That is how most libraries structure it, with a non-inline helper class. compiletime.deferredis not the tool here. It was added in 3.6 and is experimental, as I recall (it needs the modularity experimental import). It is meant for abstract givens in traits that a subclass must supply, not for breaking init cycles.- If one particular case still fails, put a
private lazy valthere, or adefwith caching. Adefis also fine for a schema this small.