3

我希望能够在这些行上做一些事情（不会编译）：

def logScope(logger:Logger)(operation: (implicit l:Logger) => Unit) {/* code */ operation(logger) /* code */} 
def operationOne(implicit logger:Logger) {/**/}
def operationTwo(implicit logger:Logger) {/**/}

然后像这样使用它：

logScope(new ConsoleLogger){logger =>
    operationOne
    operationTwo
    }

但我最接近的工作解决方案是：

def logScope(logger:Logger)(operation: Logger => Unit) {/* code */ operation(logger) /* code */} 
def operationOne(implicit logger:Logger) {/**/}
def operationTwo(implicit logger:Logger) {/**/}

/* other code */

logScope(new ConsoleLogger){logger =>
    implicit val l = logger
    operationOne
    operationTwo
    }

我认为该语言目前不允许这样的结构，但是，有什么建议或解决方法可以达到类似的结果吗？

次要更新：我用上述代码的略微扩展版本创建了一个要点，并尝试了几次模拟这种文字。到目前为止，CheatEx 的版本是最好的。

4

2 回答 2

7

在你的第二个例子中试试这个：

logScope(Logger()) { implicit logger =>
  operationOne
}

它应该可以正常工作。这里的逻辑是“隐式”是闭包内特定值的属性，而不是闭包接口的一部分。

于 2011-08-15T20:36:04.347 回答
2

另一种解决方案是依赖动态范围模式而不是隐式参数。实际上，您甚至可以将两者结合起来，如下所示：

import scala.util.DynamicVariable
object Logger {
  val defaultLogger = new ConsoleLogger( "DEFAULT: %s" )
  val currentLoggerVar = new DynamicVariable[Logger]( defaultLogger )
  implicit object DynamicScopeLogger extends Logger {
    def log( msg: Any* ) {
      currentLoggerVar.value.log( msg: _* )
    }
  }
}
trait Logger {
  def log( msg: Any* )
}
class ConsoleLogger( val pattern: String ) extends Logger {
  def log( msg: Any* ) { println( pattern.format( msg: _* ) ) }
}

def logScope[T](logger: Logger)( operation: => T ): T = {
  Logger.currentLoggerVar.withValue( logger )( operation )
}
def operationOne(implicit logger: Logger) { logger.log( "Inside operationOne" ) }
def operationTwo(implicit logger: Logger) { logger.log( "Inside operationTwo" ) }
def operationThree(implicit logger: Logger) { logger.log( "Inside operationThree" ) }
def operationFour(implicit logger: Logger) { logger.log( "Inside operationFour" ) }

一个使用示例：

operationOne
logScope(new ConsoleLogger("Customized Logger 1: %s")){
  operationTwo
  logScope(new ConsoleLogger("Customized Logger 2: %s")){
    operationThree
  }
  operationFour
}

结果是：

DEFAULT: Inside operationOne
Customized Logger 1: Inside operationTwo
Customized Logger 2: Inside operationThree
Customized Logger 1: Inside operationFour

当前记录器被隐式传递“越界”（我们只使用一个全局（和线程本地）变量来存储当前记录器）。我们可以Logger在方法签名中永远不提及任何地方，直接调用currentLoggerVar.value. currentLoggerVar.value取消对默认隐式 Logger 值（代理）内部的访问DynamicScopeLogger允许我们保持日志记录方法不变。这也意味着我们可以默认使用动态范围，并在需要时通过简单地定义一个本地 Logger 隐式来覆盖此行为，然后将优先于DynamicScopeLogger.

主要缺点是：

  • 根据速度要求，可能会太慢：访问线程本地存储是有代价的，包括（但不限于）在线程本地变量的映射中查找。

  • 这取决于词法作用域与执行顺序相匹配的事实（通常是这种情况，但并非总是如此）。一旦不再这样，你就会遇到麻烦。scala.concurrent.Future例如，当在 a （或简单地）上调用 map 或 flatMap 时Future.apply，map/flatMap 的主体可能会在另一个线程中执行，因此主体不一定会使用预期的记录器：

    scala>import scala.concurrent.Future
import scala.concurrent.Future
scala>import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.ExecutionContext.Implicits.global
scala>logScope(new ConsoleLogger("Customized Logger: %s")){
     |  Future{ operationOne }
     |}
DEFAULT: Inside operationOne
res5: scala.concurrent.Future[Unit] = scala.concurrent.impl.Promise$DefaultPromise@1a38913

    在上面的例子中，operationOne被称为 的词法范围logScope，所以我们可能期望得到消息"Customized Logger 1: Inside operationOne"，但是我们看到使用了默认的记录器。这是因为Future.apply' 的主体的执行被延迟并且稍后发生在另一个线程上（在我们将变量重置Logger.currentLoggerVar为其默认值之后）。

于 2012-11-06T14:19:52.927 回答