¿Es posible pasar "esto" como parámetro implícito en Scala?

Question

Supongamos que deseo ajustar el código que puede generar excepciones con un bloque try-catch que registra la excepción y continúa. Algo así como:

loggingExceptions { 
    // something dangerous 
} 

Idealmente, me gustaría utilizar para registrar el registrador definido en el objeto que llama, en su caso (y en su defecto, obtener un error en tiempo de compilación). Me gustaría definir algo como esto:

def loggingExceptions[L <: { def logger: Logger }](work: => Unit)(implicit objectWithLogger: L): Unit = { 
    try { 
    work 
    } catch { 
    case t: Exception => objectWithLogger.logger.error(t.getMessage) 
    } 
} 

donde objectWithLogger de alguna manera "mágica" para ampliar "este" código en el cliente. ¿Es esto (o algo similar) posible?

Answer 1

De hecho, puede hacerse del mismo modo que desee. Los otros respondedores se rindieron demasiado rápido. ¡No hay banderas blancas!

package object foo { 
    type HasLogger = { def logger: Logger } 
    implicit def mkLog(x: HasLogger) = new { 
    def loggingExceptions(body: => Unit): Unit = 
     try body 
     catch { case ex: Exception => println(ex) } 
    } 
} 

package foo { 
    case class Logger(name: String) { } 

    // Doesn't compile: 
    // class A { 
    // def f = this.loggingExceptions(println("hi")) 
    // } 
    // 1124.scala:14: error: value loggingExceptions is not a member of foo.A 
    //   def f = this.loggingExceptions(println("hi")) 
    //     ^
    // one error found 

    // Does compile 
    class B { 
    def logger = Logger("B") 
    def f = this.loggingExceptions(println("hi")) 
    def g = this.loggingExceptions(throw new Exception) 
    } 
} 

object Test { 
    def main(args: Array[String]): Unit = { 
    val b = new foo.B 
    b.f 
    b.g 
    } 
} 

// output 
// 
// % scala Test 
// hi 
// java.lang.Exception 

Answer 2

Puede agregar un rasgo a todas las clases que quieran usar def loggingExceptions y en este rasgo agregar un tipo propio que espera que def logger: Logger esté disponible.

trait LoggingExceptions { 
    this: { def logger: Logger } => 
    def loggingExceptions(work: => Unit) { 
    try { work } 
    catch { case t: Exception => logger.error(t.getMessage) } 
    } 
} 

object MyObjectWithLogging extends OtherClass with LoggingExceptions { 
    def logger: Logger = // ... 

    def main { 
    // ... 
    loggingExceptions { // ... 
    } 
    } 
} 

Answer 3

Debilski's answer va a funcionar, pero no estoy seguro de que veo una buena razón para utilizar un tipo estructural (es decir, { def logger: Logger }) aquí. De lo contrario, se incurrirá en una sobrecarga de tiempo de ejecución adicional cuando se invoca logger, ya que la implementación de tipos estructurales depende de la reflexión. El método loggingExceptions está estrechamente ligada a la tala, por lo que acaba de hacer que sea parte de un rasgo de registro:

trait Logging { 
    def logger: Logger 

    final def loggingExceptions(body: => Unit) = 
     try body catch { case e: Exception => logger.error(e.getMessage) } 
} 

trait ConcreteLogging extends Logging { 
    val logger = // ... 
} 

object MyObject extends SomeClass with ConcreteLogging { 
    def main { 
     // ... 
     loggingExceptions { 
     // ... 
     } 
    } 
}