🥝 🤥 😱 कोटलिन में सूची। हास्केल दृष्टिकोण 🤟🏼 🔸 👋🏾

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

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

मूल कार्य

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

head (x:_) = x head [] = badHead

यदि सूची में कुछ तत्व हैं, तो हम पहले लौटेंगे, अन्यथा हम एक त्रुटि वापस करेंगे।
हमारे पास इस तरह के कोड को लिखने का अवसर नहीं है, लेकिन, सामान्य तौर पर, यदि आप बारीकी से देखते हैं, तो यह टेम्पलेट के समान है। हम एक्सटेंशन फ़ंक्शन का उपयोग बाद में सूचियों पर इस पद्धति का उपयोग करने में सक्षम होने के लिए करेंगे और मूल्य प्राप्त करने का थोड़ा और संक्षिप्त तरीका होगा, बिना किसी कोष्ठक के, एक विधि कॉल की तरह।

 val <T> List<T>.head: T get() = when (this.isEmpty()) { true -> throw NoSuchElementException("List is empty.") false -> this[0] }

आसानी से पुनरावर्तन का उपयोग करने के लिए, हम सूची को पहले तत्व + अन्य सभी में विभाजित करना चाहेंगे। आइए इसके लिए टेल फ़ंक्शन को लागू करने का प्रयास करें।

यहाँ हैसेल पर ऐसा दिखता है:

 tail (_:xs) = xs tail [] = errorEmptyList "tail"

दुर्भाग्य से, कोटलिन इस तरह के पैटर्न का मिलान प्रदान नहीं करता है कि डेवलपर्स उसी शैली में वर्णन कर सकें, इसलिए यहां हमें थोड़ा लिखना होगा।

 val <T> List<T>.tail: List<T> get() = drop(1)

भाषा पुस्तकालय से किसी फ़ंक्शन का उपयोग करना थोड़ा बेईमानी है, लेकिन दूसरी तरफ, किसी भी मामले में, हमें इस पद्धति के लिए कोड लिखना होगा, इसलिए पहले से काम करने के तरीकों का उपयोग करना बेहतर होगा।

अब हम सूची को पहले तत्व + बाकी सूची में विभाजित कर सकते हैं। हमें सूची और एक तत्व को मिलाने के कार्य की भी आवश्यकता होगी, जिसे बाद में सूची में रूपांतरण और अन्य कार्यों के लिए सक्रिय रूप से उपयोग किया जाएगा।

 operator fun <T> List<T>.plus(x: T): List<T> = ArrayList(this).also { it.add(x) }

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

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

isEmpty () - क्या सूची में कोई तत्व हैं
सिर - सूची का पहला तत्व
पूंछ - पहले तत्व के बिना एक सूची
सूची + तत्व - हम एक वस्तु के साथ सूची को संक्षिप्त कर सकते हैं

वास्तव में, हम सभी की जरूरत है सभी तरीकों को प्राप्त करने की जरूरत है।
मेरे स्वाद के लिए, जब कथन में सूची लंबाई तुलना का उपयोग करना अधिक सुविधाजनक होगा। कोटलिन पहले से ही हमें इस सूची की लंबाई प्राप्त करने के लिए आकार प्रदान करता है। हालाँकि, मान लीजिए कि हम इसे स्वयं लागू करना चाहते हैं। हमारी कार्यक्षमता के साथ, यह काफी सरल होगा:

 val <T> List<T>.size: Int get() = when (this.isEmpty()) { true -> 0 false -> 1 + this.tail.size }

बुनियादी कार्यों के आवेदन

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

 fun sum(xs: List<Int>): Int = when (xs.size) { 0 -> 0 else -> xs.head + sum(xs.tail) }

विचार बहुत सरल है: यदि सूची में कोई तत्व नहीं हैं, तो योग 0 है; अन्यथा, यह पहले तत्व का योग है और पूंछ के लिए राशि का पुनरावर्ती कॉल है।

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

ऐसा लग सकता है कि हमारे द्वारा बताई गई राशि का कार्य केवल उसी तरह है, क्योंकि अंतिम कॉल राशि (xs.tail) है । हालांकि, यह सच नहीं है। यदि आप कोड का थोड़ा अलग तरीके से वर्णन करते हैं, तो यह स्पष्ट हो जाएगा:

 fun sum(xs: List<Int>): Int = when (xs.size) { 0 -> 0 else -> { val head = xs.head val tailSum = sum(xs.tail) head + tailSum } }

अब हम देखते हैं कि वास्तव में अंतिम कॉल पहले तत्व और पूंछ के शेष भाग का योग है।

अच्छी खबर यह है कि यदि आप किसी फ़ंक्शन में टेलरेक संशोधक जोड़ते हैं, तो आईडीई आपको बताएगा कि फ़ंक्शन नहीं है। हालाँकि, इसे ठीक करना बहुत सीधा है। एक फ़ंक्शन को ठीक करने वाली एक सामान्य चाल परिणामों को संग्रहीत करने के लिए एक सहायक चर का उपयोग करना है। यह इस तरह दिखता है:

 tailrec fun sum(xs: List<Int>, acum: Int): Int = when (xs.size) { 0 -> acum else -> sum(xs.tail, xs.head + acum) }

तत्वों की राशि की गणना करने के लिए, यह 2 के पैरामीटर के रूप में 0. पास करने के लिए पर्याप्त है, और इसे पूरी तरह से मुहावरेदार बनाने के लिए, हम फ़ंक्शन को थोड़ा और फिर से करेंगे, बाहरी दुनिया के बिना आंतरिक फ़ंक्शन में मुख्य गणनाओं को छिपाते हुए उस पैरामीटर तक पहुंचें जो इसे जरूरत नहीं है।

 fun sum(xs: List<Int>):Int { tailrec fun sumInner(xs: List<Int>, acum: Int): Int = when (xs.size) { 0 -> acum else -> sumInner(xs.tail, xs.head + acum) } return sumInner(xs, 0) }

इस ज्ञान के होने के बाद, आप देख सकते हैं कि हमारे द्वारा लागू किया गया आकार समारोह पूंछ पुनरावृत्ति के लिए आवश्यक शर्तों को पूरा नहीं करता है।

अब हम कोटलिन का उपयोग करके मानचित्र, फ़िल्टर, को कम करने के लिए तैयार हैं। बाद में हम देखेंगे कि यह केवल बाद वाले को महसूस करने के लिए पर्याप्त था, और बाकी, आम तौर पर बोल रहे हैं, इसके व्युत्पन्न हैं। लेकिन पहले बातें पहले।

मुख्य कार्य

एमएपी

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

 fun <T, R> List<T>.map(f: (T) -> R): List<R> = when (this.size) { 0 -> listOf() else -> f(head) + tail.map(f) }

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

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

 operator fun <T> List<T>.plus(xs: List<T>): List<T> = when (xs.size) { 0 -> ArrayList(this) else -> (this + xs.head) + xs.tail } operator fun <T> T.plus(xs: List<T>): List<T> = listOf(this) + xs

फ़िल्टर

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

 fun <T> List<T>.filter(f: (T) -> Boolean): List<T> = when (this.size) { 0 -> listOf() else -> if (f(head)) head + tail.filter(f) else tail.filter(f) }

यदि वर्तमान तत्व फ़िल्टर स्थिति को संतुष्ट करता है, तो इसे पुन: सूची की पूंछ में जोड़ें, अन्यथा, हम केवल सूची की पूंछ के साथ काम करना जारी रखते हैं।

कम

समझने में सबसे मुश्किल और, एक ही समय में, सबसे शक्तिशाली फ़ंक्शन (कार्यात्मक दुनिया में इसे गुना के रूप में जाना जाता है)। सबसे अधिक बार, इसका उपयोग किसी सूची को किसी एक आइटम को संक्षिप्त करने के लिए किया जाता है। आपके पास एक निश्चित प्रारंभिक मूल्य s0 है , और तत्वों की एक सूची भी है [] और एक फ़ंक्शन एफ , जो शुरुआती मूल्य और सूची के अगले तत्व के लिए एक नया रिटर्न देता है। f (s0, एक [0]) = s1 । और इस प्रकार, हम अनुक्रमिक रूप से तत्वों की पूरी सूची से गुजरते हैं, आउटपुट पर किसी प्रकार का एकल मूल्य प्राप्त करते हैं। एक काफी सामान्य उदाहरण सरणी तत्वों का योग है। इस स्थिति में, प्रारंभिक मान 0 है, और फ़ंक्शन दो तत्वों का योग लौटाता है: f (s, a [i]) = s + a [i] । विचार करें कि हम इस फ़ंक्शन को कैसे पुन: लागू कर सकते हैं।

 fun <T, R> reduce(s: T, xs: List<R>, f: (T, R) -> T): T = when (xs.size) { 0 -> s else -> reduce(f(s, xs.head), xs.tail, f) }

सिद्धांत रूप में, कार्यान्वयन बिल्कुल वैसा ही है जैसा हमने ऊपर समीक्षा की है। यदि सूची में कोई तत्व नहीं हैं, तो हम वर्तमान मान लौटाते हैं, अन्यथा, हम नए पहले तत्व की गणना करते हैं, और फिर से इसके लिए कम फ़ंक्शन और सूची की पूंछ कहते हैं।

ध्यान दें कि हम इस फ़ंक्शन में संशोधन भी कर सकते हैं। उदाहरण के लिए, प्रारंभ मान को पास न करें, लेकिन इसके लिए सूची के पहले तत्व का उपयोग करें। यह समझने के लिए कि कमी वहाँ समाप्त नहीं होती है, कल्पना करें कि हम एक अलग सूची का उपयोग प्रारंभिक मूल्य के रूप में करते हैं। इस मामले में, प्रत्येक बार पुनरावृत्ति पर हम एक मूल्य नहीं, बल्कि एक सूची संग्रहीत करेंगे, जिसकी बदौलत हमारी क्षमताएं बहुत बढ़ जाती हैं। उदाहरण के लिए, आउटपुट पर मूल सूची प्राप्त करने के लिए इस तरह से कम फ़ंक्शन को लागू करने का प्रयास करें:

 fun <T> reduceSame(xs: List<T>) = reduce(listOf<T>(), xs) { ys, s -> ys + s }

अब, मुझे लगता है, आप अनुमान लगाते हैं कि हम नक्शे, फ़िल्टर के वैकल्पिक कार्यान्वयन के लिए कम उपयोग कर सकते हैं। चूंकि हमने कम के साथ एक ही सूची को वापस करना सीखा है, इसलिए हमें प्रत्येक तत्व को बदलने में सक्षम होने के लिए बहुत कम बदलाव करने की आवश्यकता है। फिल्टर के लिए, सब कुछ बहुत समान है।

 fun <T, R> List<T>.map2(f: (T) -> R): List<R> = reduce(mutableListOf(), this) { xs, s -> (xs + f(s)).toMutableList() } fun <T> List<T>.filter2(f: (T) -> Boolean): List<T> = reduce(mutableListOf(), this) { ys, s -> if (f(s)) return@reduce (ys + s).toMutableList() else ys }

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

 fun <T, R> reduceRight(s: T, xs: List<R>, f: (T, R) -> T): T = when (xs.size) { 0 -> s else -> f(reduceRight(s, xs.tail, f), xs.head) }

यदि सूची खाली नहीं है, तो हम फ़ंक्शन को सूची की पूंछ और सूची के प्रमुख को मोड़ने के परिणाम के लिए लागू करते हैं। इस प्रकार, पहले तत्व को अंतिम रूप से संसाधित किया जाएगा; पारिजात - २ वगैरह। इस विकल्प के लिए, आप उन संशोधनों को भी जोड़ सकते हैं जो सूची के अंतिम तत्व का उपयोग प्रारंभिक मूल्य के रूप में करेंगे, आदि।

लगभग हमेशा, जब सूचियों के साथ काम करते हैं, तो आप इन 3 कार्यों के कुछ संयोजन का उपयोग कर सकते हैं ताकि आप जिस विषय में रुचि रखते हैं उसे प्राप्त कर सकें।

आइए ज़िप फ़ंक्शन को भी लागू करें, जो हमें 2 सूचियों को संयोजित करने की अनुमति देगा।
प्रवेश द्वार पर हमें 2 सूचियां मिलती हैं। और हम उन जोड़ों की सूची वापस करना चाहते हैं जिनकी लंबाई मूल सूचियों के न्यूनतम के बराबर है।

हमेशा की तरह, आपको पुनरावृत्ति से बाहर निकलने के बारे में सोचने और एक फ़ंक्शन लिखने की आवश्यकता है।

 fun <T, R> zip(xs: List<T>, ys: List<R>): List<Pair<T, R>> { return when (xs.isEmpty() || ys.isEmpty()) { true -> listOf() false -> Pair(xs.head, ys.head) + zip(xs.tail, ys.tail) } }

आप अपने स्वयं के संशोधनों को जोड़ सकते हैं, जो आपको तत्वों की एक जोड़ी को वापस करने के बजाय दो तत्वों के लिए एक निश्चित फ़ंक्शन लागू करेगा। हास्केल में, इस फ़ंक्शन को zipWith कहा जाता है। और इसे उस कार्यक्षमता के साथ लागू किया जाता है जिसे हम बहुत सरलता से लिखने में कामयाब रहे हैं

 fun <T, R, C> zipWith(xs: List<T>, ys: List<R>, f: (T, R) -> C): List<C> = zip(xs, ys).map { f(it.first, it.second) }

बहुत बार, कार्यात्मक दृष्टिकोण का उपयोग करते समय, समस्याएं आती हैं जब आपको सूची में वस्तुओं के आधार पर नहीं बल्कि सूचकांकों के आधार पर जोड़तोड़ करने की आवश्यकता होती है। उदाहरण के लिए, हमें किसी सूची के सभी तत्वों को योग करने की आवश्यकता है। आप पेयर <Int, बूलियन> के रूप में मौजूदा मूल्य को बनाए रखने और अगर झंडा == सच है, और अगले कदम के लिए हर बार झंडे की उपेक्षा को ले सकते हैं, तो आप इसे कम करने की कोशिश कर सकते हैं। हालाँकि, यह बहुत सुंदर नहीं लगता है, और पाठक को यह पता लगाना होगा कि आप इस कोड के साथ क्या व्यक्त करना चाहते हैं। कोटलिन के पास अनंत अनुक्रम हैं, और वे इस समस्या को हल करने के लिए महान हैं। यदि हम विश्लेषण करते हैं कि हम क्या करना चाहते हैं, तो यह पता चलता है कि हम सभी तत्वों को विषम सूचकांक के साथ फ़िल्टर करना चाहते हैं, और शेष लोगों को योग करते हैं। और अनुक्रमित प्राप्त करने में सक्षम होने के लिए, यह सूची और अनुक्रम के लिए ज़िप को कॉल करने के लिए पर्याप्त है [0,1,2 ..]

 fun sumWithEvenIndexes(xs: List<Int>) = zip(xs, generateSequence(0) { it + 1 }.take(xs.size).toList()) .filter { it.second % 2 == 0 } .map { it.first } .sum()

कोटलिन मानक पुस्तकालय में, आप अनुक्रम जोड़ी के लिए ज़िप फ़ंक्शन पा सकते हैं।

अब आइए एक सरल पहेली को देखें जिसने मुझे इस गाइड को लिखने के लिए प्रेरित किया, और इसका कार्यान्वयन कोटलिन में एक अनिवार्य भाषा में और हास्केल में बहुत अंत में कैसे दिखता है।

पूर्णांक की एक सरणी में आसन्न संख्याओं के जोड़े के बीच अधिकतम राशि की गणना करना आवश्यक है। सरणी की लंबाई 1 से अधिक है, और आपको तत्वों को सिंक करने पर अतिप्रवाह के बारे में चिंता करने की ज़रूरत नहीं है।

शाही जावा दृष्टिकोण:

 public Integer maxSum(List<Integer> array) { Integer max = array.get(0) + array.get(1); for (int i = 2; i < array.size(); i++) if (array.get(i) + array.get(i-1) > max) max = array.get(i) + array.get(i-1); return max; }

लिखित कार्यों का उपयोग करते हुए कोटलिन पर एक कार्यात्मक दृष्टिकोण (मैं खुद को प्रशिक्षण के रूप में अधिकतम कार्य को लागू करने का प्रस्ताव करता हूं):

 fun maxSum(xs: List<Int>) = zipWith(xs, xs.tail, {a, b -> a + b}).max()

हास्केल कार्यान्वयन:

 maxSum xs = maximum $ zipWith (+) xs (tail xs)

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

निष्कर्ष

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

संभवतः कार्यात्मक शैली में सबसे कठिन यह है कि समस्या को विभिन्न तरीकों से हल किया जा सकता है। सबसे स्पष्ट भविष्य में बोझिल और मुश्किल हो सकता है, और सबसे अधिक समझने योग्य लिखने में समय और गंभीर विचार हो सकता है। केवल एक चीज जो महारत हासिल करने में मदद कर सकती है वह है निरंतर अभ्यास और प्रशिक्षण।

पुनश्च: जैसा कि ऊपर उल्लेख किया गया है, आप सभी उदाहरणों के साथ भंडार देख सकते हैं जो लेख में हैं। परीक्षण चलाएं और देखें कि यह कैसे काम करता है!

PPS: आप एक वैकल्पिक दृष्टिकोण को भी देख सकते हैं जो समान कार्यक्षमता को लागू करता है ।

और बाद में https://arrow-kt.io/ अवश्य देखें । मेरी राय में, आपको तुरंत वहाँ नहीं दिखना चाहिए, क्योंकि सब कुछ बहुत डरावना लगता है, लेकिन बाद में, जब फंक्शनलर्स और मोनड आपको डरा नहीं पाएंगे, तो इसका अध्ययन करना सुनिश्चित करें।

कोटलिन में सूची। हास्केल दृष्टिकोण