“dynamically” creating case classes with macros

by

First for some shameless self-promotion: Eugene Burmako and I are giving a talk on type providers, a closely related topic, at Scalar 2014 tomorrow, and I encourage you to take a look at the example project we put together for the talk if you’re interested in this kind of thing.

While type macros are no longer supported, you can accomplish essentially the same thing with macro annotations from macro paradise (which is available as a plugin for Scala 2.10 and 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.
    }
  }
}

And then:

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

You can add arguments to the annotation that will be available at compile time, allowing you to parse an external resource that you can use to generate the implementation of the ADT, for example.

Macro annotations are very experimental and their status is still up in the air—there’s no guarantee that they’ll ship with Scala 2.12, for example. Something similar (although not quite so clean) is possible using plain old def macros and structural types—see the example project linked above for more detail and some demonstrations. In any case, this kind of mechanism is of interest to many people, including the developers of Scala’s macro system, so even if macro annotations disappear at some point down the road, there’s likely to be some way to accomplish what you’ve described here.

More Related Contents:

  1. Scala Macros: Making a Map out of fields of a class in Scala
  2. Case objects vs Enumerations in Scala
  3. Cleaner way to update nested structures
  4. Iteration over a sealed trait in Scala?
  5. Case class equality in Apache Spark
  6. What is the difference between Scala’s case class and class?
  7. How to define schema for custom type in Spark SQL?
  8. How to override apply in a case class companion
  9. How to get around the Scala case class limit of 22 fields?
  10. Case class to map in Scala
  11. Mixing in a trait dynamically
  12. Weird behavior trying to convert case classes to heterogeneous lists recursively with Shapeless
  13. Easy idiomatic way to define Ordering for a simple case class
  14. What is *so* wrong with case class inheritance?
  15. Scala case class inheritance
  16. Method Override with Scala 3 Macros
  17. How to access parameter list of case class in a dotty macro
  18. Scala macros: What is the difference between typed (aka typechecked) and untyped Trees
  19. Overload constructor for Scala’s Case Classes?
  20. Static return type of Scala macros
  21. Why is parameter in contravariant position?
  22. Creating a method definition tree from a method symbol and a body
  23. Should I use the final modifier when declaring case classes?
  24. Scala 2.10 reflection, how do I extract the field values from a case class, i.e. field list from case class
  25. Howto model named parameters in method invocations with Scala macros?
  26. How is this case class match pattern working?
  27. Getting subclasses of a sealed trait
  28. Scala3: Crafting Types Through Metaprogramming?
  29. What Scala web-frameworks are available? [closed]
  30. Unable to map on HList

Leave a Comment