Scala quasiquote concatenation

Question

I'm new to scala macros and I spent a couple of days trying to write my very first one. I have a problem with quasiquotes concatenation.

There is a list of case clauses, let's say the following:

val cases = cq"x => 1 " :: cq"_ => 0 " :: Nil

And I need to build a partial function from it. The problem is that I don't have an idea how to paste them in the final quasiquote. The documentation says I should do something like this:

q"{ case ..$cases }"

but it doesn't work if I do so.

Is there a way to build a PartialFunction from such a list?

Thanks for any help.

I believe this is correct approach. What error you have exactly? — Odomontois, May 20 '15 at 08:15
Also your pattern is bit strange `x => 1` mathes any expression, if you are referencing to some local value named `x` you should use `\`x\` => 1` as patern — Odomontois, May 20 '15 at 08:25
The error is the following: exception during macro expansion: java.lang.IllegalArgumentException: scala.collection.immutable.List(case (x @ _) => 1, case _ => 0) is not valid representation of pattern match case. — Natalia Grybovska, May 20 '15 at 09:06
My pattern doesn't make any sense now, I just took something very simple. — Natalia Grybovska, May 20 '15 at 09:08
And it works if I write like this: val case1 = cq"x => 1 " val case2 = cq"_ => 0 " val tree = q""" { case $case1 case $case2 } """ — Natalia Grybovska, May 20 '15 at 09:14
Can you please provide more details. I can't really reproduce the issue on 2.11.6. https://gist.github.com/densh/377df69df170fa205f3b — Denys Shabalin, May 20 '15 at 13:58

Ben Reich · Accepted Answer · 2015-05-20T16:52:37.627

The following works for me with 2.11.2:

import scala.reflect.macros.Context
object Macros {
    def partial: PartialFunction[Int, Int] = macro partialImpl
    def partialImpl(c: Context): c.Expr[PartialFunction[Int, Int]]= {
        import c.universe._
        val cases = cq"x => 1 " :: cq"_ => 0 " :: Nil
        val pf = q"{ case ..$cases } : PartialFunction[Int, Int]"
        c.Expr[PartialFunction[Int, Int]](pf)

    }
}

Then you can call Macros.partial(1), for example, or Macros.partial.isDefinedAt(2).

Note that in order to make this work, I had to explicitly use PartialFunction[Int, Int] in the quasiquote q"{ case ..$cases } : PartialFunction[Int, Int]". It didn't work without the explicit type definition (it otherwise assumes PartialFunction[Any, Int]).

Here is the specification for quasiquote Syntax for partial functions. It works as a pure syntax tree, but apparently cannot be interpreted as a typed expression except PartialFunction[Any, T] by a macro unless the type is made explicit.

Pattern matching anon funcs can be Function or PartialFunction depending on the expected type. — som-snytt, May 20 '15 at 16:15
Your code has a bug: `PartialFunction[Int, Int]{ case ... }` will create a PartialFunction that is defined on the whole domain. What you want is instead `{ case ... }: PartialFunction[Int, Int]` — Régis Jean-Gilles, May 20 '15 at 16:46

Scala quasiquote concatenation

1 Answers1