फ़ंक्शन इंस्टेंस के बाइंड/>> = की व्याख्या कैसे करें?

Question

मैं जावास्क्रिप्ट में अपने फ़ंक्शन इंस्टेंस को कार्यान्वित करके Applicative s और Monads की मेरी समझ में सुधार करने की कोशिश कर रहा हूं। हास्केल का मेरा ज्ञान सीमित है और मुझे उम्मीद है कि मेरा प्रश्न बिल्कुल समझ में आता है।

यहाँ जावास्क्रिप्ट में fmap, <*> और >>=Functor, Applicative और Monad typeclasses के लिए की मेरी कार्यान्वयन हैं:

:

const fmap = f => g => x => f(g(x)); // B combinator 
const apply = f => g => x => f(x) (g(x)); // S combinator 
const bind = f => g => x => g(f(x)) (x); // ? 

मुझे यकीन है कि है कि क्या bind हास्केल कार्यान्वयन के सही अनुवाद है नहीं कर रहा हूँ

(>>=) :: (r -> a) -> (a -> (r -> b)) -> r -> b 

instance Monad ((->) r) where 
f >>= k = \ r -> k (f r) r 

प्रदान किया गया कि bind सही है, इसका अर्थ कैसे है? मुझे पता है कि Applicative प्रभावशाली गणनाओं का अनुक्रम कर सकता है। मुझे यह भी पता है कि Monad इसके अलावा आप पिछले एक के परिणाम के अनुसार एक अगला प्रभाव निर्धारित करने की अनुमति देता है।

• apply:

  मैं दृश्यों (जावास्क्रिप्ट में उत्सुक मूल्यांकन आदेश) देख सकते हैं f(x) ... g(result of f): f(x) ... g(x) ... lambda(result of g) ... lambda

• bind का परिणाम ... lambda(x) ... lambda

हालांकि का परिणाम है, bind मज़ा कथन बहुत अजीब लग रहा है। f और g अन्य तरीकों से घोंसला क्यों हैं? इस कार्यान्वयन में विशिष्ट Monad व्यवहार (पिछले एक के अनुसार अगला प्रभाव निर्धारित करता है) कैसा है? वास्तव में g(f(x)) (x) फ़्लिप किए गए तर्कों के साथ एक फ़ंक्शन संरचना की तरह दिखता है, जहां g एक बाइनरी फ़ंक्शन है।

जब मैं apply/bind को एक यूनरी और बाइनरी फ़ंक्शन के साथ लागू करता हूं, तो वे एक ही परिणाम प्राप्त करते हैं। यह ज्यादा समझ में नहीं आता है।

Answer 1

फ़ंक्शंस के लिए मोनैड इंस्टेंस में मानों में कुछ निश्चित प्रकार r के लिए r -> a टाइप करें। (>>=) को दिए गए फ़ंक्शन (a -> (r -> b)) आपको वर्तमान मान से परिणाम देने के लिए अगला फ़ंक्शन चुनने की अनुमति देता है (एक फ़ंक्शन r -> a)। f r में a और k (f r) टाइप r -> b है जो लागू करने के लिए अगला कार्य है।

आपके कोड में g(f(x)) इसलिए एक ऐसा फ़ंक्शन है जो r प्रकार के एक तर्क की अपेक्षा करता है। bind का कॉलर पिछले फ़ंक्शन द्वारा दिए गए मान के आधार पर इस फ़ंक्शन को चुन सकता है उदा।

var inc = x => x + 1; 
var f = bind(inc)(function(i) { 
    if(i <= 5) { return x => x * 2; } 
    else { return x => x * 3; } 
}); 

समारोह x एक इनपुट के रूप दिया जाएगा और inc(x) उदा का परिणाम के आधार पर गणना में अगले चरण के लिए चुन सकते हैंली की जवाब देने के लिए

f(2) //4; 
f(5) //15; 

Answer 2

कुछ फ़ुटनोट:

हालांकि, bind समारोह बहुत अजीब लग रहा है। f और g अन्य तरीकों से घोंसला क्यों हैं?

क्योंकि bind पीछे की तरफ है। (>>=) तुलना करें और अपनी फ़्लिप संस्करण :

(>>=) :: Monad m => m a -> (a -> m b) -> m b 
(=<<) :: Monad m => (a -> m b) -> m a -> m b 

या, अपने विशिष्ट उदाहरण में:

(>>=) :: (r -> a) -> (a -> (r -> b)) -> (r -> b) 
(=<<) :: (a -> (r -> b)) -> (r -> a) -> (r -> b) 

व्यवहार में जब तक हम से कैसे (>>=), वाक्य रचना बोल की वजह से अधिक बार (>>=) का उपयोग करते हैं, उधार देता इसे लिखने का सबसे स्वाभाविक तरीका है, जो कि सैद्धांतिक दृष्टिकोण से, पाइपलाइन मोनैड्स के निर्माण के लिए अक्सर उपयोग किया जाता है। विशेष रूप से, समानताएं और fmap/(<$>) और (<*>) के साथ मतभेद और अधिक स्पष्ट कर रहे हैं:

(<$>) :: Functor f  => (a -> b) -> f a -> f b 
(<*>) :: Applicative f => f (a -> b) -> f a -> f b 
(=<<) :: Monad f  => (a -> f b) -> f a -> f b 

जब मैं एक एकल और एक द्विआधारी समारोह के साथ apply/bind लागू होते हैं, वे एक ही परिणाम उपज। यह ज्यादा समझ में नहीं आता है।

यह फ़ंक्शन उदाहरणों के बारे में एक आकस्मिक तथ्य है। की ओर से विशेष हस्ताक्षर पक्ष रखते हैं:

(<*>) :: (r -> (a -> b)) -> (r -> a) -> (r -> b) 
(=<<) :: (a -> (r -> b)) -> (r -> a) -> (r -> b) 

MonadApplicative से परे चला जाता साधन प्रदान पिछले परिणाम के अनुसार अगले प्रभाव का निर्धारण करने के (के रूप में "पिछले प्रभाव" के लिए विरोध द्वारा - Applicative कर सकते हैं कि पहले से ही)। प्रभाव, इस मामले में, एक ऐसा फ़ंक्शन होता है जो r प्रकार के तर्क के मानों को उत्पन्न करता है। अब, चूंकि कई तर्कों (यानी फ़ंक्शंस जो फ़ंक्शन लौटाते हैं) के साथ फ़ंक्शन फ़्लिप किए जा सकते हैं, ऐसा होता है कि (r -> (a -> b)) और (a -> (r -> b)) (flip के बीच कोई महत्वपूर्ण अंतर नहीं हो सकता है), जो Monad उदाहरण (->) r के बराबर समकक्ष बनाता है Applicative पर एक।