निरंतरता और कॉलबैक में क्या अंतर है?

Question

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

अब जब मुझे लगता है कि मैंने अंत में जारी रखा है कि मैं जानना चाहता हूं कि क्या मैं जानता हूं कि वास्तव में सच्चाई है। अगर मुझे लगता है कि वास्तव में सच नहीं है, तो यह अज्ञानता है और ज्ञान नहीं है।

तो, यहाँ मैं क्या जानता हूँ:

लगभग सभी भाषाओं में अपने कॉलर को स्पष्ट रूप से मान (और नियंत्रण) दिए जाते हैं। उदाहरण के लिए:

var sum = add(2, 3);

console.log(sum);

function add(x, y) {
    return x + y;
}

प्रथम श्रेणी के कार्यों वाली भाषा में अब हम नियंत्रण को वापस कर सकते हैं और कॉल करने वाले को वापस करने के बजाय कॉलबैक पर वापस आ सकते हैं:

add(2, 3, function (sum) {
    console.log(sum);
});

function add(x, y, cont) {
    cont(x + y);
}

इस प्रकार एक फ़ंक्शन से मान वापस करने के बजाय हम दूसरे फ़ंक्शन के साथ जारी रख रहे हैं। इसलिए इस फ़ंक्शन को पहले की निरंतरता कहा जाता है।

तो निरंतरता और कॉलबैक में क्या अंतर है?

Comments

मेरे एक हिस्से को लगता है कि यह वास्तव में एक अच्छा सवाल है और मेरे एक हिस्से को लगता है कि यह बहुत लंबा है और शायद इसका परिणाम केवल 'हां / नहीं' में है। हालांकि प्रयास और अनुसंधान के कारण मैं अपनी पहली भावना के साथ जा रहा हूं।

— एंड्रास जोल्तान

आपका सवाल क्या हैं? लगता है कि आप इसे अच्छी तरह समझते हैं।

— माइकल आरोन सफाई

हाँ मैं सहमत हूँ - मुझे लगता है कि यह संभवतः '' जावास्क्रिप्ट कंटीन्यूज़ेशन - जो मैं उन्हें समझता हूँ '' की तर्ज पर एक ब्लॉग पोस्ट होना चाहिए था।

— एंड्रास जोल्तान

खैर, एक आवश्यक प्रश्न है: "तो एक निरंतरता और कॉलबैक के बीच क्या अंतर है?", इसके बाद "मुझे विश्वास है ..."। उस सवाल का जवाब दिलचस्प हो सकता है?

— कन्फ्यूजन

ऐसा लगता है कि यह और अधिक उचित रूप से programmers.stackexchange.com पर पोस्ट किया जा सकता है।

— ब्रायन रिस्किल

Answer 1

मेरा मानना ​​है कि निरंतरता कॉलबैक का एक विशेष मामला है। एक फ़ंक्शन किसी भी संख्या में फ़ंक्शन, किसी भी समय कॉलबैक कर सकता है। उदाहरण के लिए:

var array = [1, 2, 3];

forEach(array, function (element, array, index) {
    array[index] = 2 * element;
});

console.log(array);

function forEach(array, callback) {
    var length = array.length;
    for (var i = 0; i < length; i++)
        callback(array[i], array, i);
}

हालाँकि यदि कोई फ़ंक्शन किसी अन्य फ़ंक्शन को अंतिम चीज़ के रूप में वापस करता है तो वह दूसरा फ़ंक्शन पहले की निरंतरता कहलाता है। उदाहरण के लिए:

var array = [1, 2, 3];

forEach(array, function (element, array, index) {
    array[index] = 2 * element;
});

console.log(array);

function forEach(array, callback) {
    var length = array.length;

    // This is the last thing forEach does
    // cont is a continuation of forEach
    cont(0);

    function cont(index) {
        if (index < length) {
            callback(array[index], array, index);
            // This is the last thing cont does
            // cont is a continuation of itself
            cont(++index);
        }
    }
}

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

बोनस : निरंतरता की शैली में आगे बढ़ना। निम्नलिखित कार्यक्रम पर विचार करें:

console.log(pythagoras(3, 4));

function pythagoras(x, y) {
    return x * x + y * y;
}

अब अगर हर ऑपरेशन (इसके अलावा, गुणा, आदि) को कार्यों के रूप में लिखा गया था, तो हमारे पास होगा:

console.log(pythagoras(3, 4));

function pythagoras(x, y) {
    return add(square(x), square(y));
}

function square(x) {
    return multiply(x, x);
}

function multiply(x, y) {
    return x * y;
}

function add(x, y) {
    return x + y;
}

इसके अलावा अगर हमें किसी भी मान को वापस करने की अनुमति नहीं थी, तो हमें निरंतरता का उपयोग करना होगा:

pythagoras(3, 4, console.log);

function pythagoras(x, y, cont) {
    square(x, function (x_squared) {
        square(y, function (y_squared) {
            add(x_squared, y_squared, cont);
        });
    });
}

function square(x, cont) {
    multiply(x, x, cont);
}

function multiply(x, y, cont) {
    cont(x * y);
}

function add(x, y, cont) {
    cont(x + y);
}

प्रोग्रामिंग की यह शैली जिसमें आपको मूल्यों को वापस करने की अनुमति नहीं है (और इसलिए आपको पास के निरंतरता का सहारा लेना चाहिए) को निरंतरता शैली कहा जाता है।

हालांकि निरंतरता शैली के साथ दो समस्याएं हैं:

1. निरंतरता के आसपास गुजरने से कॉल स्टैक का आकार बढ़ जाता है। जब तक आप किसी भाषा जैसी योजना का उपयोग नहीं कर रहे हैं जो टेल कॉल को समाप्त कर देती है तो आपको स्टैक स्पेस से बाहर निकलने का जोखिम होगा।
2. यह नेस्टेड फ़ंक्शन लिखने के लिए एक दर्द है।

निरंतरता को अतुल्यकालिक रूप से कॉल करके जावास्क्रिप्ट में पहली समस्या को आसानी से हल किया जा सकता है। कॉल को जारी रखने से पहले एसिंक्रोनस रूप से फ़ंक्शन को अतुल्यकालिक रूप से कॉल करके। इसलिए कॉल स्टैक का आकार नहीं बढ़ता है:

Function.prototype.async = async;

pythagoras.async(3, 4, console.log);

function pythagoras(x, y, cont) {
    square.async(x, function (x_squared) {
        square.async(y, function (y_squared) {
            add.async(x_squared, y_squared, cont);
        });
    });
}

function square(x, cont) {
    multiply.async(x, x, cont);
}

function multiply(x, y, cont) {
    cont.async(x * y);
}

function add(x, y, cont) {
    cont.async(x + y);
}

function async() {
    setTimeout.bind(null, this, 0).apply(null, arguments);
}

दूसरी समस्या आमतौर पर एक फ़ंक्शन का उपयोग करके हल की call-with-current-continuationजाती है जिसे अक्सर संक्षिप्त रूप में देखा जाता है callcc। दुर्भाग्य से callccजावास्क्रिप्ट में पूरी तरह से लागू नहीं किया जा सकता है, लेकिन हम इसके अधिकांश उपयोग मामलों के लिए एक प्रतिस्थापन कार्य लिख सकते हैं:

pythagoras(3, 4, console.log);

function pythagoras(x, y, cont) {
    var x_squared = callcc(square.bind(null, x));
    var y_squared = callcc(square.bind(null, y));
    add(x_squared, y_squared, cont);
}

function square(x, cont) {
    multiply(x, x, cont);
}

function multiply(x, y, cont) {
    cont(x * y);
}

function add(x, y, cont) {
    cont(x + y);
}

function callcc(f) {
    var cc = function (x) {
        cc = x;
    };

    f(cc);

    return cc;
}

callccसमारोह एक समारोह लेता है fऔर करने के लिए इसे लागू होता है current-continuation(के रूप में संक्षिप्त cc)। current-continuationएक निरंतरता समारोह जो करने के लिए कॉल के बाद समारोह शरीर के बाकी ऊपर लपेटता है callcc।

फ़ंक्शन के मुख्य भाग पर विचार करें pythagoras:

var x_squared = callcc(square.bind(null, x));
var y_squared = callcc(square.bind(null, y));
add(x_squared, y_squared, cont);

current-continuationदूसरे की callccहै:

function cc(y_squared) {
    add(x_squared, y_squared, cont);
}

इसी तरह current-continuationपहले का callccहै:

function cc(x_squared) {
    var y_squared = callcc(square.bind(null, y));
    add(x_squared, y_squared, cont);
}

चूंकि current-continuationपहले callccमें एक और सम्‍मिलित है, callccइसे निरंतरता गुजर शैली में परिवर्तित किया जाना चाहिए:

function cc(x_squared) {
    square(y, function cc(y_squared) {
        add(x_squared, y_squared, cont);
    });
}

तो अनिवार्य callccरूप से तार्किक रूप से पूरे फ़ंक्शन बॉडी को वापस वही करता है जो हमने शुरू किया था (और उन अनाम कार्यों को नाम देता है cc)। पाइकगोरस फंक्शन का उपयोग करते हुए कॉलक का यह कार्यान्वयन तब बन जाता है:

function pythagoras(x, y, cont) {
    callcc(function(cc) {
        square(x, function (x_squared) {
            square(y, function (y_squared) {
                add(x_squared, y_squared, cont);
            });
        });
    });
}

फिर से आप callccजावास्क्रिप्ट में लागू नहीं कर सकते हैं , लेकिन आप इसे जावास्क्रिप्ट में जारी रखने की शैली को निम्नानुसार लागू कर सकते हैं:

Function.prototype.async = async;

pythagoras.async(3, 4, console.log);

function pythagoras(x, y, cont) {
    callcc.async(square.bind(null, x), function cc(x_squared) {
        callcc.async(square.bind(null, y), function cc(y_squared) {
            add.async(x_squared, y_squared, cont);
        });
    });
}

function square(x, cont) {
    multiply.async(x, x, cont);
}

function multiply(x, y, cont) {
    cont.async(x * y);
}

function add(x, y, cont) {
    cont.async(x + y);
}

function async() {
    setTimeout.bind(null, this, 0).apply(null, arguments);
}

function callcc(f, cc) {
    f.async(cc);
}

फ़ंक्शन callccका उपयोग जटिल नियंत्रण प्रवाह संरचनाओं को लागू करने के लिए किया जा सकता है जैसे कि ट्राई-कैच ब्लॉक, कोरटाइन, जनरेटर, फाइबर आदि।

Comments

मैं बहुत आभारी हूँ शब्दों का वर्णन नहीं कर सकता हूँ। मैं अंत में अंतर्ज्ञान स्तर पर एक स्वीप में सभी निरंतरता से संबंधित अवधारणाओं को समझ गया! मैंने एक बार नया क्लिक किया था, यह सरल होने जा रहा था और मैं देखूंगा कि मैंने अनजाने से पहले पैटर्न का कई बार उपयोग किया था, और यह ऐसा ही था। अद्भुत और स्पष्ट स्पष्टीकरण के लिए बहुत बहुत धन्यवाद।

— एटा

Trampolines काफी सरल हैं, फिर भी शक्तिशाली सामान हैं। कृपया उनके बारे में रेजिनाल्ड ब्रेथवेट की पोस्ट देखें ।

— मार्को फौस्टिनेली

जवाब के लिए धन्यवाद। मुझे आश्चर्य है कि क्या आप संभवतः उस कथन के लिए अधिक समर्थन प्रदान कर सकते हैं जो कॉलक जावास्क्रिप्ट में लागू नहीं किया जा सकता है? संभवतः जावास्क्रिप्ट इसे लागू करने के लिए क्या आवश्यकता होगी की एक व्याख्या?

— जॉन हेनरी

@ जॉनहेनरी - ठीक है, वास्तव में मैट मेक द्वारा किया गया जावास्क्रिप्ट में एक कॉल / सीसी कार्यान्वयन है (मैट. might.net/articles/by-example-continuation-passing-style - बहुत अंतिम पैराग्राफ पर जाएं), लेकिन कृपया डॉन करें ' t मुझसे पूछें कि यह कैसे काम करता है और न ही इसका उपयोग कैसे करना है :-)

— Marco Faustinelli

@ जॉनहेनरी जेएस को प्रथम श्रेणी में निरंतरता (कॉल स्टैक के कुछ राज्यों को पकड़ने के लिए एक तंत्र के रूप में सोचना) की आवश्यकता होगी। लेकिन इसमें केवल फर्स्ट क्लास फ़ंक्शंस और क्लोजर हैं, इस प्रकार सीपीएस निरंतरता की नकल करने का एकमात्र तरीका है। स्कीम प्रतियोगिता में निहित हैं और कॉलक की नौकरी का एक हिस्सा इन निहित दावों को "पुनरीक्षित" करना है, ताकि उपभोग कार्य उनके पास पहुंच जाए। यही कारण है कि Callcc in Scheme एक फ़ंक्शन को एकमात्र तर्क की उम्मीद करता है। JS में Callcc का CPS संस्करण अलग है, क्योंकि यह प्रतियोगिता एक स्पष्ट फ़ेक तर्क के रूप में पारित की गई है। इसलिए बहुत सारे अनुप्रयोगों के लिए Aadit का कॉलक पर्याप्त है।

— स्क्रिप्टम

Answer 2

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

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

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

Comments

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

— आदित एम शाह

@AaditMShah हाँ, मुझे वहाँ याद आती है। एक निरंतरता को एक फ़ंक्शन (या प्रक्रिया जैसा कि मैंने कहा था) होने की आवश्यकता नहीं है। परिभाषा के अनुसार यह अभी आने वाली चीजों का सार प्रतिनिधित्व है। हालाँकि, स्कीम में भी एक प्रक्रिया की तरह एक निरंतरता को लागू किया जाता है और एक के रूप में इसे पास किया जाता है। हम्म .. यह समान रूप से दिलचस्प सवाल उठाता है कि एक निरंतरता क्या दिखती है जो फ़ंक्शन / प्रक्रिया नहीं है।

— dcow

@AaditMShah काफी दिलचस्प है कि मैंने यहाँ चर्चा जारी रखी है: programmers.stackexchange.com/questions/212057/…

— dcow

Answer 3

संक्षिप्त उत्तर यह है कि एक निरंतरता और एक कॉलबैक के बीच का अंतर यह है कि कॉलबैक लागू होने के बाद (और समाप्त हो गया है) निष्पादन उसी बिंदु पर शुरू होता है, जिस पर इसे लागू किया गया था, जबकि एक निरंतरता को लागू करने से उस बिंदु पर फिर से शुरू होने के लिए निष्पादन का कारण बनता है। दूसरे शब्दों में: एक निरंतरता कभी नहीं लौटती है ।

फ़ंक्शन पर विचार करें:

function add(x, y, c) {
    alert("before");
    c(x+y);
    alert("after");
}

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

अब, यदि हम इसे कॉलबैक पास करते हैं:

add(2, 3, function (sum) {
    alert(sum);
});

फिर हम तीन अलर्ट देखेंगे: "पहले", "5" और "बाद"।

दूसरी ओर, अगर हम इसे एक निरंतरता के रूप में पारित करते हैं जो कॉलबैक के समान काम करता है, तो इस तरह:

alert(callcc(function(cc) {
    add(2, 3, cc);
}));

तब हम केवल दो अलर्ट देखेंगे: "पहले" और "5"। लागू c()अंदर add()समाप्त होता है के निष्पादन add()और कारणों callcc()वापसी करने के लिए; मान द्वारा लौटाया गया मान (यानी, योग) callcc()के तर्क के रूप में पारित किया गया था c।

इस अर्थ में, भले ही एक निरंतरता को लागू करना एक फ़ंक्शन कॉल की तरह दिखता है, यह कुछ मायनों में रिटर्न स्टेटमेंट के लिए अधिक समान है या अपवाद फेंक रहा है।

वास्तव में, कॉल / cc का उपयोग उन भाषाओं में रिटर्न स्टेटमेंट जोड़ने के लिए किया जा सकता है जो उनका समर्थन नहीं करते हैं। उदाहरण के लिए, यदि जावास्क्रिप्ट में रिटर्न स्टेटमेंट नहीं था (इसके बजाय, कई लिप्स भाषाओं की तरह, केवल फंक्शन बॉडी में अंतिम एक्सप्रेशन का मान लौटाते हुए), लेकिन कॉल / cc था, तो हम इस तरह से रिटर्न लागू कर सकते हैं:

function find(myArray, target) {
    callcc(function(return) {
        var i;
        for (i = 0; i < myArray.length; i += 1) {
            if(myArray[i] === target) {
                return(i);
            }
        }
        return(undefined); // Not found.
    });
}

कॉलिंग return(i)एक निरंतरता को आमंत्रित करता है जो गुमनाम फ़ंक्शन के निष्पादन को समाप्त करता है और callcc()उस सूचकांक को वापस करने का कारण बनता है iजिस targetपर पाया गया था myArray।

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

कॉल / cc को इसी तरह अपवाद हैंडलिंग (थ्रो एंड ट्राई / कैच), लूप और कई अन्य कंटोल संरचनाओं को लागू करने के लिए इस्तेमाल किया जा सकता है।

कुछ संभावित गलतफहमी को दूर करने के लिए:

• प्रथम श्रेणी की निरंतरताओं का समर्थन करने के लिए टेल कॉल अनुकूलन किसी भी तरह से आवश्यक नहीं है। विचार करें कि यहां तक ​​कि सी भाषा के रूप में निरंतरताओं का एक (प्रतिबंधित) रूप है setjmp(), जो एक निरंतरता बनाता है, और longjmp(), जो एक को आमंत्रित करता है!

  • दूसरी ओर, यदि आप पूंछ कॉल अनुकूलन के बिना निरंतरता से गुजरने की शैली में अपने कार्यक्रम को लिखने की कोशिश करते हैं, तो आप अंततः स्टैक को ओवरफ्लो करने के लिए बर्बाद हो जाते हैं।

• कोई विशेष कारण नहीं है कि एक निरंतरता के लिए केवल एक तर्क की आवश्यकता है। यह सिर्फ तर्क (नों) को जारी रखने के लिए कॉल / cc का रिटर्न वैल्यू है, और कॉल / cc को आमतौर पर सिंगल रिटर्न वैल्यू के रूप में परिभाषित किया जाता है, इसलिए स्वाभाविक रूप से निरंतरता को बिल्कुल एक होना चाहिए। कई रिटर्न वैल्यू (जैसे कॉमन लिस्प, गो, या वास्तव में स्कीम) के समर्थन वाली भाषाओं में यह पूरी तरह से संभव होगा जिसमें कई मानों को स्वीकार किया जाए।

Comments

क्षमा याचना अगर मैंने जावास्क्रिप्ट उदाहरणों में कोई त्रुटि की है। इस उत्तर को लिखने से जावास्क्रिप्ट की कुल मात्रा दोगुनी हो गई है।

— cpcallen

क्या मैं सही ढंग से समझता हूं कि आप इस उत्तर में अविभाजित निरंतरता के बारे में बात कर रहे हैं, और स्वीकृत उत्तर वार्ता निरन्तर जारी है?

— जोजफ मिकुसिनेक

"निरंतरता को लागू करने से उस बिंदु पर फिर से शुरू होने के लिए निष्पादन शुरू हो जाता है" - मुझे लगता है कि आप वर्तमान निरंतरता पर कब्जा करने के साथ एक निरंतरता बनाने "भ्रमित" कर रहे हैं ।

— एलेक्सी

@Alexey: यह एक प्रकार का पेडेंट्री है जिसे मैं मंजूरी देता हूं। लेकिन अधिकांश भाषाएँ वर्तमान निरंतरता को कैप्चर करने के अलावा (reified) निरंतरता बनाने का कोई तरीका प्रदान नहीं करती हैं।

— cpcallen

@jozef: मैं निश्चित रूप से अविवादित निरंतरताओं के बारे में बात कर रहा हूं। मुझे लगता है कि एडिट का इरादा भी था, हालांकि डीपीसी नोट स्वीकार किए गए उत्तर को (बारीकी से संबंधित) टेल कॉल से निरंतरता को भेद करने में विफल रहता है, और मैं ध्यान देता हूं कि एक सीमांकित निरंतरता किसी भी तरह से एक fuction / प्रक्रिया के बराबर है: community.scubewiki.org/ ?

— कंपोजेबल