यह जांचने के लिए कि क्या आलसी वैल शुरू किए बिना शुरू किया गया है?

Question

क्या यह निर्धारित करना संभव है कि आलसी वैल शुरू हो जाए, इसे शुरू किए बिना?

object TheApp { 
    lazy val optionalSubsystem = { 
     // ... 
     subsystem 
    } 

    def main(args: Array[String]) { 
     bootSubsystemA(this) 
     bootSubsystemB(this) 

     if (/* optionalSubsystem is initialized */) { 
      // more dependencies 
     } 
    } 
} 

Answer 1

यह वास्तव में आपके प्रश्न का उत्तर नहीं है, और जब लोग ऐसा करते हैं तो मुझे नफरत है, लेकिन मैं वैसे भी ऐसा करने जा रहा हूं। मुझे लगता है कि सबसे अच्छी प्रतिक्रिया यह है कि: आलसी वैल इसके लिए उपयुक्त नहीं है, इसलिए एक प्रकार को परिभाषित करें जो आपको आवश्यकतानुसार समर्थन देता है।

आप optionalSubsystem() बजाय optionalSubsystem के रूप में चर का उल्लेख करना होगा, लेकिन यह, एक अच्छी बात है, क्योंकि डिजाइन आप चाहते हैं के साथ कि संदर्भ प्राप्त करने के एक observably पक्ष प्रभावशाली प्रक्रिया है।

class Lazy[A](f: => A, private var option: Option[A] = None) { 

    def apply(): A = option match { 
    case Some(a) => a 
    case None => val a = f; option = Some(a); a 
    } 

    def toOption: Option[A] = option 

} 

scala> val optionalSubsystem = new Lazy { "a" } 
optionalSubsystem: Lazy[java.lang.String] = Lazy@1210267 

scala> optionalSubsystem.toOption.isDefined 
res1: Boolean = false 

scala> optionalSubsystem() 
res2: java.lang.String = a 

scala> optionalSubsystem.toOption.isDefined 
res12: Boolean = true 

संपादित - यहाँ टॉमस Mikula को कुछ संशोधनों के धन्यवाद के साथ एक और संशोधन है:

import scala.language.implicitConversions 

object Lazy { 

    def lazily[A](f: => A): Lazy[A] = new Lazy(f) 

    implicit def evalLazy[A](l: Lazy[A]): A = l() 

} 

class Lazy[A] private(f: => A) { 

    private var option: Option[A] = None 

    def apply(): A = option match { 
    case Some(a) => a 
    case None => val a = f; option = Some(a); a 
    } 

    def isEvaluated: Boolean = option.isDefined 

} 

इस की मदद से आप lazily { ... } बजाय new Lazy { ... }, और optionalSubsystem बजाय optionalSubsystem() लिखें।

scala> import Lazy._ 
import Lazy._ 

scala> val optionalSubsystem = lazily { "a" } 
optionalSubsystem: Lazy[String] = Lazy@3d0d54 

scala> optionalSubsystem.isEvaluated 
res0: Boolean = false 

scala> optionalSubsystem: String 
res1: String = a 

scala> optionalSubsystem.isEvaluated 
res2: Boolean = true 

Answer 2

आप कुछ इस तरह कर सकते हैं:

object TheApp { 

    private var _optionalSubsystemInitialized = false 

    def optionalSubsystemInitialized = _optionalSubsystemInitialized 

    lazy val optionalSubsystem = { 
     _optionalSubsystemInitialized = true 
     subsystem 
    } 

} 

क्या यह वास्तव में उचित एक lazy val के प्रवर्तन कोड में इस तरह के साइड इफेक्ट के लिए है एक और सवाल है।

Answer 3

लेकिन निश्चित रूप से आप कर सकते हैं। एक क्षेत्र सिर्फ एक क्षेत्र है।

package lazyside 

object Lazy 

class Foo { 
    lazy val foo = 7 
    lazy val bar = { Lazy ; 8 } 
} 

object Test extends App { 
    import scala.reflect.runtime.{ currentMirror => cm } 
    import scala.reflect.runtime.universe._ 

    val x = new Foo 

    // method 1: reflect the underlying field 
    val im = cm reflect x 
    val f = (typeOf[Foo] declaration TermName("foo")).asTerm.accessed.asTerm 
    def foo_? = x synchronized ((im reflectField f).get != 0) 

    def yn(b: Boolean) = if (b) "yes" else "no" 
    Console println s"Is foo set yet? ${yn(foo_?)}" 

    // method 2: check a benign side effect like a class load 
    val m = classOf[ClassLoader].getDeclaredMethod("findLoadedClass", classOf[String]) 
    m setAccessible true 
    def bar_? = (m invoke (x.getClass.getClassLoader, "lazyside.Lazy$")) != null 
    Console println s"Is bar set yet? ${yn(bar_?)}" 

    Console println s"I see that foo is ${x.foo}." 
    Console println s"Is foo set yet? ${yn(foo_?)}" 
    Console println s"I see that bar is ${x.bar}." 
    Console println s"Is bar set yet? ${yn(bar_?)}" 
    Console println s"I see that x is loaded by a ${x.getClass.getClassLoader.getClass}" 
} 

चेतावनी foo_? की कि धागे की सुरक्षा आलसी गणना उदाहरण x की निगरानी के प्राप्त करने पर निर्भर करता है। इसे बदलने की बात है।

इसके अलावा, स्पष्ट रूप से, फ़ील्ड मान का परीक्षण केवल तभी काम करता है जब init मान डिफ़ॉल्ट मान (null.asInstanceOf[T]) नहीं है।

दूसरी विधि आलसी init द्वारा लोड होने वाली कक्षा Lazy$ पर निर्भर करती है। फू के अंदर वस्तु को गिलहरी करना थोड़ा सा सुरक्षित होगा। किसी भी मामले में, वह विशेष दुष्प्रभाव एक शॉट है। यह उपप्रणाली स्टार्ट-अप के उपयोग के मामले को पूरा कर सकता है।

unsurprising उत्पादन के साथ:

Is foo set yet? no 
Is bar set yet? no 
I see that foo is 7. 
Is foo set yet? yes 
I see that bar is 8. 
Is bar set yet? yes 
I see that x is loaded by a class scala.reflect.internal.util.ScalaClassLoader$URLClassLoader 

2,11 में संकलित। 2.10 के लिए, TermName के बजाय newTermName का उपयोग करें।

Answer 4

नहीं सीधे, लेकिन क्यों तुम सिर्फ अपने तर्क के आसपास इस तरह बदलाव नहीं है:

object TheApp { 
    lazy val optionalSubsystem = { 
     // ... 
     subsystem 
     // more dependencies 
    } 

    def main(args: Array[String]) { 
     bootSubsystemA(this) 
     bootSubsystemB(this) 
    } 
} 

इस तरह "अधिक निर्भरता" इष्टतम समय लोड हो (सहित कभी नहीं अगर वे आवश्यक नहीं हैं)