स्कालाज़

Question

का उपयोग कर स्कैला में सत्यापन के साथ असिंक गणना, रिमोट सेवा (प्ले 2.0 का उपयोग करके) तक पहुंचने के लिए पूरी तरह से एसिंक लाइब्रेरी लिखने के बाद, मैं Promise और Validation का उपयोग गैर-अवरुद्ध कॉल बनाने के लिए कर रहा हूं, जिसमें एक प्रकार प्रस्तुत करने में असफल रहा है और वैध परिणाम एक बार में।

Promise Play2-scala से आता है, जहां Validation स्केलज़ से आता है।

तो यहाँ

इस तरह के कार्यों

का उदाहरण के प्रकार है

• च :: A => Promise[Validation[E, B]]
• जी :: B => Promise[Validation[E, C]]

अब तक तो अच्छा, अब मैं उन्हें रचना करना चाहते हैं , मैं इस तथ्य का सरल उपयोग कर सकता हूं कि Promise एक flatMap प्रस्तुत करता है, इसलिए मैं इसे समझने के लिए कर सकता हूं

for (
    x <- f(a); 
    y <- g(b) 
) yield y 

ठीक है, मैंने अपनी समस्या का शॉर्टकट यहां लिया क्योंकि मैंने Validation परिणामों को समझने के लिए परिणामों का पुन: उपयोग नहीं किया। तो अगर मैं g में x पुन: उपयोग करना चाहते हैं, तो यहां आपको मैं

for (
    x <- f(a); // x is a Validation 
    y <- x.fold(
     fail => Promise.pure(x), 
     ok => g(ok) 
    ) 
) yield y 

पर्याप्त मेले कर सकता है, लेकिन बॉयलरप्लेट इस तरह बार बार मेरे कोड को प्रदूषित करने के लिए जाना जाएगा। यहां समस्या यह है कि मेरे पास M[N[_]] जैसे दो स्तरों की मोनाडिक संरचना है।

for (
    x <- f(a); //x is a B 
    y <- g(b) 
) yield y 

, अब नीचे कैसे मैं ऐसी ही कुछ हासिल है:

इस स्तर पर, वहाँ च ° प्रोग्रामिंग में किसी भी संरचना है कि इस तरह की संरचना के साथ आसानी से secong स्तर लंघन द्वारा काम करने को सक्षम बनता है।

मुझे लगता है कि एक में दो स्तर लपेटता Monadic संरचना की तरह बनाया है, का कहना है कि ValidationPromised जो दो तरीकों के साथ Promise प्रकार pimped करते हैं:

def /~> [EE >: E, B](f: Validation[E, A] => ValidationPromised[EE, B]): ValidationPromised[EE, B] = 
    promised flatMap { valid => 
     f(valid).promised 
    } 

def /~~>[EE >: E, B](f: A => ValidationPromised[EE, B]): ValidationPromised[EE, B] = 
    promised flatMap { valid => 
     valid.fold (
      bad => Promise.pure(KO(bad)), 
      good => f(good).promised 
     ) 
    } 

यह मैं ऐसी बातों

 endPoint.service /~~>         //get the service 
     (svc =>             //the service 
     svc.start /~~> (st =>         //get the starting elt 
      svc.create(None) /~~>        //svc creates a new elt 
      (newE =>           //the created one 
      newEntry.link(st, newE) /~~>      //link start and the new 
      (lnk => Promise.pure(OK((st, lnk, newE))))  //returns a triple => hackish 
     ) 
     ) 
    ) 

करने की अनुमति देता

जैसा कि हम देख सकते हैं /~~>flatMap के समान है लेकिन एक स्तर छोड़ देता है। समस्या शब्दशः है (यही कारण है कि "समझने के लिए" स्कैला में है और हास्केल में "करो")।

एक और मुद्दा है, मैं /~> कि एक map भी तरह खड़ा है लेकिन दूसरे स्तर पर काम करता है है (मान्य प्रकार के बजाय - तीसरे स्तर)

तो मेरी दूसरा सवाल पूर्व के लिए परिणाम है ... क्या मैं इस निर्माण के साथ एक स्थायी समाधान का सामना कर रहा हूं?

खेद है कि लंबे समय से

Answer 1

अवधारणा तुम यहाँ के लिए देख रहे monad transformers है। संक्षेप में, मोनैड ट्रांसफार्मर आपको monads not composing की क्षतिपूर्ति करके "स्टैक" करने की अनुमति देकर क्षतिपूर्ति करते हैं।

आपने स्कालज़ के संस्करण का उल्लेख नहीं किया है, लेकिन यदि आप scalaz-seven branch में देखते हैं, तो आपको ValidationT मिल जाएगा। इसका उपयोग किसी भी F[Validation[E, A]] को ValidationT[F, E, A] में लपेटने के लिए किया जा सकता है, जहां आपके मामले में F = Promise है। आप f और g बदलते हैं तो ValidationT वापस जाने के लिए है, तो आप के रूप में

for { 
    x ← f(a) 
    y ← g(b) 
} yield y 

अपने कोड छोड़ सकते हैं यह आपको एक परिणाम के रूप में एक ValidationT[Promise, E, B] दे देंगे।