क्या स्कैला में अंतर्निहित पैरामीटर के रूप में "यह" पास करना संभव है?

Question

मान लीजिए कि मैं कोड को लपेटना चाहता हूं जो अपवाद को लॉग इन करने वाले प्रयास-चिह्न ब्लॉक के साथ अपवाद फेंक सकता है और जारी रहता है। की तरह कुछ:

loggingExceptions { 
    // something dangerous 
} 

आदर्श रूप में, मैं, लॉगर बुला वस्तु पर परिभाषित प्रवेश करने के लिए उपयोग करना चाहते हैं, यदि कोई हो (और कोई नहीं, एक संकलन समय त्रुटि मिलती है)। मैं कुछ इस तरह परिभाषित करने के लिए खुशी होगी:

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

जहां objectWithLogger किसी भी तरह "जादुई" से "इस" ग्राहक में कोड का विस्तार होगा। क्या यह (या एक समान चीज़) संभव है?

Answer 1

यह वास्तव में किया जा सकता है आप चाहते हैं बस के रूप में। अन्य उत्तरदाताओं ने बहुत जल्दी आत्मसमर्पण कर दिया। कोई सफेद झंडे नहीं!

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 का उपयोग करना चाहते हैं और इस विशेषता में एक स्व-प्रकार जोड़ें जो def logger: Logger उपलब्ध होने की अपेक्षा करता है।

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 काम करेंगे, लेकिन मुझे यकीन है कि मैं यहाँ (अर्थात { def logger: Logger }) एक संरचनात्मक प्रकार का उपयोग करने के लिए एक अच्छा कारण देख नहीं हूँ। जब भी logger लागू होता है, तो ऐसा करने से अतिरिक्त रनटाइम ओवरहेड लग जाएगा, क्योंकि संरचनात्मक प्रकार के कार्यान्वयन प्रतिबिंब पर निर्भर करता है। loggingExceptions विधि बारीकी से प्रवेश से जुड़ा हुआ है, तो मैं बस यह एक लॉगिंग विशेषता का हिस्सा बनाना होगा:

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