TypeScript के साथ Functor, Applicative Functor और Monad को समझना

पाठ

• Functor के map से हल न होने वाली दो समस्याओं से शुरुआत करते हुए—कंटेनर के अंदर फंक्शन के फँस जाने की समस्या और composition के समय context nesting की समस्या—TypeScript कोड के जरिए Applicative Functor और Monad तक पहुँचने की प्रक्रिया समझाई गई है
• 1988 में Eugenio Moggi ने प्रोग्राम को A → B की बजाय A → T(B) के रूप में मॉडल किया, इस पृष्ठभूमि से चर्चा शुरू होती है
• flatMap = map + join जैसी संरचना और इसे सुरक्षित रूप से इस्तेमाल करने के लिए तीन नियमों—associativity, left identity, right identity—पर चर्चा की गई है
• Monad को "endomorphism category में monoid object" क्यों कहा जाता है, इसे integer addition के monoid के मुकाबले समझाया गया है
• यह भी बताया गया है कि Promise monadic तरीके से काम करता है, लेकिन सख्त गणितीय अर्थ में Monad नहीं है

Functor की सीमाएँ: map से जो नहीं हो सकता

• Curried function को map से apply करने पर परिणाम Maybe<(b: number) => number> जैसा हो जाता है, यानी फंक्शन कंटेनर के अंदर फँस जाता है
  • map केवल कंटेनर के बाहर के function को ही ले सकता है, इसलिए अंदर फँसे function को किसी दूसरे value पर apply करने का तरीका नहीं होता
• Functor लौटाने वाले दो functions को compose करने पर Maybe<Maybe> जैसी context nesting हो जाती है
  • जैसे-जैसे चरण बढ़ते हैं, यह Maybe<Maybe<Maybe<...>>> की अनंत nesting में बदल सकता है

Applicative Functor: कंटेनर के अंदर के function को apply करना

• apply operation के जरिए कंटेनर के अंदर फँसे function को दूसरे कंटेनर के value पर apply किया जा सकता है
  • apply: T<(A → B)> → T<A> → T<B>
• pure operation के जरिए pure value को कंटेनर में डाला जाता है
• सीमा: किन कंटेनरों को compose करना है, यह पहले से तय होना चाहिए
  • पिछले computation के परिणाम को देखकर अगला computation तय करने वाली dynamic sequential dependency को व्यक्त नहीं किया जा सकता

Monad: nesting को flatten करने वाले operation का आविष्कार

• join operation T<T<A>> → T<A> के रूप में double container को single container में flatten कर देता है
  • JavaScript का Array.prototype.flat यही काम करता है
• व्यवहार में map + join को मिलाकर बने flatMap का उपयोग किया जाता है
  • flatMap: T<A> → (A → T<B>) → T<B>
  • map जहाँ A → B लेता है, वहीं flatMap A → T<B> लेता है, इसलिए परिणाम एक ही layer में बना रहता है

flatMap के तीन नियम

• associativity rule: T(T(T(A))) जैसी triple nesting को flatten करते समय, अंदर से flatten करें या बाहर से, परिणाम समान होना चाहिए
  • m.flatMap(f).flatMap(g) === m.flatMap(x => f(x).flatMap(g))
• left identity rule: pure से value डालकर तुरंत flatMap करें, तो परिणाम function को सीधे apply करने जैसा ही होना चाहिए
  • pure(a).flatMap(f) === f(a)
• right identity rule: flatMap में pure देने पर वही मूल कंटेनर वापस मिलना चाहिए
  • m.flatMap(pure) === m

"endomorphism category में monoid object" को खोलकर समझना

• प्रोग्रामिंग में Functor type world से type world की ओर जाता है, इसलिए वह endofunctor है
• ऐसे endofunctors को ही objects मानकर endofunctor category बनाई जा सकती है
• monoid की शर्तें (binary operation + associativity + identity element) इसमें रखने पर:
  • binary operation = join
  • identity element = pure
  • यह संरचना integer addition के monoid से ठीक-ठीक मेल खाती है

Promise Monad क्यों नहीं है

• then return value के अनुसार map और flatMap को मिलाकर संभालता है
• Promise<Promise> जैसी स्थिति runtime में रहने नहीं दी जाती और तुरंत एक single layer में merge हो जाती है
• व्यवहारिक रूप से यह सुविधाजनक है, लेकिन गणितीय Monad laws को संतुष्ट नहीं करता

[calofmijuck]

कृपया Comonad को भी कवर करें!

[bboydart91]

अरे... इस पर सोचूँगा हाहाहा