2012-12-12 16 views
10

में अनुक्रमिक रूप से वायदा की संख्या को गठबंधन करें, मैं स्कैला के लिए नया हूं और मैं स्कैला 2.10 आरसी 3 में कई फ़्यूचर्स को गठबंधन करने का प्रयास करता हूं। अनुक्रमिक क्रम में Futures निष्पादित किया जाना चाहिए। दस्तावेज़ Scala SIP14 विधि andThen अनुक्रमिक क्रम में फ़्यूचर्स निष्पादित करने के लिए परिभाषित किया गया है। मैंने कई Futures (नीचे उदाहरण देखें) को गठबंधन करने के लिए इस विधि का उपयोग किया। मेरी उम्मीद थी कि यह 6 प्रिंट करता है लेकिन वास्तव में परिणाम 0 है। मुझसे यहां क्या गलत हो रहा है? मेरे पास दो प्रश्न हैं:स्काला

पहला, परिणाम 0 क्यों है। दूसरा, मैं कई Futures को कैसे जोड़ सकता हूं, ताकि दूसरे Future का निष्पादन पहले Future समाप्त होने से पहले शुरू न हो।

val intList = List(1, 2, 3) 

val sumOfIntFuture = intList.foldLeft(Future { 0 }) { 
case (future, i) => future andThen { 
    case Success(result) => result + i 
    case Failure(e) => println(e) 
} 
} 

sumOfIntFuture onSuccess { case x => println(x) } 

उत्तर

12

andThen साइड इफेक्ट्स के लिए है। यह आपको भविष्य के पूरा होने के बाद कुछ और क्रियाओं को निर्दिष्ट करने की अनुमति देता है और इससे पहले कि यह किसी और चीज के लिए उपयोग किया जाता है।

उपयोग मानचित्र:

scala> List(1, 2, 3).foldLeft(Future { 0 }) { 
    | case (future, i) => future map { _ + i } 
    | } onSuccess { case x => println(x) } 
6 
+0

धन्यवाद! मुझे ठीक इसी की आवश्यकता थी। – Chrisse

+0

+1 इससे मुझे बहुत मदद मिली! – pvorb

2

मैं इस सामान्य दृष्टिकोण की तरह:

trait FutureImplicits { 

    class SeriallyPimp[T, V](futures: Seq[T]) { 
    def serially(f: T => Future[V])(implicit ec: ExecutionContext): Future[Seq[V]] = { 
     val buf = ListBuffer.empty[V] 
     buf.sizeHint(futures.size) 

     futures.foldLeft(Future.successful(buf)) { (previousFuture, next) => 
     for { 
      previousResults <- previousFuture 
      nextResult <- f(next) 
     } yield previousResults += nextResult 
     } 
    } 
    } 

    implicit def toSeriallyPimp[T, V](xs: Seq[T]): SeriallyPimp[T, V] = 
    new SeriallyPimp(xs) 

} 

फिर मिश्रण में ऊपर विशेषता और इस तरह इसका इस्तेमाल:

val elems: Seq[Elem] = ??? 
val save: Elem => Future[Result] = ??? 
val f: Future[Seq[Result]] = elems serially save 

इस कोड को कर सकता है इनपुट संग्रह प्रकार को संरक्षित करने के लिए सुधार किया जाना चाहिए। उदाहरण के लिए this आलेख देखें।