scala-macros

I have a bit of a sense of the Aux pattern (as used in shapeless and elsewhere) in which a type member is extracted into a type parameter, and I know it's a workaround the fact that arguments in the same argument list can't depend on each other -- but I'm not clear generally what it's used for and what problems it solves. For example, I'm currently trying to figure out how to preserve and work with the more specific type returned by a whitebox macro -- is this a usecase for Aux? Is there a simple description? Simply speaking this pattern lets you establish a relation between two generic type

I'm trying to generate case object s for every case member of every child case class of a sealed trait. I'm able to generate the code in the macro but I don't know how to use this in my code. Example usecase: sealed trait Item sealed trait Field { val name: String } case class Product(id: String, name: String) extends Item It should generate the following case object s which are fields of Product . case object ProductIdField extends Field { val name = "Product Id" } case object ProductNameField extends Field { val name = "Product Name" } Macro so far which generates the code import scala

What is the best way to add a Scala compiler plugin to the scalaCompile task in Gradle? Add a configuration for compiler plugins: configurations { scalaCompilerPlugin } Add compiler plugin dependencies: dependencies { scalaCompilerPlugin "org.scalamacros:paradise_2.11.7:2.1.0" } Set up the option: tasks.withType(ScalaCompile) { scalaCompileOptions.additionalParameters = [ "-Xplugin:" + configurations.scalaCompilerPlugin.asPath ] } I was able to use Macro Paradise in a Gradle-built project with this setup. 来源： https://stackoverflow.com/questions/35439912/gradle-scala-plugin-corollary-to

I'll start with an example. Here's an equivalent of List.fill for tuples as a macro in Scala 2.10: import scala.language.experimental.macros import scala.reflect.macros.Context object TupleExample { def fill[A](arity: Int)(a: A): Product = macro fill_impl[A] def fill_impl[A](c: Context)(arity: c.Expr[Int])(a: c.Expr[A]) = { import c.universe._ arity.tree match { case Literal(Constant(n: Int)) if n < 23 => c.Expr( Apply( Select(Ident("Tuple" + n.toString), "apply"), List.fill(n)(a.tree) ) ) case _ => c.abort( c.enclosingPosition, "Desired arity must be a compile-time constant less than 23!" ) }

I am trying to use Scala macros to create a case class map of single-parameter copy methods, with each method accepting a Play Json JsValue and a case class instance, and returning an updated copy of the instance. However, I am running into problems with the macro syntax for returning a function object. Given a case class case class Clazz(id: Int, str: String, strOpt: Option[String]) the intention is to create a map of the class's copy methods implicit def jsonToInt(json: JsValue) = json.as[Int] implicit def jsonToStr(json: JsValue) = json.as[String] implicit def jsonToStrOpt(json: JsValue) =

I'm making a Scala app that sets by reflection field values. This works OK. However, in order to set field values I need a created instance. If I have a class with an empty constructor, I can do this easily with classOf[Person].getConstructors.... However, when I try doing this with a Case class with a non empty constructor It doesn't work. I have all of the field names and its values, as well as the Object type I need to create. Can I instance the Case Class somehow with what I've got? The only thing I don't have is the parameter names from the Case Class constructor or a way to create this

Given how difficult it is to know whether an arithmetic final val expression will be compiled to a compile-time constant, and how easy it is to accidentally break compile-time-ness ... Can anyone think of an easy way to verify, at compile-time, that the compiler has actually created a compile-time constant from, say, a complex arithmetic expression? I'm guessing this might be some kind of annotation or macro, but maybe there's something simpler. For example, maybe something like: @CompileTime final val HALF_INFINITY = Int.MaxValue / 2 would be possible. Luckily enough, macros are wired into