स्काला में कैट्स लाइब्रेरी का उपयोग करने के लिए 9 सुझाव

स्काला में कार्यात्मक प्रोग्रामिंग भाषा की कुछ वाक्यात्मक और अर्थ संबंधी विशेषताओं के कारण मास्टर करना मुश्किल हो सकता है। विशेष रूप से, मुख्य पुस्तकालयों की मदद से आपने जो योजना बनाई है, उसे लागू करने के कुछ भाषा उपकरण और तरीके स्पष्ट प्रतीत होते हैं जब आप उनसे परिचित होते हैं - लेकिन अध्ययन की शुरुआत में, विशेष रूप से अपने दम पर, उन्हें पहचानना इतना आसान नहीं है।

इस कारण से, मैंने तय किया कि स्काला में कुछ कार्यात्मक प्रोग्रामिंग युक्तियों को साझा करना उपयोगी होगा। उदाहरण और नाम बिल्लियों के अनुरूप हैं, लेकिन स्केलाज़ में वाक्यविन्यास सामान्य सैद्धांतिक आधार के कारण समान होना चाहिए।

9) विस्तार विधि निर्माता

आइए, किसी भी प्रकार के सबसे मूल उपकरण - विस्तार विधियों के साथ शुरू करें, जो विशेष रूप से विकल्प, या तो, आदि में एक उदाहरण को बदल देते हैं:

• Option लिए .some और संबंधित none निर्माता विधि none ;
• .asRight , .asLeft लिए Either ;
• Validated लिए .valid , .invalid , .validNel , .invalidNel

उनके उपयोग के दो मुख्य लाभ:

1. यह अधिक कॉम्पैक्ट और समझने योग्य है (चूंकि विधि कॉल का अनुक्रम सहेजा गया है)।
2. कंस्ट्रक्टर विकल्पों के विपरीत, इन तरीकों के रिटर्न प्रकार एक सुपरटाइप तक बढ़ाए जाते हैं, अर्थात:

 import cats.implicits._ Some("a") //Some[String] "a".some //Option[String] 

हालाँकि पिछले वर्षों में टाइप इंफ़ेक्शन में सुधार हुआ है, और संभावित स्थितियों की संख्या जिसमें यह व्यवहार प्रोग्रामर को शांत रहने में मदद करता है, कम हो गए हैं, अत्यधिक विशिष्ट टाइपिंग के कारण संकलन त्रुटियां आज भी स्काला में संभव हैं। अक्सर, एक मेज के खिलाफ अपने सिर को पीटने की इच्छा तब उत्पन्न होती है जब Either साथ काम करते हैं ( बिल्लियों अध्याय 4.4 के साथ स्काला देखें)।

विषय पर एक और बात: .asRight और .asLeft अभी भी एक और प्रकार का पैरामीटर है। उदाहरण के लिए, "1".asRight[Int] Either[Int, String] । यदि यह पैरामीटर प्रदान नहीं किया गया है, तो संकलक इसे आउटपुट करने की कोशिश करेगा और Nothing मिलेगा। फिर भी, यह हर बार दोनों मापदंडों को प्रदान करने या निर्माणकर्ताओं के मामले में प्रदान नहीं करने की तुलना में अधिक सुविधाजनक है।

8) फिफ्टी शेड्स *>

किसी भी Apply विधि में (*, Monad , Monad , आदि में परिभाषित) ऑपरेटर का अर्थ है कि "प्रारंभिक गणना की प्रक्रिया करें और दूसरे तर्क में निर्दिष्ट परिणाम के साथ परिणाम बदलें"। कोड की भाषा में ( Monad के मामले में):

 fa.flatMap(_ => fb) 

एक ऑपरेशन के लिए अस्पष्ट प्रतीकात्मक ऑपरेटर का उपयोग क्यों करें जिसमें ध्यान देने योग्य प्रभाव नहीं है? ApplicationativeError और / या MonadError का उपयोग करना शुरू करते हुए, आप पाएंगे कि ऑपरेशन पूरे वर्कफ़्लो के लिए त्रुटि प्रभाव को बरकरार रखता है। उदाहरण के रूप में Either लें:

 import cats.implicits._ val success1 = "a".asRight[Int] val success2 = "b".asRight[Int] val failure = 400.asLeft[String] success1 *> success2 //Right(b) success2 *> success1 //Right(a) success1 *> failure //Left(400) failure *> success1 //Left(400) 

जैसा कि आप देख सकते हैं, यहां तक ​​कि एक त्रुटि की स्थिति में भी, गणना अल्पकालिक बनी हुई है। * मैं आपको Monix , IO और इस तरह के Monix में आस्थगित गणनाओं के साथ काम करने में मदद करेगा।

एक सममित ऑपरेशन है, <*। तो, पिछले उदाहरण के मामले में:

 success1 <* success2 //Right(a) 

अंत में, यदि प्रतीकों का उपयोग आपके लिए विदेशी है, तो इसका सहारा लेना आवश्यक नहीं है। *> productR लिए सिर्फ एक उपनाम है, और * productL लिए एक उपनाम है।

टिप्पणी

एक व्यक्तिगत बातचीत में, एडम वारस्की (धन्यवाद, एडम!) ने ठीक ही टिप्पणी की कि इसके अलावा *> ( productR ) के अलावा productR से भी है। >> fa.flatMap(_ => fb) के समान ही परिभाषित किया गया है, लेकिन दो बारीकियों के साथ:

• इसे productR स्वतंत्र रूप से परिभाषित किया गया है, और इसलिए, यदि किसी कारण से इस पद्धति का अनुबंध बदल जाता है (सैद्धांतिक रूप से, इसे बिना मठ के कानूनों का उल्लंघन किए बिना बदला जा सकता है, लेकिन मुझे MonadError बारे में निश्चित नहीं है), तो आपको नुकसान नहीं होगा;
• अधिक महत्वपूर्ण बात, >> कॉल-बाय-नाम से एक दूसरा ऑपरेंड है, अर्थात्। fb: => F[B] । यदि आप गणना करते हैं जो स्टैक विस्फोट हो सकता है, तो शब्दार्थ में अंतर मौलिक हो जाता है।

इसके आधार पर, मैंने * * अधिक बार उपयोग करना शुरू कर दिया। एक तरीका या दूसरा, ऊपर सूचीबद्ध कारकों के बारे में मत भूलना।

7) पाल उठाइये!

कई लोग lift अवधारणा को अपने सिर में रखने के लिए समय लेते हैं। लेकिन जब आप सफल होंगे, तो आप पाएंगे कि वह हर जगह है।

कार्यात्मक प्रोग्रामिंग की हवा में बढ़ते हुए कई शब्दों की तरह, lift श्रेणी के सिद्धांत से आई थी। मैं समझाने की कोशिश करूंगा: एक ऑपरेशन करें, इसके प्रकार के हस्ताक्षर को बदल दें ताकि यह सीधे सार प्रकार से संबंधित हो जाए।

बिल्लियों में, सबसे सरल उदाहरण फनकार है :

 def lift[A, B](f: A => B): F[A] => F[B] = map(_)(f) 

इसका मतलब है: इस फ़ंक्शन को बदल दें ताकि यह दिए गए प्रकार के फ़ंक्टर एफ पर कार्य करे।

लिफ्ट फ़ंक्शन अक्सर दिए गए प्रकार के लिए नेस्टेड कंस्ट्रक्टरों का पर्याय बन जाता है। तो, EitherT.liftF अनिवार्य रूप से EitherT.right. स्केलडॉक से उदाहरण :

 import cats.data.EitherT import cats.implicits._ EitherT.liftF("a".some) //EitherT(Some(Right(a))) EitherT.liftF(none[String]) //EitherT(None) 

केक पर चेरी: स्काला मानक पुस्तकालय में हर जगह lift मौजूद है। सबसे लोकप्रिय (और शायद रोजमर्रा के काम में सबसे उपयोगी) उदाहरण PartialFunction :

 val intMatcher: PartialFunction[Int, String] = { case 1 => "jak się masz!" } val liftedIntMatcher: Int => Option[String] = intMatcher.lift liftedIntMatcher(1) //Some(jak się masz!) liftedIntMatcher(0) //None intMatcher(1) //jak się masz! intMatcher(0) //Exception in thread "main" scala.MatchError: 0 

अब हम अधिक दबाव वाले मुद्दों पर आगे बढ़ सकते हैं।

6) मैपएन

mapN tuples के साथ काम करने के लिए एक उपयोगी सहायक कार्य है। फिर, यह एक नवीनता नहीं है, लेकिन अच्छे पुराने ऑपरेटर के लिए एक प्रतिस्थापन है |@| वह एक चीख है।

यहाँ दो तत्वों के टपल के साथ मैपएन कैसा दिखता है:

 // where t2: Tuple2[F[A0], F[A1]] def mapN[Z](f: (A0, A1) => Z)(implicit functor: Functor[F], semigroupal: Semigroupal[F]): F[Z] = Semigroupal.map2(t2._1, t2._2)(f) 

संक्षेप में, यह हमें किसी भी एफ से एक टुपल के अंदर मानों को मैप करने की अनुमति देता है जो एक अर्धवृत्ताकार (उत्पाद) और एक फ़नकार (मानचित्र) हैं। तो:

 import cats.implicits._ ("a".some, "b".some).mapN(_ ++ _) //Some(ab) (List(1, 2), List(3, 4), List(0, 2).mapN(_ * _ * _)) //List(0, 6, 0, 8, 0, 12, 0, 16) 

वैसे, यह मत भूलो कि बिल्लियों के साथ आपको leftmap लिए मैप और leftmap मिलेगा:

 ("a".some, List("b","c").mapN(_ ++ _)) //won't compile, because outer type is not the same ("a".some, List("b", "c")).leftMap(_.toList).mapN(_ ++ _) //List(ab, ac) 

एक अन्य उपयोगी .mapN फंक्शन तत्काल केस क्लासेस है:

 case class Mead(name: String, honeyRatio: Double, agingYears: Double) ("półtorak".some, 0.5.some, 3d.some).mapN(Mead) //Some(Mead(półtorak,0.5,3.0)) 

बेशक, आप इसके लिए लूप ऑपरेटर के लिए उपयोग करते हैं, लेकिन मैपएन सरल मामलों में मोनोएड ट्रांसफार्मर से बचता है।

 import cats.effect.IO import cats.implicits._ //interchangable with eg Monix's Task type Query[T] = IO[Option[T]] def defineMead(qName: Query[String], qHoneyRatio: Query[Double], qAgingYears: Query[Double]): Query[Mead] = (for { name <- OptionT(qName) honeyRatio <- OptionT(qHoneyRatio) agingYears <- OptionT(qAgingYears) } yield Mead(name, honeyRatio, agingYears)).value def defineMead2(qName: Query[String], qHoneyRatio: Query[Double], qAgingYears: Query[Double]): Query[Mead] = for { name <- qName honeyRatio <- qHoneyRatio agingYears <- qAgingYears } yield (name, honeyRatio, agingYears).mapN(Mead) 

तरीकों के समान परिणाम होते हैं, लेकिन बाद वाले विवादास्पद ट्रांसफार्मर के साथ।

5) नेस्टेड

Nested अनिवार्य रूप से मोनाड ट्रांसफॉर्मर का एक सामान्यीकृत डबल है। जैसा कि नाम से पता चलता है, यह आपको कुछ शर्तों के तहत अनुलग्नक संचालन करने की अनुमति देता है। यहाँ .map(_.map( : लिए एक उदाहरण है .map(_.map( :

 import cats.implicits._ import cats.data.Nested val someValue: Option[Either[Int, String]] = "a".asRight.some Nested(someValue).map(_ * 3).value //Some(Right(aaa)) 

Functor अलावा, Nested Functor , Functor ApplicativeError और Traverse सामान्यीकरण करता है। अतिरिक्त जानकारी और उदाहरण यहाँ हैं ।

4) .recover / .recoverWith / .handleError / .handleErrorWith / .valueOr

स्काला में कार्यात्मक प्रोग्रामिंग में त्रुटि प्रभाव से निपटने के लिए बहुत कुछ है। MonadError और MonadError कुछ उपयोगी तरीके हैं, और चार मुख्य लोगों के बीच सूक्ष्म अंतर का पता लगाने के लिए यह आपके लिए उपयोगी हो सकता है। तो, ApplicativeError F[A]:

• handleError निर्दिष्ट फ़ंक्शन के अनुसार कॉल बिंदु पर सभी त्रुटियों को ए में परिवर्तित करता है।
• recover इसी तरह से कार्य करता है, लेकिन आंशिक कार्यों को स्वीकार करता है, और इसलिए आपके द्वारा चुनी गई त्रुटियों को ए में बदल सकता है।
• handleErrorWith के समान है, लेकिन इसका परिणाम F[A] तरह दिखना चाहिए, जिसका अर्थ है कि यह आपको त्रुटियों को बदलने में मदद करता है।
• recoverWith ठीक होने जैसा काम करता है, लेकिन इसके परिणामस्वरूप F[A] भी आवश्यकता होती है।

जैसा कि आप देख सकते हैं, आप handleErrorWith को handleErrorWith लिए सीमित कर सकते हैं। और recoverWith , जो सभी संभावित कार्यों को कवर करता है। हालांकि, प्रत्येक विधि के अपने फायदे हैं और अपने तरीके से सुविधाजनक हैं।

सामान्य तौर पर, मैं आपको अपने आप को एप्लिकेरिव एपीआई के साथ परिचित करने की सलाह देता हूं, जो कि कैट्स में सबसे अमीर है और मोनाडेयोर में विरासत में मिला है - जिसका अर्थ है कि यह बिल्लियों में समर्थित है।

Either/EitherT , Validated और Ior - .valueOr लिए एक और तरीका है। अनिवार्य रूप से, यह Option लिए .getOrElse तरह काम करता है, लेकिन कुछ "बाईं ओर" वाली कक्षाओं के लिए सामान्य है।

 import cats.implicits._ val failure = 400.asLeft[String] failure.valueOr(code => s"Got error code $code") //"Got error code 400" 

३) गली-सियार

गली-मुहल्ले दो मामलों के लिए एक सुविधाजनक समाधान है:

• टाइल वर्गों के उदाहरण जो अपने कानूनों का पालन नहीं करते हैं 100%;
• असामान्य सहायक टाइपक्लासी, जिसका ठीक से उपयोग किया जा सके।

ऐतिहासिक रूप से, Try लिए मोनाड उदाहरण इस परियोजना में सबसे लोकप्रिय है, क्योंकि Try , जैसा कि आप जानते हैं, घातक त्रुटियों के संदर्भ में सभी विवादास्पद कानूनों को संतुष्ट नहीं करता है। अब वह वास्तव में बिल्लियों के लिए पेश किया गया है।

इसके बावजूद, मेरा सुझाव है कि आप इस मॉड्यूल से खुद को परिचित करें, यह आपके लिए उपयोगी हो सकता है।

2) जिम्मेदारी से आयात का इलाज करें

आपको पता होना चाहिए - प्रलेखन, पुस्तक, या कहीं और से - कि बिल्लियाँ एक विशिष्ट आयात पदानुक्रम का उपयोग करती हैं:

मूल (कर्नेल) प्रकारों के लिए cats.x ;
मान्य, मोनाड ट्रांसफार्मर, आदि जैसे डेटा प्रकारों के लिए cats.data ;
cat.syntax.x._ विस्तार विधियों का समर्थन करने के लिए ताकि आप sth.asRight, sth.pure, आदि को कॉल कर सकें।
cats.instances.x. _ विभिन्न टाइपक्लासेस के कार्यान्वयन को सीधे व्यक्तिगत ठोस प्रकारों के लिए निहित दायरे में आयात करने के लिए ताकि कॉल करते समय, उदाहरण के लिए, sth.pure, त्रुटि "निहित नहीं मिली" नहीं होती है।

बेशक, आपने cats.implicits._ . cats.implicits._ के आयात पर ध्यान दिया है, जो निहित वर्ग में सभी वर्ग के सभी सिंटैक्स और सभी उदाहरणों को आयात करता है।

सिद्धांत रूप में, बिल्लियों के साथ विकसित होने पर, आपको अक्सर पूछे जाने वाले प्रश्न से आयात के एक निश्चित क्रम से शुरू करना चाहिए, अर्थात्:

 import cats._ import cats.data._ import cats.implicits._ 

यदि आप लाइब्रेरी को बेहतर जानते हैं, तो आप इसे अपने स्वाद के साथ जोड़ सकते हैं। एक सरल नियम का पालन करें:

• cats.syntax.x एक्स से संबंधित सिंटैक्स प्रदान करता है;
• cats.instances.x उदाहरण कक्षाएं प्रदान करता है।

उदाहरण के लिए, यदि आपको आवश्यकता है .asRight , जो कि Either लिए एक विस्तार विधि है, निम्न कार्य करें:

 import cats.syntax.either._ "a".asRight[Int] //Right[Int, String](a) 

दूसरी ओर, Option.pure प्राप्त करने के लिए आपको Option.pure को आयात करना होगा। cats.syntax.monad और cats.instances.option :

 import cats.syntax.applicative._ import cats.instances.option._ "a".pure[Option] //Some(a) 

अपने आयात को मैन्युअल रूप से अनुकूलित करके, आप अपनी स्कैला फ़ाइलों में निहित स्कोप को सीमित कर देंगे और इस तरह संकलन समय को कम कर सकते हैं।

हालाँकि, कृपया: निम्न स्थितियों के पूरा न होने पर ऐसा न करें:

• आपने पहले ही बिल्लियों को अच्छी तरह से महारत हासिल कर ली है
• आपकी टीम उसी स्तर की लाइब्रेरी का मालिक है

क्यों? क्योंकि:

 //  ,   `pure`, //    import cats.implicits._ import cats.instances.option._ "a".pure[Option] //could not find implicit value for parameter F: cats.Applicative[Option] 

इसका कारण यह है कि दोनों cats.implicits और cats.instances.option एक्सटेंशन हैं। वास्तव में, हम संकलक को भ्रमित करने की तुलना में दो बार इसके निहित दायरे का आयात करते हैं।

इसके अलावा, प्रत्यारोपण के पदानुक्रम में कोई जादू नहीं है - यह प्रकार के एक्सटेंशन का एक स्पष्ट अनुक्रम है। आपको बस cats.implicits की परिभाषा का उल्लेख करने की आवश्यकता है। cats.implicits और प्रकार पदानुक्रम की जांच करें।

कुछ 10-20 मिनट के लिए आप इन जैसी समस्याओं से बचने के लिए पर्याप्त अध्ययन कर सकते हैं - मेरा विश्वास करो, यह निवेश निश्चित रूप से भुगतान करेगा।

1) बिल्लियों अपडेट के बारे में मत भूलना!

आप सोच सकते हैं कि आपकी एफपी लाइब्रेरी कालातीत है, लेकिन वास्तव में cats और scalaz सक्रिय रूप से अपडेट हो scalaz । उदाहरण के तौर पर बिल्लियों को लें। यहाँ केवल नवीनतम परिवर्तन हैं:

• अब आपको एक विस्तृत अपवाद को बढ़ाने की आवश्यकता नहीं है जब upError का उपयोग करें ;
• अब अवधि और परिमिति के उदाहरण हैं, जिसका अर्थ है कि आप बाहरी पुस्तकालयों का उपयोग किए बिना d1> d2 का उपयोग कर सकते हैं;
• साथ ही अन्य छोटे और बड़े नवाचारों का एक समूह है।

इसलिए, जब परियोजनाओं के साथ काम करते हैं, तो लाइब्रेरी संस्करण की जांच करना न भूलें, नए संस्करणों के लिए नोट्स पढ़ें और समय में अपडेट करें।