metodos - scala ejemplos

"Dinámicamente" creando clases de casos con macros

Question

Me gustaría crear una jerarquía generada en macro de clases de casos y abstractos sellados. Hubo un ejemplo similar a esto con http://docs.scala-lang.org/overviews/macros/typemacros.html pero ahora está obsoleto. ¿Es esto posible?

Creo que sería increíblemente poderoso generar un AST seguro para una gramática específica. Idealmente con un IDE capaz de resolver todas las clases.

Answer 1

Primero por una descarada autopromoción: Eugene Burmako y yo daremos una charla sobre los proveedores de tipos , un tema estrechamente relacionado, mañana en Scalar 2014 , y los animo a echar un vistazo al proyecto de ejemplo que preparamos para la charla si Estoy interesado en este tipo de cosas.

Si bien las macros de tipo ya no son compatibles, puede lograr esencialmente lo mismo con macroanotaciones de macro paraíso (que está disponible como un complemento para Scala 2.10 y 2.11):

import scala.annotation.StaticAnnotation
import scala.language.experimental.macros
import scala.reflect.macros.Context

// Add constructor arguments here.
class expand extends StaticAnnotation {
  def macroTransform(annottees: Any*) = macro Expander.expand_impl
}

object Expander {
  def expand_impl(c: Context)(annottees: c.Expr[Any]*) = {
    import c.universe._

    annottees.map(_.tree) match {
      case List(q"trait $name") => c.Expr[Any](
        // Add your own logic here, possibly using arguments on the annotation.
        q"""
          sealed trait $name
          case class Foo(i: Int) extends $name
          case class Bar(s: String) extends $name
          case object Baz extends $name
        """
      )
      // Add validation and error handling here.
    }
  }
}

Y entonces:

scala> @expand trait MyADT
defined trait MyADT
defined class Foo
defined class Bar
defined module Baz

Puede agregar argumentos a la anotación que estará disponible en tiempo de compilación, lo que le permitirá analizar un recurso externo que puede usar para generar la implementación de la ADT, por ejemplo.

Las anotaciones macro son muy experimentales y su estado todavía está en el aire; no hay garantía de que se envíen con Scala 2.12, por ejemplo. Algo similar (aunque no del todo tan limpio) es posible usando macros y tipos estructurales simples antiguos: consulte el proyecto de ejemplo vinculado anteriormente para obtener más detalles y algunas demostraciones. En cualquier caso, este tipo de mecanismo es de interés para muchas personas, incluidos los desarrolladores del macro sistema de Scala, por lo que incluso si las anotaciones macro desaparecen en algún momento, es probable que haya alguna manera de lograr lo que has descrito aquí. .