स्कैला

Question

में आवेदक फ़ैक्टरों को कैसे ढेर करें, आपके गणना चरण स्वतंत्र होने पर आवेदक फ़ैक्टर को अक्सर मोनैड के विकल्प के रूप में वर्णित किया जाता है। उनके अक्सर उल्लिखित फायदों में से एक यह है कि जब आप आवेदकों को ढेर करना चाहते हैं तो आपको ट्रांसफार्मर की आवश्यकता नहीं है, क्योंकि F[G[X]] हमेशा एक आवेदक भी होता है। चलो कहते हैं कि मैं निम्नलिखित कार्य करते हैं:

def getDataOption(): Option[Data] 
def getUserFuture(): Future[User] 
def process(data: Data, user: User) 

मैं आदेश में एक Future[Option[User]] और Future[Option[Data]] हो और नक्शा कि process साथ करने के लिए सुरुचिपूर्ण स्टैकिंग करना चाहते हैं।

अब तक मैं केवल यह (बिल्लियों का प्रयोग करके) के साथ आया था:

Applicative[Future] 
    .compose[Option] 
    .map2(
     Applicative[Future].pure(getDataOption()), 
     getUserFuture().map(Applicative[Option].pure))(process) 

लेकिन मुझे यकीन है कि यह आदर्श से दूर हूँ। क्या यह हासिल करने के लिए एक और अधिक सुरुचिपूर्ण और सामान्य तरीका है?

Answer 1

सबसे कठिन बात यहां टाइप अनुमान है। यह सबसे अच्छा है कि मैं

// for the Applicative[Future[Option[?]] 
    import cats.Applicative 

    implicit val fo = { 
    import cats.std.future._ 
    import cats.std.option._ 
    Applicative[Future].compose[Option] 
    } 

    // for the |@| syntax 
    import cats.syntax.cartesian._ 

    // to guide type inference 
    type FutureOption[A] = Future[Option[A]] 

    ((Future(getDataOption): FutureOption[Data]) |@| 
    getUserFuture.map(Option.apply)).map(process _)