एरो के साथ बहुरूपी कार्यक्रम कैसे लिखें

नमस्कार, हेब्र!

मेरा नाम एर्टोम डोब्रोविंस्की है, मैं फिंच के लिए काम करता हूं। मेरा सुझाव है कि कैसे बहुरंगी कार्यक्रमों को लिखने के लिए Arrow फंक्शनल प्रोग्रामिंग लाइब्रेरी के पिताओं में से एक ने एक लेख पढ़ा। अक्सर जो लोग केवल एक कार्यात्मक शैली में लिखना शुरू कर रहे हैं, वे पुरानी आदतों के साथ भाग लेने की जल्दी में नहीं हैं, और वास्तव में डीआई कंटेनर और विरासत के साथ थोड़ा अधिक सुरुचिपूर्ण अनिवार्यता लिखते हैं। प्रकारों की परवाह किए बिना कार्यों का पुन: उपयोग करने का विचार कई लोगों को सही दिशा में सोचने के लिए प्रेरित कर सकता है।

का आनंद लें!

***

क्या होगा यदि हम रनटाइम में उपयोग किए जाने वाले डेटा के प्रकारों के बारे में सोचे बिना आवेदन लिख सकते हैं, लेकिन बस यह वर्णन करें कि इस डेटा को कैसे संसाधित किया जाएगा?

कल्पना कीजिए कि हमारे पास एक एप्लिकेशन है जो RxJava लाइब्रेरी से ऑब्जर्वेबल टाइप के साथ काम करता है। यह प्रकार हमें डेटा के साथ कॉल और मैनिपुलेशन की श्रृंखला लिखने की अनुमति देता है, लेकिन अंत में, क्या यह Observable केवल अतिरिक्त गुणों वाला कंटेनर नहीं होगा?

Flowable , Flowable ( Flowable ), Future , IO और कई अन्य जैसे प्रकारों के साथ एक ही कहानी।

वैचारिक रूप से, ये सभी प्रकार एक ऑपरेशन है (भविष्य में लागू होने की योजना बनाई या बनाई गई है) जो एक दूसरे प्रकार ( map ) के लिए आंतरिक मूल्य को कास्टिंग करने के लिए जोड़तोड़ का समर्थन करता है, इसी प्रकार के अन्य उदाहरणों के साथ संयोजन करते हुए इसी प्रकार के संचालन की एक श्रृंखला बनाने के लिए flatMap का उपयोग flatMap ( zip ), आदि।

इन व्यवहारों के आधार पर कार्यक्रम लिखने के लिए, एक घोषणात्मक विवरण बनाए रखते हुए, और आपके कार्यक्रमों को विशिष्ट डेटा प्रकारों जैसे कि flatMap स्वतंत्र बनाने के लिए Observable पर्याप्त है कि डेटा प्रकार कुछ अनुबंधों के अनुरूप होते हैं, जैसे कि map , flatMap और अन्य। ।

ऐसा दृष्टिकोण अजीब या बहुत जटिल लग सकता है, लेकिन इसके दिलचस्प फायदे हैं। पहले, एक साधारण उदाहरण पर विचार करें, और फिर उनके बारे में बात करें।

विहित समस्या

मान लीजिए हमारे पास एक टू-डू सूची के साथ एक आवेदन है, और हम स्थानीय कैश से टाइप Task की वस्तुओं की एक सूची निकालना चाहेंगे। यदि वे स्थानीय संग्रहण में नहीं पाए जाते हैं, तो हम उन्हें नेटवर्क पर क्वेरी करने का प्रयास करेंगे। हमें दोनों डेटा स्रोतों के लिए एक एकल अनुबंध की आवश्यकता है ताकि दोनों को स्रोत की परवाह किए बिना उपयुक्त User ऑब्जेक्ट के लिए टाइप Task की वस्तुओं की सूची मिल सके:

 interface DataSource { fun allTasksByUser(user: User): Observable<List<Task>> } 

यहाँ, सादगी के लिए, हम Flowable , लेकिन यह Single , Maybe , Flowable , Deferred - लक्ष्य को प्राप्त करने के लिए उपयुक्त हो।

डेटा स्रोतों के मोचा कार्यान्वयन के एक जोड़े को जोड़ें, एक और एक ।

 class LocalDataSource : DataSource { private val localCache: Map<User, List<Task>> = mapOf(User(UserId("user1")) to listOf(Task("LocalTask assigned to user1"))) override fun allTasksByUser(user: User): Observable<List<Task>> = Observable.create { emitter -> val cachedUser = localCache[user] if (cachedUser != null) { emitter.onNext(cachedUser) } else { emitter.onError(UserNotInLocalStorage(user)) } } } class RemoteDataSource : DataSource { private val internetStorage: Map<User, List<Task>> = mapOf(User(UserId("user2")) to listOf(Task("Remote Task assigned to user2"))) override fun allTasksByUser(user: User): Observable<List<Task>> = Observable.create { emitter -> val networkUser = internetStorage[user] if (networkUser != null) { emitter.onNext(networkUser) } else { emitter.onError(UserNotInRemoteStorage(user)) } } } 

दोनों डेटा स्रोतों का कार्यान्वयन लगभग समान है। ये इन स्रोतों के केवल नकली संस्करण हैं जो आदर्श रूप से स्थानीय भंडारण या नेटवर्क एपीआई से डेटा खींचते हैं। दोनों ही मामलों में, Map<User, List<Task>> का उपयोग डेटा को संग्रहीत करने के लिए किया जाता है।

क्योंकि हमारे पास डेटा के दो स्रोत हैं, हमें उन्हें किसी तरह समन्वयित करने की आवश्यकता है। एक रिपॉजिटरी बनाएँ:

 class TaskRepository(private val localDS: DataSource, private val remoteDS: RemoteDataSource) { fun allTasksByUser(user: User): Observable<List<Task>> = localDS.allTasksByUser(user) .subscribeOn(Schedulers.io()) .observeOn(Schedulers.computation()) .onErrorResumeNext { _: Throwable -> remoteDS.allTasksByUser(user) } } 

यह केवल LocalDataSource से List<Task> को लोड करने का प्रयास करता है, और यदि यह नहीं पाया जाता है, तो यह LocalDataSource का उपयोग करके उन्हें नेटवर्क से अनुरोध करने का प्रयास करता है।

चलो निर्भरता इंजेक्शन (DI) के लिए किसी भी ढांचे का उपयोग किए बिना निर्भरता प्रदान करने के लिए एक सरल मॉड्यूल बनाएँ:

 class Module { private val localDataSource: LocalDataSource = LocalDataSource() private val remoteDataSource: RemoteDataSource = RemoteDataSource() val repository: TaskRepository = TaskRepository(localDataSource, remoteDataSource) } 

और अंत में, हमें एक सरल परीक्षण की आवश्यकता होती है जो संचालन के पूरे ढेर को चलाता है:

 object test { @JvmStatic fun main(args: Array<String>): Unit { val user1 = User(UserId("user1")) val user2 = User(UserId("user2")) val user3 = User(UserId("unknown user")) val dependenciesModule = Module() dependenciesModule.run { repository.allTasksByUser(user1).subscribe({ println(it) }, { println(it) }) repository.allTasksByUser(user2).subscribe({ println(it) }, { println(it) }) repository.allTasksByUser(user3).subscribe({ println(it) }, { println(it) }) } } } 

उपरोक्त सभी कोड जीथब पर पाए जा सकते हैं ।

यह कार्यक्रम तीन उपयोगकर्ताओं के लिए निष्पादन श्रृंखला की रचना करता है, फिर परिणामी Observable लिए सदस्यता लेता है।

User पहले दो ऑब्जेक्ट उपलब्ध हैं, इसके साथ हम भाग्यशाली थे। User1 स्थानीय DataSource में उपलब्ध है, और User2 रिमोट में उपलब्ध है।

लेकिन उपयोगकर्ता 3 के साथ एक समस्या है, क्योंकि यह स्थानीय भंडारण में उपलब्ध नहीं है। कार्यक्रम इसे दूरस्थ सेवा से डाउनलोड करने का प्रयास करेगा - लेकिन यह वहां भी नहीं है। खोज विफल हो जाएगी, और हम कंसोल में एक त्रुटि संदेश प्रदर्शित करेंगे।

यहाँ तीनों मामलों के लिए कंसोल में प्रदर्शित किया जाएगा:

 > [Task(value=LocalTask assigned to user1)] > [Task(value=Remote Task assigned to user2)] > UserNotInRemoteStorage(user=User(userId=UserId(value=unknown user))) 

हम एक उदाहरण के साथ किया जाता है। अब इस तर्क को की शैली में प्रोग्राम करने का प्रयास करते हैं।

डेटा प्रकार अमूर्त

अब DataSource इंटरफ़ेस का अनुबंध इस तरह दिखाई देगा:

 interface DataSource<F> { fun allTasksByUser(user: User): Kind<F, List<Task>> } 

सब कुछ समान लगता है, लेकिन दो महत्वपूर्ण अंतर हैं:

• सामान्यीकृत प्रकार (जेनेरिक) F पर निर्भरता है F
• फ़ंक्शन द्वारा लौटाया गया प्रकार अब Kind<F, List<Task>> ।

Kind एरो को किस Kind से एनकोड करता है जिसे आमतौर पर एक (higher kind) कहा जाता है
मैं इस अवधारणा को एक सरल उदाहरण के साथ समझाऊंगा।

Observable<A> के 2 भाग हैं:

• Observable : कंटेनर, निश्चित प्रकार।
• A : सामान्य प्रकार का तर्क। एक अमूर्त जिसके लिए अन्य प्रकार पारित किए जा सकते हैं।

हम A जैसे सार के रूप में सामान्य प्रकार लेने के लिए उपयोग किया जाता है। लेकिन बहुत से लोग नहीं जानते हैं कि हम Observable कंटेनर प्रकारों का भी पालन कर सकते हैं। इसके लिए, उच्च प्रकार हैं।

विचार यह है कि हमारे पास F<A> जैसा एक निर्माता हो सकता है जिसमें F और A दोनों एक सामान्य प्रकार हो सकते हैं। यह सिंटैक्स अभी तक कोटलिन कंपाइलर ( अभी भी? ) द्वारा समर्थित नहीं है, इसलिए हम इसे एक समान दृष्टिकोण के साथ नकल करेंगे।

एरो एक इंटरमीडिएट मेटा इंटरफ़ेस Kind<F, A> के उपयोग के माध्यम से इसका समर्थन करता है, जिसमें दोनों प्रकार के लिंक होते हैं, और संकलन के दौरान दोनों दिशाओं में कन्वर्टर्स भी उत्पन्न करता है ताकि आप Kind<Observable, List<Task>> से पथ का अनुसरण कर सकें। Kind<Observable, List<Task>> Observable<List<Task>> और इसके विपरीत। एक आदर्श समाधान नहीं है, लेकिन एक काम कर रहा है।

तो फिर, हमारे भंडार का इंटरफ़ेस देखें:

 interface DataSource<F> { fun allTasksByUser(user: User): Kind<F, List<Task>> } 

DataSource फ़ंक्शन उच्च प्रकार देता है: Kind<F, List<Task>> । यह F<List<Task>> , जहां F सामान्यीकृत रहता है।

हम हस्ताक्षर में केवल List<Task> पर कब्जा करते हैं। दूसरे शब्दों में, हम परवाह नहीं करते हैं कि F कंटेनर का उपयोग किस प्रकार किया जाएगा, जब तक कि इसमें एक List<Task> । हम फ़ंक्शन में विभिन्न डेटा कंटेनर पास कर सकते हैं। पहले से ही स्पष्ट है? आगे बढ़ो।

आइए इस तरह से लागू किए गए DataSource पर एक नज़र डालें, लेकिन इस बार प्रत्येक के लिए व्यक्तिगत रूप से। सबसे पहले स्थानीय:

 class LocalDataSource<F>(A: ApplicativeError<F, Throwable>) : DataSource<F>, ApplicativeError<F, Throwable> by A { private val localCache: Map<User, List<Task>> = mapOf(User(UserId("user1")) to listOf(Task("LocalTask assigned to user1"))) override fun allTasksByUser(user: User): Kind<F, List<Task>> = Option.fromNullable(localCache[user]).fold( { raiseError(UserNotInLocalStorage(user)) }, { just(it) } ) } 

बहुत सी नई चीजों को जोड़ा गया है, हम हर चीज का चरण दर चरण विश्लेषण करेंगे।

यह DataSource सामान्य प्रकार F बनाए रखता है क्योंकि यह DataSource<F> लागू करता है। हम बाहर से इस प्रकार के प्रसारण की संभावना रखना चाहते हैं।

अब, निर्माता में संभवतः अपरिचित allTasksByUser() बारे में भूल जाएं और allTasksByUser() फ़ंक्शन पर ध्यान केंद्रित करें। और हम ऐप्लीकेशन पर लौट आएंगे।

 override fun allTasksByUser(user: User): Kind<F, List<Task>> = Option.fromNullable(localCache[user]).fold( { raiseError(UserNotInLocalStorage(user)) }, { just(it) } ) 

यह देखा जा सकता है कि यह Kind<F, List<Task>> । हमें अभी भी परवाह नहीं है कि कंटेनर F क्या F जब तक कि इसमें एक List<Task> ।

लेकिन एक समस्या है। इस पर निर्भर करते हुए कि हम स्थानीय स्टोरेज में वांछित उपयोगकर्ता के लिए Task ऑब्जेक्ट्स की सूची प्राप्त कर सकते हैं या नहीं, हम एक त्रुटि (कोई Task नहीं मिला) की रिपोर्ट करना चाहते हैं या पहले से ही टा में लिपटे Task ( Task पाया गया) को वापस करना चाहते हैं।

और दोनों ही मामलों में हमें लौटने की आवश्यकता है: Kind<F, List<Task>> ।

दूसरे शब्दों में: एक प्रकार है जिसे हम ( F ) के बारे में कुछ भी नहीं जानते हैं, और हमें उस प्रकार से लिपटे एक त्रुटि को वापस करने के लिए एक रास्ता चाहिए। साथ ही, हमें इस प्रकार का एक उदाहरण बनाने का एक तरीका चाहिए, जिसमें फ़ंक्शन के सफल समापन के बाद प्राप्त मूल्य को लपेटा जाएगा। कुछ असंभव जैसा लगता है?

आइए कक्षा की घोषणा पर वापस जाएं और ध्यान दें कि एप्लिकेटर को कंस्ट्रक्टर में पास किया जाता है और फिर कक्षा के लिए एक प्रतिनिधि के रूप में ( by A ) by A उपयोग किया जाता है।

 class LocalDataSource<F>(A: ApplicativeError<F, Throwable>) : DataSource<F>, ApplicativeError<F, Throwable> by A { //... } 

ApplicativeError एपेरेटिव से विरासत ApplicativeError मिला है, दोनों ही प्रकार के वर्ग हैं।

प्रकार कक्षाएं व्यवहार (अनुबंध) को परिभाषित करती हैं। वे इंटरफेस के रूप में एन्कोडेड होते हैं जो जेनेरिक प्रकारों के रूप में तर्कों के साथ काम करते हैं, जैसा कि Monad<F> , Functor<F> और कई अन्य में। यह F एक डेटा प्रकार है। इस तरह, हम Either , Option , IO , Flowable और कई और अधिक प्रकार पास कर सकते हैं।

इसलिए, हमारी दो समस्याओं पर वापस जाएं:

• फ़ंक्शन को सफलतापूर्वक Kind<F, List<Task>> में पूरा करने के बाद प्राप्त मान लपेटें

इसके लिए हम एक प्रकार के Applicative का उपयोग कर सकते हैं। चूँकि एप्लीकेटर इस से विरासत ApplicativeError मिला है, इसलिए हम इसके गुणों को सौंप सकते हैं।

Applicative सिर्फ just(a) फ़ंक्शन प्रदान करता है। just(a) किसी भी उच्च प्रकार के संदर्भ में मूल्य को लपेटता है। इस प्रकार, यदि हमारे पास Applicative<F> , तो कंटेनर F में मूल्य को लपेटने के लिए just(a) कह सकते हैं, जो भी उस मूल्य का है। मान लें कि हम Observable उपयोग करते हैं, हमारे पास एक Applicative<Observable> जो जानता है कि एक Observable में कैसे लपेटें, ताकि हमें Observable.just(a) ।

• उदाहरण में त्रुटि लपेटें Kind<F, List<Task>>

इसके लिए हम ApplicativeError उपयोग कर सकते हैं। यह एक फ़ंक्शन raiseError(e) , जो टाइप F कंटेनर में त्रुटि को लपेटता है F Observable उदाहरण के लिए, एक त्रुटि Observable.error<A>(t) तरह कुछ Observable.error<A>(t) , जहां t Throwable , क्योंकि हमने अपनी त्रुटि के प्रकार को एक प्रकार के ApplicativeError<F, Throwable> रूप में घोषित किया है ApplicativeError<F, Throwable> ।

LocalDataSource<F> हमारे अमूर्त कार्यान्वयन पर एक नज़र डालें।

 class LocalDataSource<F>(A: ApplicativeError<F, Throwable>) : DataSource<F>, ApplicativeError<F, Throwable> by A { private val localCache: Map<User, List<Task>> = mapOf(User(UserId("user1")) to listOf(Task("LocalTask assigned to user1"))) override fun allTasksByUser(user: User): Kind<F, List<Task>> = Option.fromNullable(localCache[user]).fold( { raiseError(UserNotInLocalStorage(user)) }, { just(it) } ) } 

स्मृति में संग्रहीत Map<User, List<Task>> समान रहता है, लेकिन अब यह फ़ंक्शन कुछ ऐसे काम करता है जो आपके लिए नए हो सकते हैं:

• वह स्थानीय कैश से Task सूची को लोड करने की कोशिश करता है, और चूंकि वापसी मूल्य null हो सकता है ( Task नहीं मिल सकता है), हम Option का उपयोग करके इसे मॉडल करते हैं। यदि यह स्पष्ट नहीं है कि Option कैसे काम करता है, तो यह उस मूल्य की उपस्थिति या अनुपस्थिति को दर्शाता है जो इसमें लिपटे हुए हैं।

  
  

• वैकल्पिक मूल्य प्राप्त करने के बाद, हम इसके शीर्ष पर fold कहते हैं। यह वैकल्पिक मान पर when का उपयोग करने के बराबर है। यदि मान गायब है, तो Option डेटा प्रकार F (पहले लंबो पास) में त्रुटि को लपेटता है। और यदि मान मौजूद है, तो Option डेटा टाइप F (दूसरा लैम्ब्डा) के लिए एक आवरण उदाहरण बनाता है। दोनों ही मामलों में, पहले इस्तेमाल की जाने वाली raiseError() संपत्ति का उपयोग किया जाता है: raiseError() और just() ।

  
  

इस प्रकार, हमने कक्षाओं का उपयोग करके डेटा स्रोतों के कार्यान्वयन को अमूर्त कर दिया ताकि उन्हें यह पता न चले कि किस प्रकार का F लिए कंटेनर का उपयोग किया जाएगा।

नेटवर्क DataSource लागू करना इस तरह दिखता है:

 class RemoteDataSource<F>(A: Async<F>) : DataSource<F>, Async<F> by A { private val internetStorage: Map<User, List<Task>> = mapOf(User(UserId("user2")) to listOf(Task("Remote Task assigned to user2"))) override fun allTasksByUser(user: User): Kind<F, List<Task>> = async { callback: (Either<Throwable, List<Task>>) -> Unit -> Option.fromNullable(internetStorage[user]).fold( { callback(UserNotInRemoteStorage(user).left()) }, { callback(it.right()) } ) } } 

लेकिन एक छोटा सा अंतर है: एप्लिकेरियल उदाहरण में प्रतिनिधि के बजाय, हम एक अन्य वर्ग का उपयोग करते हैं जैसे: Async ।

ऐसा इसलिए है क्योंकि नेटवर्क कॉल प्रकृति में अतुल्यकालिक हैं। हम कोड लिखना चाहते हैं जिसे एसिंक्रोनस रूप से निष्पादित किया जाएगा, इसके लिए डिज़ाइन किए गए एक प्रकार के वर्ग का उपयोग करना तर्कसंगत है।

एसिंक्रोनस अतुल्यकालिक संचालन का अनुकरण करने के लिए उपयोग किया जाता है। यह किसी भी कॉलबैक ऑपरेशन का अनुकरण कर सकता है। ध्यान दें कि हम अभी भी विशिष्ट डेटा प्रकारों को नहीं जानते हैं, हम बस प्रकृति में अतुल्यकालिक एक ऑपरेशन का वर्णन करते हैं।

निम्नलिखित कार्य पर विचार करें:

 override fun allTasksByUser(user: User): Kind<F, List<Task>> = async { callback: (Either<Throwable, List<Task>>) -> Unit -> Option.fromNullable(internetStorage[user]).fold( { callback(UserNotInRemoteStorage(user).left()) }, { callback(it.right()) } ) } 

हम फ़ंक्शन को async {} उपयोग कर सकते हैं, जो हमें ऑपरेशन को अनुकरण करने के लिए टाइप Async एक वर्ग के साथ प्रदान किया जाता है और प्रकार Kind<F, List<Task>> एक उदाहरण बनाता है Kind<F, List<Task>> जिसे asynchronously बनाया जाएगा।

यदि हम एक निश्चित डेटा प्रकार का उपयोग करते हैं, जैसे कि Async.async {} , Async.async {} Observable.create() , यानी के बराबर होगा। एक ऑपरेशन बनाना, जिसे सिंक्रोनस या एसिंक्रोनस कोड से बुलाया जा सकता है, जैसे Thread या AsyncTask ।

callback पैरामीटर का उपयोग परिणामी कॉलबैक को कंटेनर संदर्भ F से जोड़ने के लिए किया जाता है, जो एक उच्च प्रकार है।

इस प्रकार, हमारा RemoteDataSource सार है और अभी भी F अज्ञात कंटेनर पर निर्भर करता है F

चलिए एब्सट्रैक्शन के स्तर तक जाते हैं और हमारी रिपॉजिटरी पर एक और नज़र डालते हैं। यदि आपको याद है, तो पहले हमें LocalDataSource में Task ऑब्जेक्ट्स की खोज करने की आवश्यकता है, और केवल तब (यदि वे स्थानीय रूप से नहीं मिले थे) RemoteLocalDataSource से अनुरोध करने के लिए।

 class TaskRepository<F>( private val localDS: DataSource<F>, private val remoteDS: RemoteDataSource<F>, AE: ApplicativeError<F, Throwable>) : ApplicativeError<F, Throwable> by AE { fun allTasksByUser(user: User): Kind<F, List<Task>> = localDS.allTasksByUser(user).handleErrorWith { when (it) { is UserNotInLocalStorage -> remoteDS.allTasksByUser(user) else -> raiseError(UnknownError(it)) } } } 

ApplicativeError<F, Throwable> फिर से हमारे साथ है! यह किसी भी उच्च अंत रिसीवर के शीर्ष पर काम करने वाला फ़ंक्शन handleErrorWith() फ़ंक्शन प्रदान करता है।

यह इस तरह दिखता है:

 fun <A> Kind<F, A>.handleErrorWith(f: (E) -> Kind<F, A>): Kind<F, A> 

क्योंकि localDS.allTasksByUser(user) Kind<F, List<Task>> रिटर्न देता है Kind<F, List<Task>> , जिसे F<List<Task>> के रूप में माना जा सकता है, जहां F एक सामान्य प्रकार बना हुआ है, हम इसके ऊपर से handleErrorWith() को कॉल कर सकते हैं।

handleErrorWith() आपको गुज़रे हुए लैम्ब्डा का उपयोग करके त्रुटियों का जवाब देने की अनुमति देता है। चलो समारोह पर एक करीब देखो:

 fun allTasksByUser(user: User): Kind<F, List<Task>> = localDS.allTasksByUser(user).handleErrorWith { when (it) { is UserNotInLocalStorage -> remoteDS.allTasksByUser(user) else -> raiseError(UnknownError(it)) } } 

इस प्रकार, हमें पहले ऑपरेशन का परिणाम मिलता है, सिवाय इसके कि जब एक अपवाद को फेंक दिया गया था। अपवाद लांबा द्वारा नियंत्रित किया जाएगा। यदि त्रुटि UserNotInLocalStorage प्रकार की है, तो हम UserNotInLocalStorage में Tasks प्रकार की वस्तुओं को खोजने का प्रयास करेंगे। अन्य सभी मामलों में, हम अज्ञात त्रुटि को F कंटेनर में लपेटते हैं F

निर्भरता मॉड्यूल पिछले संस्करण के समान है:

 class Module<F>(A: Async<F>) { private val localDataSource: LocalDataSource<F> = LocalDataSource(A) private val remoteDataSource: RemoteDataSource<F> = RemoteDataSource(A) val repository: TaskRepository<F> = TaskRepository(localDataSource, remoteDataSource, A) } 

अंतर केवल इतना है कि यह अब सार है और F पर निर्भर करता है, जो बहुरूपी रहता है। मैंने शोर के स्तर को कम करने के लिए जानबूझकर इस पर ध्यान नहीं दिया, लेकिन Async एप्टीट्यूटर से विरासत में मिला है, इसलिए इसे कार्यक्रम निष्पादन के सभी स्तरों पर इसके उदाहरण के रूप में इस्तेमाल किया जा सकता है।

बहुरूपता का परीक्षण

अंत में, हमारा एप्लिकेशन कंटेनरों ( F ) के लिए विशिष्ट डेटा प्रकारों के उपयोग से पूरी तरह से अलग है और हम रनटाइम में पॉलिफॉर्मिज्म के परीक्षण पर ध्यान केंद्रित कर सकते हैं। हम टाइप F लिए अलग-अलग प्रकार के डेटा पास करने वाले कोड के एक ही टुकड़े का परीक्षण करेंगे F परिदृश्य वैसा ही है जब हमने Observable उपयोग किया था।

कार्यक्रम इस तरह से लिखा गया है कि हम पूरी तरह से सार की सीमाओं से छुटकारा पा लेते हैं और कार्यान्वयन विवरण को वांछित रूप में बता सकते हैं।

सबसे पहले, RxJava से एक कंटेनर के रूप में F Single का उपयोग करने का प्रयास करें।

 object test { @JvmStatic fun main(args: Array<String>): Unit { val user1 = User(UserId("user1")) val user2 = User(UserId("user2")) val user3 = User(UserId("unknown user")) val singleModule = Module(SingleK.async()) singleModule.run { repository.allTasksByUser(user1).fix().single.subscribe(::println, ::println) repository.allTasksByUser(user2).fix().single.subscribe(::println, ::println) repository.allTasksByUser(user3).fix().single.subscribe(::println, ::println) } } } 

अनुकूलता के लिए, एरो प्रसिद्ध पुस्तकालय डेटा प्रकारों के लिए आवरण प्रदान करता है। उदाहरण के लिए, एक सुविधाजनक SingleK रैपर है। ये रैपर आपको उच्च प्रकार के रूप में डेटा प्रकारों के साथ संयोजन में उपयोग करने की अनुमति देते हैं।

निम्नलिखित कंसोल पर प्रदर्शित किया जाएगा:

 [Task(value=LocalTask assigned to user1)] [Task(value=Remote Task assigned to user2)] UserNotInRemoteStorage(user=User(userId=UserId(value=unknown user))) 

यदि Observable का उपयोग करना है तो वही परिणाम होगा।

अब आइए, Maybe साथ काम करें, जिसके लिए Maybe MaybeK रैपर MaybeK :

 @JvmStatic fun main(args: Array<String>): Unit { val user1 = User(UserId("user1")) val user2 = User(UserId("user2")) val user3 = User(UserId("unknown user")) val maybeModule = Module(MaybeK.async()) maybeModule.run { repository.allTasksByUser(user1).fix().maybe.subscribe(::println, ::println) repository.allTasksByUser(user2).fix().maybe.subscribe(::println, ::println) repository.allTasksByUser(user3).fix().maybe.subscribe(::println, ::println) } } 

एक ही परिणाम कंसोल पर प्रदर्शित किया जाएगा, लेकिन अब एक अलग डेटा प्रकार का उपयोग कर:

 [Task(value=LocalTask assigned to user1)] [Task(value=Remote Task assigned to user2)] UserNotInRemoteStorage(user=User(userId=UserId(value=unknown user))) 

क्या के बारे में ObservableK / FlowableK ?
आइए इसे आजमाएँ:

 object test { @JvmStatic fun main(args: Array<String>): Unit { val user1 = User(UserId("user1")) val user2 = User(UserId("user2")) val user3 = User(UserId("unknown user")) val observableModule = Module(ObservableK.async()) observableModule.run { repository.allTasksByUser(user1).fix().observable.subscribe(::println, ::println) repository.allTasksByUser(user2).fix().observable.subscribe(::println, ::println) repository.allTasksByUser(user3).fix().observable.subscribe(::println, ::println) } val flowableModule = Module(FlowableK.async()) flowableModule.run { repository.allTasksByUser(user1).fix().flowable.subscribe(::println) repository.allTasksByUser(user2).fix().flowable.subscribe(::println) repository.allTasksByUser(user3).fix().flowable.subscribe(::println, ::println) } } } 

हम कंसोल में देखेंगे:

 [Task(value=LocalTask assigned to user1)] [Task(value=Remote Task assigned to user2)] UserNotInRemoteStorage(user=User(userId=UserId(value=unknown user))) [Task(value=LocalTask assigned to user1)] [Task(value=Remote Task assigned to user2)] UserNotInRemoteStorage(user=User(userId=UserId(value=unknown user))) 

सब कुछ उम्मीद के मुताबिक काम करता है।

आइए kotlinx.coroutines.Deferred का उपयोग करने का प्रयास करें, टाइप kotlinx.coroutines.Deferred लिए एक आवरण। kotlinx.coroutines.Deferred :

 object test { @JvmStatic fun main(args: Array<String>): Unit { val user1 = User(UserId("user1")) val user2 = User(UserId("user2")) val user3 = User(UserId("unknown user")) val deferredModule = Module(DeferredK.async()) deferredModule.run { runBlocking { try { println(repository.allTasksByUser(user1).fix().deferred.await()) println(repository.allTasksByUser(user2).fix().deferred.await()) println(repository.allTasksByUser(user3).fix().deferred.await()) } catch (e: UserNotInRemoteStorage) { println(e) } } } } } 

जैसा कि आप जानते हैं, कॉरटीन का उपयोग करते समय अपवाद को संभालना स्पष्ट रूप से निर्धारित करना होगा। , , .

— :

 [Task(value=LocalTask assigned to user1)] [Task(value=Remote Task assigned to user2)] UserNotInRemoteStorage(user=User(userId=UserId(value=unknown user))) 

Arrow API DeferredK . runBlocking :

 object test { @JvmStatic fun main(args: Array<String>): Unit { val user1 = User(UserId("user1")) val user2 = User(UserId("user2")) val user3 = User(UserId("unknown user")) val deferredModuleAlt = Module(DeferredK.async()) deferredModuleAlt.run { println(repository.allTasksByUser(user1).fix().unsafeAttemptSync()) println(repository.allTasksByUser(user2).fix().unsafeAttemptSync()) println(repository.allTasksByUser(user3).fix().unsafeAttemptSync()) } } } 

[ Try ]({{ '/docs/arrow/core/try/ru' | relative_url }}) (.., Success Failure ).

 Success(value=[Task(value=LocalTask assigned to user1)]) Success(value=[Task(value=Remote Task assigned to user2)]) Failure(exception=UserNotInRemoteStorage(user=User(userId=UserId(value=unknown user)))) 

, , IO .
IO , in/out , , .

 object test { @JvmStatic fun main(args: Array<String>): Unit { val user1 = User(UserId("user1")) val user2 = User(UserId("user2")) val user3 = User(UserId("unknown user")) val ioModule = Module(IO.async()) ioModule.run { println(repository.allTasksByUser(user1).fix().attempt().unsafeRunSync()) println(repository.allTasksByUser(user2).fix().attempt().unsafeRunSync()) println(repository.allTasksByUser(user3).fix().attempt().unsafeRunSync()) } } } 

 Right(b=[Task(value=LocalTask assigned to user1)]) Right(b=[Task(value=Remote Task assigned to user2)]) Left(a=UserNotInRemoteStorage(user=User(userId=UserId(value=unknown user)))) 

IO — . Either<L,R> ( ). , "" Either , "" , . Right(...) , , Left(...) .

.

, . , , , .

.

… ?

, , . .

• : , (, ), — . , .

  
  

• , . . () ( ) , .

  
  

• (), , (). , .

  
  

• , . , ( ).

  
  

• , API . ( map , flatMap , fold , ). , , Kotlin, Arrow — .

  
  

• DI ( ), .., DI " ". , , . DI, .., , .

  
  

• , , . , .., , .

  
  

, .
, , , , .

, . — Twitter: @JorgeCastilloPR .

(, ) :

• Kotlin Functional Programming: Does it make sense? Jorge Castillo
• Kotlin purity and Function Memoization Jorge Castillo

FP to the max John De Goes FpToTheMax.kt , arrow-examples . , , .