Deriving infrastructure in typelevel

Author: odersky

compiler/src/dotty/tools/dotc/core/Definitions.scala

@@ -647,6 +647,16 @@ class Definitions {
     def Product_productElement(implicit ctx: Context): Symbol = Product_productElementR.symbol
     lazy val Product_productPrefixR: TermRef = ProductClass.requiredMethodRef(nme.productPrefix)
     def Product_productPrefix(implicit ctx: Context): Symbol = Product_productPrefixR.symbol
+
+  lazy val ShapedType: TypeRef                        = ctx.requiredClassRef("scala.typelevel.Shaped")
+  def ShapedClass(implicit ctx: Context): ClassSymbol = ShapedType.symbol.asClass
+  lazy val ShapeType: TypeRef                         = ctx.requiredClassRef("scala.typelevel.Shape")
+  def ShapeClass(implicit ctx: Context): ClassSymbol  = ShapeType.symbol.asClass
+  lazy val ShapeCaseType: TypeRef                     = ctx.requiredClassRef("scala.typelevel.Shape.Case")
+  def ShapeCaseClass(implicit ctx: Context): ClassSymbol = ShapeCaseType.symbol.asClass
+  lazy val ShapeCasesType: TypeRef                    = ctx.requiredClassRef("scala.typelevel.Shape.Cases")
+  def ShapeCasesClass(implicit ctx: Context): ClassSymbol = ShapeCasesType.symbol.asClass
+
   lazy val LanguageModuleRef: TermSymbol = ctx.requiredModule("scala.language")
   def LanguageModuleClass(implicit ctx: Context): ClassSymbol = LanguageModuleRef.moduleClass.asClass
   lazy val NonLocalReturnControlType: TypeRef   = ctx.requiredClassRef("scala.runtime.NonLocalReturnControl")

compiler/src/dotty/tools/dotc/core/StdNames.scala

@@ -346,6 +346,7 @@ object StdNames {
     val RootClass: N            = "RootClass"
     val Scala2: N               = "Scala2"
     val Select: N               = "Select"
+    val Shape: N                = "Shape"
     val StringContext: N        = "StringContext"
     val This: N                 = "This"
     val ThisType: N             = "ThisType"

library/src-scala3/scala/typelevel/Mirror.scala

@@ -0,0 +1,18 @@
+package scala.typelevel
+
+/** A generic representation of a case in an ADT
+  *  @param  deriving  The companion object of the ADT
+  *  @param  ordinal   The ordinal value of the case in the list of the ADT's cases
+  *  @param  elems     The elements of the case
+  */
+class Mirror(val reflected: ReflectedClass, val ordinal: Int, val elems: Product) {
+
+  /** The `n`'th element of this generic case */
+  def apply(n: Int): Any = elems.productElement(n)
+
+  /** The name of the constructor of the case reflected by this mirror */
+  def caseLabel: String = reflected.label(ordinal, 0)
+
+  /** The label of the `n`'th element of the case reflected by this mirror */
+  def elementLabel(n: Int) = reflected.label(ordinal, n + 1)
+}

library/src-scala3/scala/typelevel/Reflected.scala

@@ -0,0 +1,16 @@
+package scala.typelevel
+
+/** A class for mapping between an ADT value and
+  *  the case mirror that represents the value.
+  */
+abstract class Reflected[T] {
+
+  /** The case mirror corresponding to ADT instance `x` */
+  def reflect(x: T): Mirror
+
+  /** The ADT instance corresponding to given `mirror` */
+  def reify(mirror: Mirror): T
+
+  /** The companion object of the ADT */
+  def common: ReflectedClass
+}

library/src-scala3/scala/typelevel/ReflectedClass.scala

@@ -0,0 +1,57 @@
+package scala.typelevel
+import annotation.tailrec
+
+/** @param caseLabels The case and element labels of the described ADT as encoded strings.
+*/
+class ReflectedClass(caseLabels: Array[String]) {
+  import ReflectedClass._
+
+  /** A mirror of case with ordinal number `ordinal` and elements as given by `Product` */
+  def mirror(ordinal: Int, product: Product): Mirror =
+    new Mirror(this, ordinal, product)
+
+  /** A mirror with elements given as an array */
+  def mirror(ordinal: Int, elems: Array[AnyRef]): Mirror =
+    mirror(ordinal, new ArrayProduct(elems))
+
+  /** A mirror with an initial empty array of `numElems` elements, to be filled in. */
+  def mirror(ordinal: Int, numElems: Int): Mirror =
+    mirror(ordinal, new Array[AnyRef](numElems))
+
+  /** A mirror of a case with no elements */
+  def mirror(ordinal: Int): Mirror =
+    mirror(ordinal, EmptyProduct)
+
+  private[typelevel] def label(ordinal: Int, idx: Int): String = {
+    val labels = caseLabels(ordinal)
+    @tailrec def separatorPos(from: Int): Int =
+      if (from == labels.length || labels(from) == separator) from
+      else separatorPos(from + 1)
+    @tailrec def findLabel(count: Int, idx: Int): String =
+      if (idx == labels.length) ""
+      else if (count == 0) labels.substring(idx, separatorPos(idx))
+      else findLabel(if (labels(idx) == separator) count - 1 else count, idx + 1)
+    findLabel(idx, 0)
+  }
+}
+
+object ReflectedClass {
+
+  private final val separator = '\000'
+
+  /** Helper class to turn arrays into products */
+  private class ArrayProduct(val elems: Array[AnyRef]) extends Product {
+    def canEqual(that: Any): Boolean = true
+    def productElement(n: Int) = elems(n)
+    def productArity = elems.length
+    override def productIterator: Iterator[Any] = elems.iterator
+    def update(n: Int, x: Any) = elems(n) = x.asInstanceOf[AnyRef]
+  }
+
+  /** Helper object */
+  private object EmptyProduct extends Product {
+    def canEqual(that: Any): Boolean = true
+    def productElement(n: Int) = throw new IndexOutOfBoundsException
+    def productArity = 0
+  }
+}

library/src-scala3/scala/typelevel/Shape.scala

@@ -0,0 +1,16 @@
+package scala.typelevel
+
+/** The shape of an ADT.
+  *  This is eithe a product (`Case`) or a sum (`Cases`) of products.
+  */
+sealed abstract class Shape
+
+object Shape {
+
+  /** A sum with alternative types `Alts` */
+  case class Cases[Alts <: Tuple] extends Shape
+
+  /** A product type `T` with element types `Elems` */
+  case class Case[T, Elems <: Tuple] extends Shape
+}
+

library/src-scala3/scala/typelevel/Shaped.scala

@@ -0,0 +1,6 @@
+package scala.typelevel
+
+/** Every generic derivation starts with a typeclass instance of this type.
+  *  It informs that type `T` has shape `S` and also implements runtime reflection on `T`.
+  */
+abstract class Shaped[T, S <: Shape] extends Reflected[T]

library/src-scala3/scala/typelevel/package.scala

@@ -4,8 +4,6 @@ package object typelevel {
 
   erased def erasedValue[T]: T = ???
 
-  case class Typed[T](val value: T) { type Type = T }
-
   inline def error(inline msg: String, objs: Any*): Nothing = ???
 
   inline def constValueOpt[T]: Option[T] = ???