विफलता के बावजूद भविष्य अनुक्रम निष्पादित करने के लिए कैसे?

Question

traverseFuture से विधि पहली विफलता पर बंद हो जाती है। मैं इस विधि का सहिष्णु/क्षमा करने वाला संस्करण चाहता हूं जो त्रुटियों की घटना के अनुक्रम के साथ चलता है।

वर्तमान में हम हमारे utils के लिए निम्न विधि जोड़ लिया है:

def traverseFilteringErrors[A, B <: AnyRef] 
          (seq: Seq[A]) 
          (f: A => Future[B]): Future[Seq[B]] = { 
    val sentinelValue = null.asInstanceOf[B] 
    val allResults = Future.traverse(seq) { x => 
    f(x) recover { case _ => sentinelValue } 
    } 
    val successfulResults = allResults map { result => 
    result.filterNot(_ == sentinelValue) 
    } 
    successfulResults 
} 

वहाँ यह करने के लिए एक बेहतर तरीका है?

Answer 1

वास्तव में उपयोगी चीज (आमतौर पर बोलने) एक भविष्य की त्रुटि को उचित मूल्य में बढ़ावा देने में सक्षम होगी। या दूसरे शब्दों में, Future[T] को Future[Try[T]] में बदलें (सफल वापसी मान Success[T] बन जाता है जबकि विफलता केस Failure[T] बन जाता है)। ,

Future.traverse(seq)(f andThen mapValue) 

आप एक सफल Future[Seq[Try[A]]], जिसका अंतिम मूल्य प्रत्येक सफल भविष्य के लिए एक Success उदाहरण शामिल प्राप्त करेंगे:,

// Can also be done more concisely (but less efficiently) as: 
// f.map(Success(_)).recover{ case t: Throwable => Failure(t) } 
// NOTE: you might also want to move this into an enrichment class 
def mapValue[T](f: Future[T]): Future[Try[T]] = { 
    val prom = Promise[Try[T]]() 
    f onComplete prom.success 
    prom.future 
} 

अब अगर आप निम्न करें: यहाँ हम यह कैसे लागू हो सकता है और प्रत्येक असफल भविष्य के लिए Failure उदाहरण। यदि आवश्यक हो, तो आप Failure उदाहरणों को छोड़ने के लिए collect का उपयोग इस सीक पर कर सकते हैं और केवल सशक्त मान रख सकते हैं।

def traverseFilteringErrors[A, B](seq: Seq[A])(f: A => Future[B]): Future[Seq[B]] = { 
    Future.traverse(seq)(f andThen mapValue) map (_ collect{ case Success(x) => x }) 
}