मैं कॉलसीसी के साथ क्या कर सकता हूं जो प्रतियोगिता के साथ नहीं किया जा सकता है?

मैं वास्तव में कॉलसीसी समझने के साथ वास्तव में संघर्ष कर रहा हूं। मुझे कंटीन्यू की शक्ति मिलती है और मैं अपने कुछ प्रोजेक्ट्स में कॉन्सेप्ट का इस्तेमाल कूल कॉन्सेप्ट बनाने में कर रहा हूं। लेकिन कभी भी मुझे इससे अधिक क्षमताओं के साथ कुछ का उपयोग करने की आवश्यकता नहीं है cont :: ((a->r)->r)-> Cont r a।

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

haskell functional-programming monads

— अलेजांद्रो नवस
स्रोत

आपने कैसे उपयोग किया है Cont? जब आप कहते हैं कि आपको कुछ अधिक शक्तिशाली उपयोग करने की आवश्यकता नहीं है cont, तो क्या इसका मतलब है कि आपने resetया shiftतो उपयोग नहीं किया है या नहीं?

— केए बुहर

मैंने इस्तेमाल नहीं किया है resetया shift। मैंने इसका उपयोग एक एंबेडेड भाषा को परिभाषित करने के लिए किया है जिसे तब तक निलंबित किया जा सकता है जब तक किसी दिए गए कार्य को किसी अन्य प्रक्रिया द्वारा हल नहीं किया जाता है, और फिर यह दिए गए "निरंतरता" के साथ फिर से शुरू होता है। शायद मैं कंट मोनाड के साथ बहुत अनुभव होने का आभास देता हूं, लेकिन वास्तव में ऐसा नहीं है, मैं वास्तव में कॉलसीसी को समझना चाहता हूं

— एलेजांद्रो नवस

callCC आपको "शुरुआती वापसी" शब्दार्थ प्रदान करता है, लेकिन एक विवादास्पद संदर्भ में।

कहते हैं कि आप चाहते थे doOne, और अगर वह रिटर्न देता है True, तो आप तुरंत रुक जाते हैं, अन्यथा आप पर जाते हैं doTwoऔर doThree:

doOne :: Cont r Bool
doTwo :: Cont r ()
doThree :: Cont r ()

doThings :: Cont r ()
doThings = do
    one <- doOne
    if one
        then pure ()
        else do
            doTwo
            doThree

उस ifशाखा को वहाँ देखें ? एक शाखा इतनी बुरी नहीं है, इससे निपटा जा सकता है, लेकिन कल्पना कीजिए कि ऐसे कई बिंदु हैं जहां आप बस जमानत चाहते हैं? यह बहुत जल्दी बदसूरत हो जाता है।

आपके साथ callCC"जल्दी वापसी" हो सकती है: आप ब्रांचिंग पॉइंट पर जमानत कर लेते हैं और बाकी कंपटीशन को नहीं छोड़ना पड़ता है:

doThings = callCC \ret -> do
    one <- doOne
    when one $ ret ()
    doTwo
    doThree

पढ़ने में बहुत अधिक सुखद!

इससे भी महत्वपूर्ण बात, क्योंकि retयहाँ एक विशेष वाक्यविन्यास नहीं है (जैसे returnसी-लाइक भाषाओं में), लेकिन किसी भी अन्य की तरह सिर्फ एक मूल्य, आप इसे अन्य कार्यों के लिए भी पास कर सकते हैं! और फिर वे फ़ंक्शन "गैर-स्थानीय रिटर्न" कहे जाने वाले प्रदर्शन कर सकते हैं - यानी वे doThingsगणना को "बंद" कर सकते हैं , यहां तक कि कई नोड्स कॉल से भी गहरा। उदाहरण के लिए, मैं इस तरह के doOneएक अलग समारोह में परिणाम की जाँच कर सकता है checkOne:

checkOne ret = do
    one <- doOne
    when one $ ret ()

doThings = callCC \ret -> do
    checkOne ret
    doTwo
    doThree

— फ्योडोर सोइकिन
स्रोत

मैं समझ गया! और bमूल रूप से सिर्फ एक वाइल्डकार्ड है ताकि आप कॉलसीसी के अंदर और अधिक निरंतरता को चेन कर सकें। वैसे भी, एक बार retलागू होने के बाद, कॉल cc द्वारा निर्मित निरंतरता जो कुछ भी डाला गया था, उसे "वापस" कर देगी ret। यह बहुत जटिल है, फिर भी बहुत स्मार्ट है, फिर भी बहुत शक्तिशाली है, मैं ऐसी बहुत सी जगहों को नहीं देखता जहाँ इस तरह की शक्ति का उपयोग करना एक मक्खी को मारने के लिए नहीं है, जैसे

— एलेजांद्रो नवीस

@ कैसियस ग्लैड I हेल्प। अगर आपको मेरा जवाब पसंद आया, तो क्या आप इसे स्वीकार करने पर विचार करेंगे?

— फ्योडोर सोइकिन