scala-macros

Background I'm trying to add a @Prisms annotation to Monocle that will work as follows. Given: @Prisms sealed trait Foo case object A extends Foo case object B extends Foo it will generate a companion object for Foo : object Foo { val a = monocle.macros.GenPrism.apply[Foo, A] val b = monocle.macros.GenPrism.apply[Foo, B] } (or if the companion object already exists, it will add those methods to it). The macro relies on directKnownSubclasses to find A and B , so there will be a note in the Monocle readme recommending that people use Typelevel Scala. I've configured Monocle to use TLS on my

I'm trying to implement an implicit materializer as described here: http://docs.scala-lang.org/overviews/macros/implicits.html I decided to create a macro that converts a case class from and to a String using quasiquotes for prototyping purposes. For example: case class User(id: String, name: String) val foo = User("testid", "foo") Converting foo to text should result in "testid foo" and vice versa. Here is the simple trait and its companion object I have created: trait TextConvertible[T] { def convertTo(obj: T): String def convertFrom(text: String): T } object TextConvertible { import

I'm trying to achieve a StringContext extension which will allow me to write this: val tz = zone"Europe/London" //tz is of type java.util.TimeZone But with the added caveat that it should fail to compile if the supplied time-zone is invalid (assuming that can be determined at compile-time). Here's a helper function: def maybeTZ(s: String): Option[java.util.TimeZone] = java.util.TimeZone.getAvailableIDs collectFirst { case id if id == s => java.util.TimeZone.getTimeZone(id) } I can create a non-macro implementation very easily: scala> implicit class TZContext(val sc: StringContext) extends

I am writing a macro that needs to create a class that rewrites a trait, having the same methods/args of the trait but different return type. So say we got: trait MyTrait[T] { def x(t1: T)(t2: T): T } @AnnProxy class MyClass[T] extends MyTrait[T] MyClass will be rewritten to: class MyClass[T] { def x(t1: T)(t2: T): R[T] } (so x will now return R[T] instead of T) I wrote the macro and debugging it, it produces this code: Expr[Any](class MyClass[T] extends scala.AnyRef { def <init>() = { super.<init>(); () }; def x(t1: T)(t2: T): macrotests.R[T] = $qmark$qmark$qmark }) @AnnProxy As you see the

I'm new to scala macros and I'm using scala 2.10.0-RC3. I want to write a macro that adds a function to a class. Usage example: trait MyTrait { def addF = macro { /*add "def f = 3" to class*/ } } class MyClass extends MyTrait { addF //Adds the "def f" to MyClass } object Main { val t = new MyClass assert(t.f==3) } I need this in the following scenario. My first try didn't use macros but didn't work, because I can't inherit the same trait twice. trait AddF[T] { def f(t: T) { /* ...do sthg ... */ } } class MyClass extends AddF[Int] with AddF[String] With the macro solution I could write class