Erased eDSL

[Adam-Vandervorst]

The idea is to have zero-overhead embedded DSLs using erased classes with erased methods as combinators, compiled to Scala via metaprogramming.

As a minimal example, let's say we want a DSL for constructing and manipulating functions

// rf.scala

sealed trait RichFunction[X, Y]:
  def apply(x: X): Y

  def subsIn[Z](other: RichFunction[Y, Z]) = SubsIn(this, other)

erased case class Wrapped[X, Y](f: X => Y) extends RichFunction[X, Y]:
  override def apply(x: X): Y = f(x)

erased case class SubsIn[X, Y, Z](f: RichFunction[X, Y], g: RichFunction[Y, Z]) extends RichFunction[X, Z]:
  override def apply(x: X): Z = g(f(x))

which can be used as follow:

// main.scala
erased val incr: Wrapped[Int, Int] = Wrapped((x: Int) => x + 1)
erased val double: Wrapped[Int, Int] = Wrapped(x => 2*x)
erased val combined: RichFunction[Int, Int] = double subsIn incr

@main def example =
  println(show(compileRF(combined)))
  // ideally prints "(x: Int) => 2*x + 1"

with the attempted implementation:

// macro.scala
object Impl:
  import scala.quoted.*

  def show(e: Expr[Any])(using Quotes): Expr[String] =
    Expr(e.show)

  def compileRF[X : Type, Y : Type](erf: Expr[RichFunction[X, Y]])(using q: Quotes): Expr[X => Y] =
    import q.reflect.*

    erf match
      case '{ Wrapped[X, Y]($ef) } =>
        ef
      case '{ SubsIn[X, yt, Y]($erff, $erfg) } =>
        val ef = compileRF[X, yt](erff.asInstanceOf)
        val eg = compileRF[yt, Y](erfg.asInstanceOf)
        Expr.betaReduce('{ x => ${eg}(${ef}(x)) })

inline def show(inline a: Any): String = ${ Impl.show('a) }

inline def compileRF[X, Y](inline rf: RichFunction[X, Y]): X => Y = ${ Impl.compileRF('rf) }

Is this something in the language's vision?
Currently, this bumps into a couple of conflicts (like case classes not being erasable), but I was surprised by how elegantly erased and metaprogramming could model this together.
Moreover, many common paradigms like those of IO and database-ops could be expressed like this without causing overhead.

[prolativ]

I think you really shouldn't need to have erased case classes - normal erased classes should be enough - you can already call their constructors without new and you don't need default implementations of equals and hashCode because these classes won't be used at runtime. You're also not going to pattern-match on them - in cases like case '{ Wrapped[X, Y]($ef) } => you pattern match on syntax trees instead. From what I can see the only inconvenience would be that for non-case classes constructor's parameters are not public by default and you would need to write val before them explicitly