भविष्य [सूची [त्रुटि \/डबल]] भविष्य में [[सूची [त्रुटि] \/सूची [डबल]] स्कैला

Question

मैं कार्यशील प्रोग्रामिंग सीखने के लिए स्कैला (जेड) के साथ खेल रहा हूं।

मेरे पास Future[List[Error \/ Double]] प्रकार का मान है और इसे Future[[List[Error] \/ List[Double]] के प्रकार से बदलना चाहते हैं।

लक्ष्य lefts और अधिकारों को समूहित करना है।

val foo: Future[List[Error] \/ List[Double]] = { 
    for { 
    results <- resultsF 
    } yield 
    results.foldLeft(\/[List[Error], List[Double]])({ 
     case (acc, v) if v.isRight => v :: \/-(acc) 
     case (acc, v) if v.isLeft => v :: -\/(acc) 
    }) 
} 

हालांकि, मैं जो इस तथ्य के कारण है कि मेरे संचायक (बाहर से) एक सूची \/[List[Error], List[Double]] नहीं है :: पर कोई त्रुटि मिलती है:

मैं वर्तमान में निम्नलिखित है। यह कैसे किया जाना चाहिए?

Answer 1

हास्केल में यह फ़ंक्शन partitionEithers: [Either a b] -> ([a], [b]) होगा।

(आप नहीं है वास्तव में Either [a] [b] चाहते हैं, जो वास्तव में कोई मतलब नहीं होगा। मेरा अनुमान है कि आप के बजाय अपने विवरण में पाठ की वजह से इस समारोह चाहते हैं ...)

Scalaz नहीं है यह जैसा है

/** Generalized version of Haskell's `partitionEithers` */ 
def separate[G[_, _], A, B](value: F[G[A, B]])(implicit G: Bifoldable[G]): (F[A], F[B]) 

मूल रूप से Bifoldable g, MonadPlus f => f (g a b) -> (f a), (f b) है कौन सा: हालांकि, यह एक अधिक सामान्य separate है। विशेष रूप से: [Either a b] -> ([a], [b])। आप इसे अपनी सूची में आसानी से कॉल कर सकते हैं (जहां g = \/ (या या तो), f = List)।

कार्रवाई में:

scala> import scalaz._, Scalaz._ 
scala> List(\/-(3), -\/("a")).separate 
res1: (List[String], List[Int]) = (List(a),List(3)) 

Answer 2

कड़ाई से, आप इस तरह के समारोह लागू कर सकते हैं, उदाहरण के लिए, आप कैसे इस सूची लागू होते हैं:

-\/(A) :: \/-(B) :: Nil 

इनपुट सूची सभी छोड़ दिया है या सब ठीक मान लें, आप पहली बार एक नज़र सकते हैं, और अवशेष निपटने के लिए कैसे तय:

val foo: Future[List[Error] \/ List[Double]] = 
    resultsF.map(resultsF.head match { 
    case -\/(_) => { _.left } 
    case \/-(_) => { _.right } 
    }) 

मान लें समूह lef करने के लिए आप चाहते हैं टीएस और अधिकार, एक एकल गुना जो लौटाता है (सूची [एल], सूची [आर]) पूरी तरह से काम करता है:

val foo[L,R]: Future[(List[L], List[R])] = 
    resultsF.foldr((Nil, Nil)){ (s, v) => 
    case -\/(l) => (l :: s._1, s._2) 
    case \/-(r) => (s._1, r :: s._2) 
    }