आलसी मूल्यांकन अनुक्रमित अनुक्रम प्रकार

Question

मुझे बाहरी संसाधन से लोड की गई वस्तुओं का अनुक्रम बनाने की आवश्यकता है। यह लोडिंग एक महंगा ऑपरेशन होने के कारण वस्तुओं की आवश्यकता होने तक देरी होनी चाहिए। संग्रह के निर्माण के बाद, मुझे निहित वस्तुओं के लिए अनुक्रमित पहुंच की आवश्यकता है। क्या स्कैला मानक पुस्तकालय इस उपयोग के मामले के लिए उपयुक्त संग्रह प्रदान करता है? यदि नहीं, तो इसे लागू करने का सबसे अच्छा तरीका क्या होगा?

संपादित करें:
अनुक्रमित देखने अधिमानतः एक हे (1) आपरेशन होना चाहिए।

Answer 1

अजीब, माइल्स हाल ही में tweeted about this। एक जवाब तब Needको स्केलज़ में Name.scala के पर इंगित करता है और दूसरा अंक चश्मा 'LazyParameter पर इंगित करता है।

की आवश्यकता के साथ थोड़ा परीक्षण:

import scalaz._ 
import Scalaz._ 
val longOp = { var x = 0;() => {println("longOp"); x += 1; x }} 
val seq = Seq(Need(longOp()), Need(longOp())) 
val sum = seq.map(_.value).sum 
val sum = seq.map(_.value).sum 

val v = Need(longOp()) 
val s = v.map("got " + _) 
println(s.value) 
println(s.value) 

प्रिंट:

longOp:() => Int = <function0> 
seq: Seq[scalaz.Name[Int]] = List(
    scalaz.Name$$anon$2@1066d88, scalaz.Name$$anon$2@1011f1f) 
longOp 
longOp 
sum: Int = 3 
sum: Int = 3 
v: scalaz.Name[Int] = scalaz.Name$$anon$2@133ef6a 
s: scalaz.Name[java.lang.String] = scalaz.Name$$anon$2@11696ec 
longOp 
got 3 
got 3 

तो longOp केवल मूल्य के पहले पहुँच पर एक बार कहा जाता है।

Answer 2

ऐसा लगता है कि आप Stream चाहते हैं।

Answer 3

मेरे ज्ञान के लिए, मानक पुस्तकालय में फिट कुछ भी नहीं है। एक समाधान अपने वस्तुओं के लिए लेज़ी आवरण का एक प्रकार का उपयोग करने के हो सकता है:

class Lazy[A](operation: => A) { 
    lazy val get = operation 
} 

और फिर आप उपयोग करना चाहते हैं संग्रह के किसी भी प्रकार के साथ अपने Collection[Lazy[A] निर्माण कर सकते हैं।