Scala'da "this" kelimesini implicit parametresi olarak vermek mümkün mü?

Question

İstisnaları kaydeden ve devam ettiren bir try-catch bloğuyla istisnalar atabilecek bir kod yazmak istiyorum. gibi bir şey: İdeal

loggingExceptions { 
    // something dangerous 
} 

, ben eğer herhangi biri (ve hiçbiri bir derleme zamanı hatası alırsanız), çağıran nesne üzerinde tanımlı Logger giriş için kullanmak istiyorum. Böyle bir şey tanımlamak isteriz:

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

objectWithLogger bir şekilde "sihirli" "Bu" istemci kod genişletmek vermesi. Bu (veya benzer bir şey) mümkün mü?

Answer 1

istediğiniz gibi. Diğer cevap verenler çok hızlı bir şekilde teslim oldular. Beyaz bayrak yok!

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

def loggingExceptions kullanmak istediğiniz tüm sınıflara bir özellik ekleyebilir ve bu özelliğin içinde def logger: Logger kullanılabilir olmasını bekleyen bir kendim türü ekleyebilirsiniz.

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 çalışacaktır, ama ben (yani { def logger: Logger }) burada bir yapısal tipini kullanmak için iyi bir neden görmüyorum emin değilim. Yapısal tiplerin uygulanması, yansımaya dayanması nedeniyle, logger çağrıldığında ekstra çalışma zamanı yükü gerektirecektir. loggingExceptions yöntem yakından günlük bağlıdır, bu yüzden sadece bir Günlüğü özelliğin bir parçası yapacak: Aslında yapılabilir

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 { 
     // ... 
     } 
    } 
}