भिक्षुओं के बारे में अवैज्ञानिक

सभी को नमस्कार।

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

कोड उदाहरण कोटलिन में लिखे जाएंगे, जैसे यह काफी लोकप्रिय है, और एक ही समय में काफी कार्यात्मक (शब्द के दोनों इंद्रियों में)।

चलिए एक फ़नकार की अवधारणा से शुरू करते हैं, यहाँ यह है:

interface Functor<A> 

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

फ़नकार कार्यान्वयन के उदाहरण:

• स्थिर
• प्रकार A परिणामस्वरूप आने वाले तर्कों की एक मनमानी संख्या के साथ कार्य करता है
• राज्य छद्म यादृच्छिक जनरेटर (रैंडम)
• हार्डवेयर यादृच्छिक संख्या जनरेटर
• डिस्क से या नेटवर्क से ऑब्जेक्ट पढ़ना
• एसिंक्रोनस गणना - फनकार कार्यान्वयन के लिए एक कॉलबैक पारित किया जाता है, जिसे कुछ समय बाद कहा जाएगा

स्थिर को छोड़कर, इन सभी उदाहरणों में एक महत्वपूर्ण संपत्ति है - वे आलसी हैं, अर्थात्। गणना स्वयं तब नहीं होती है जब फ़नकार बनाया जाता है, लेकिन जब इसकी गणना की जाती है।

Functor<A> , Functor<A> से टाइप A का मान प्राप्त करने की अनुमति नहीं देता है, या टाइप A मौजूदा मूल्य से एक नया Functor<A> बनाने की अनुमति नहीं देता है A लेकिन इस तरह के प्रतिबंधों के साथ भी, फ़नकार बेकार नहीं है - यदि किसी प्रकार B हम A से B बदल सकते हैं (दूसरे शब्दों में, एक फ़ंक्शन (a: A) -> B ) है, तो हम एक फ़ंक्शन लिख सकते हैं (f: Functor<A>) -> Functor<B> और इसे नाम दें:

 interface Functor<A> { fun <B> map(f: (A) -> B): Functor<B> } 

फ़नकार के विपरीत, मानचित्र विधि एक मनमाना कार्य नहीं हो सकती है:
- map((a) -> a) ही फ़नकार को वापस करना चाहिए
- map((a) -> f(a)).map((b) -> g(b)) map(a -> g(f(a)) समान होना चाहिए map(a -> g(f(a))

एक उदाहरण के रूप में, हम एक फ़नकार को लागू करते हैं जो एक निश्चित मान देता है जिसमें एक निश्चित संख्या में यादृच्छिक बिट्स होते हैं। कोटलिन में हमारा इंटरफ़ेस इतनी आसानी से उपयोग नहीं किया जा सकता है (लेकिन यदि आप चाहें तो), तो हम एक विस्तार विधि लिखेंगे:

 //  - ,     ,   map data class MyRandom<A>( val get: (bits: Int) -> A ) { companion object { val intRandom: MyRandom<Int> = MyRandom { Random.nextBits(it) } val hexRandom: MyRandom<String> = intRandom.map { it.toString(16) } } } //  map   fun <A, B> MyRandom<A>.map(f: (A) -> B): MyRandom<B> = MyRandom(get = {bits -> f(get(bits)) }) fun main(args: Array<String>) { println("random=" + MyRandom.intRandom.get(12)) //  random=1247 println("hexRandom=" + MyRandom.hexRandom.get(12)) //  hexRandom=c25 } 

एक उपयोगी map साथ फंक्शनलर्स के अन्य उदाहरण

• अपरिवर्तनीय List<A>
• MyInputStream<A>
• Optional<A>

अब आप भिक्षुओं के पास जा सकते हैं।

एक मोनड दो अतिरिक्त संचालन वाला एक फ़नकार है। सबसे पहले, फन्ने के विपरीत मोनाड में एक स्थिर से निर्माण का संचालन होता है, इस ऑपरेशन को lift कहा जाता lift :

 fun <A> lift(value: A): Monad<A> = TODO() 

दूसरे ऑपरेशन को flatMap कहा जाता है, यह अधिक जटिल है, इसलिए पहले हम अपने पूरे मोनड इंटरफ़ेस को देंगे:

 interface Monad<A> { //   ,  map     - //    flatMap  lift fun <B> map(f: (A) -> B): Monad<B> = flatMap { a -> lift(f(a)) } fun <B> flatMap(f: (A) -> Monad<B>): Monad<B> } fun <A> lift(value: A): Monad<A> = TODO() 

एक भिक्षु और एक फ़नकार के बीच सबसे महत्वपूर्ण अंतर यह है कि भिक्षुओं को एक-दूसरे के साथ जोड़ा जा सकता है, नए साधुओं को पैदा किया जा सकता है और इस बात से अमूर्त किया जाता है कि कैसे मोनाद को लागू किया जाता है - क्या यह डिस्क से पढ़ता है, क्या यह इसके मान की गणना करने के लिए अतिरिक्त मापदंडों को स्वीकार करता है, क्या यह मान मौजूद है । दूसरा महत्वपूर्ण बिंदु - भिक्षुओं को समानांतर में संयोजित नहीं किया जाता है, लेकिन क्रमिक रूप से, पहले मठ के परिणाम के आधार पर तर्क को जोड़ने की क्षमता को छोड़कर।

एक उदाहरण:

 // ,     Int //       -      //           val readInt: Monad<Int> = TODO() // ,      -  fun readBytes(len: Int): Monad<ByteArray> = TODO() // ,     ,    val bytes: Monad<ByteArray> = readInt.flatMap {len -> if (len > 0) readBytes(len) //    -   else lift(ByteArray(0)) //  ,    } 

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

पहले उदाहरण सरल है, विकल्प मोनाड। कोटलिन में, इसकी वास्तव में आवश्यकता नहीं है, लेकिन जावा / स्काला में यह अत्यंत उपयोगी है:

 data class Option<A>(val value: A?) { fun <B> map(f: (A) -> B): Option<B> = flatMap { a -> lift(f(a)) } fun <B> flatMap(f: (A) -> Option<B>): Option<B> = when(value) { null -> Option(null) else -> f(value) } } fun <A> lift(value: A?): Option<A> = Option(value) fun mul(a: Option<Int>, b: Option<Int>): Option<Int> = a.flatMap { a -> b.map { b -> a * b } } fun main(args: Array<String>) { println(mul(Option(4), Option(5)).value) // 20 println(mul(Option(null), Option(5)).value) // null println(mul(Option(4), Option(null)).value) // null println(mul(Option(null), Option(null)).value) // null } 

पोज़ाकॉविरिस्टी के एक मठ के रूप में, चलो डेटाबेस में काम को मोनाड में लपेटते हैं:

 data class DB<A>(val f: (Connection) -> A) { fun <B> map(f: (A) -> B): DB<B> = flatMap { a -> lift(f(a)) } fun <B> flatMap(f: (A) -> DB<B>): DB<B> = DB { conn -> f(this.f(conn)).f(conn) } } fun <A> lift(value: A): DB<A> = DB { value } fun select(id: Int): DB<String> = DB { conn -> val st = conn.createStatement() // .... TODO() } fun update(value: String): DB<Unit> = DB { conn -> val st = conn.createStatement() // .... TODO() } fun selectThenUpdate(id: Int): DB<Unit> = select(id).flatMap { value -> update(value) } fun executeTransaction(c: Connection): Unit { //  ,     //          val body: DB<Unit> = selectThenUpdate(42) //  ,   select  update body.f(c) c.commit() } 

क्या खरगोश का छेद गहरा है?

भिक्षुओं की एक विशाल विविधता है, लेकिन उनका मुख्य उद्देश्य गणना के कुछ विवरणों से आवेदन के व्यापारिक तर्क को अलग करना है:

• वह मान मौजूद नहीं हो सकता है: data class Option<A>(value: A?)
• कि गणना विफल हो जाएगी: data class Either<Error, A>(value: Pair<Error?, A?>)
• यह गणना आलसी हो सकती है: data class Defer<A>(value: () -> A)
• या एसिंक्रोनस: java.util.concurrent.CompletableFuture<A>
• या एक कार्यात्मक राज्य है: data class State<S, A>(value: (S) -> Pair<S, A>)

अनुत्तरित प्रश्नों की सूची:

• एप्लाइड फ़ंक्शनलर्स - फ़ंक्शनलर्स और मोनाड्स के बीच एक मध्यवर्ती लिंक
• मठों की तरह संग्रह
• मोनोटाइपिक मोनोड की रचनाएं - तीर ग्लूसी, मोनैडिक ट्रांसफार्मर
• अनुक्रम / ट्रैवर्स
• प्रभाव के रूप में भिक्षुओं
• मोनाड्स और रिकर्सियन, स्टैक ओवरफ्लो, ट्रम्पोलिनिंग
• टैगलेस अंतिम एन्कोडिंग
• आयो मोनाद
• और आम तौर पर मानक साधुओं का पूरा चिड़ियाघर

आगे क्या है?

arrow-kt.io
typelevel.org/cats/typeclasses.html
wiki.haskell.org/All_About_Monads

मेरा प्रयोग स्काला पर एक पूर्ण एफपी शैली का अनुप्रयोग है:
github.com/scf37/fpscala2

पीएस मैं एक छोटा नोट चाहता था, यह हमेशा की तरह निकला।