宏訪問在運行時

源代碼的文本已經存在或是否有可能有一個斯卡拉宏，讓我訪問源的文本？比如我想這樣寫代碼：宏訪問在運行時

val list = List(1, 2, 3) 
val (text, sum) = (list.sum).withSource{(source, sum) => (source, sum)} 
// would return ("list.sum", 6) 
(list.sum).withSource{(source, sum) => println(s"$source: $sum"} 
// prints list.sum: 6

來源

2013-04-12 huynhjl

我剛剛發現有類似的功能（及以上）在以下庫中：https://github.com/retronym/macrocosm;看'log'，'trace'，'desugar' ... – huynhjl

你真的想要一個源代碼或Tree夠嗎？

對於Tree你可以使用的Contextprefix這樣的：

import scala.language.experimental.macros 
import reflect.macros.Context 

implicit class WithSourceHelper[T](source: T) { 
    def withSource[R](f: (String, T) => R): R = macro withSourceImpl[T, R] 
} 

def withSourceImpl[T, R](c: Context)(f: c.Expr[(String, T) => R]): c.Expr[R] = { 
    import c.universe.{reify, Apply} 

    val source = c.prefix.tree match { 
    case Apply(_, List(s)) => s 
    case _ => c.abort(c.enclosingPosition, "can't find source") 
    } 

    reify{ f.splice.apply(c.literal(source.toString).splice, c.Expr[T](source).splice) } 
}

用法：

scala> val (x, y) = (1, 2) 
x: Int = 1 
y: Int = 2 

scala> {x + y}.withSource{ (s, r) => s"$s = $r" } 
res15: String = x.+(y) = 3 

scala> val list = List(1, 2, 3) 
list: List[Int] = List(1, 2, 3) 

scala> val (text, sum) = (list.sum).withSource{(source, sum) => (source, sum)} 
text: String = list.sum[Int](math.this.Numeric.IntIsIntegral) 
sum: Int = 6 

scala> (list.sum).withSource{(source, sum) => println(s"$source: $sum")} 
$line38.$read.$iw.$iw.$iw.list.sum[Int](math.this.Numeric.IntIsIntegral): 6

來源

2013-04-12 14:01:28 senia

源代碼是最好的，因爲這是我寫的。但是樹的頂層可能已經足夠好了。 – huynhjl

似乎不可能刪除'implicit'關鍵字，而是創建'WithSourceHelper'的隱式子類，該子類有一個引用'withSource'的方法......你知道是否有限制嗎？我希望將宏觀事物保持在最低限度，並能夠提供'withSource'封裝。例如我有這樣的想法：'隱式類LogValue [T]（t：T）擴展WithSourceHelper（t）{def logvalue = withSource {（s，t）=> {println（s）; t}}' – huynhjl

我顯然需要24小時才能給你賞金...... – huynhjl

我是不是能夠直接重用withSource只是打印源和值，並返回值。該withSource宏不能從同一個對象本身使用的（所以我不能只是添加我withSource的略加修改就在該文件），我不能夠調用withSource從WithSourceHelper一個子類，通過繼承限制重用。

如果有人有興趣，這裏是一個補充塞尼亞的答案，只需登錄與源的值，並返回值，因此計算的其餘部分可發生。

def logValueImpl[T](c: Context): c.Expr[T] = { 
    import c.universe._ 
    val source = c.prefix.tree match { 
    case Apply(_, List(s)) => s 
    case _ => c.abort(c.enclosingPosition, "can't find source") 
    } 
    val freshName = newTermName(c.fresh("logValue$")) 
    val valDef = ValDef(Modifiers(), freshName, TypeTree(source.tpe), source) 
    val ident = Ident(freshName) 
    val print = reify{ 
    println(c.literal(show(source)).splice + ": " + c.Expr[T](ident).splice) } 
    c.Expr[T](Block(List(valDef, print.tree), ident)) 
}

然後，我將其定義爲def p = macro Debug.logValueImpl[T]上的隱式轉換。然後我可以使用這樣的：

List(1, 2, 3).reverse.p.head 
// prints: immutable.this.List.apply[Int](1, 2, 3).reverse: List(3, 2, 1)

有趣的是，我可以申請兩次：

List(1, 2, 3).reverse.p.p

，它會告訴我logValueImpl宏做了什麼：

{ 
    val logValue$7: List[Int] = immutable.this.List.apply[Int](1, 2, 3).reverse; 
    Predef.println("immutable.this.List.apply[Int](1, 2, 3).reverse: ".+(logValue$7)); 
    logValue$7 
}

這似乎與其它宏以及工作：

f"float ${1.3f}%3.2f; str ${"foo".reverse}%s%n".p` 
//prints: 
{ 
    val arg$1: Float = 1.3; 
    val arg$2: Any = scala.this.Predef.augmentString("foo").reverse; 
    scala.this.Predef.augmentString("float %3.2f; str %s%%n").format(arg$1, arg$2) 
}: float 1.30; str oof%n

更有趣的是，如果我用showRaw代替show我甚至可以看到擴展的宏，這可能會派上用場弄清楚如何寫其他宏樹。

來源

2013-04-16 07:58:04 huynhjl

宏訪問在運行時

回答

相關問題