为正整数编写宏

Question

Given the following types:

sealed trait PosIntCheckResult
case class LteZero(x: Int) extends PosIntCheckResult
case object NotConstant extends PosIntCheckResult

I'm trying to write a macro that checks whether the given Int is greater than 0.

import reflect.macros.Context

def getInt(c: Context)(value: c.Expr[Int]): Either[PosIntCheckResult, Int] = {

    import c.universe._

    value.tree match {
        case Literal(Constant(x)) => if (x > 0) Right(x) else Left(LteZero(x))
        case _                    => Left(NotConstant)
    }
}

But Any shows up for the x value:

Test.scala:29: type mismatch;
  found   : Any
  required: Int
    case Literal(Constant(x)) => 
       if (x > 0) Right(x) else Left(LteZero(x))

How can I get the compiler to expect an Int rather than Any ?

Answer 1

You just have to match on patterns where x is an Int :

case Literal(Constant(x: Int)) => //When using x here, it is an Int

Read about pattern matching on type and the other types of pattern matching in the docs .

You should also note that your macro will need to return an Expr in order to work. You can use reify to construct the desired Exprs at each case . Read about reify and def macros here . I'm not sure why this needs to be a macro, but if you're just learning the techniques, something like this might work:

object Macros {
    def getInt(value: Int): Either[PosIntCheckResult, Int] = macro getIntImpl

    def getIntImpl(c: Context)(value: c.Expr[Int]): c.Expr[Either[PosIntCheckResult,Int]] = {

        import c.universe._

        value.tree match {
            case x@Literal(Constant(const: Int)) if const > 0 => reify(Right(c.Expr[Int](x).splice))
            case x@Literal(Constant(_: Int)) => reify(Left(LteZero(c.Expr[Int](x).splice)))
            case _  => reify(Left(NotConstant))
        }
    }
}