किसी फ़ंक्शन से निरंतरता को अलग करता है?

Question

निरंतरता वर्णन करता है कि कुछ मूल्य के साथ क्या होता है, है ना? क्या यह एक ऐसा कार्य नहीं है जो मूल्य लेता है और कुछ गणना करता है?

(+ (* 2 3) 5) 

(* 2 3) की निरंतरता (+ _ 5)

(define k (lambda (v) (+ v 5))) 

है यहाँ में call/cc का उपयोग कर और समारोह k का उपयोग नहीं की बात क्या है?

Answer 1

सच। सभी कार्यक्रमों में निरंतरता होती है जब तक कि यह रोक नहीं जाता है। एक निरंतरता अंतर्निहित कार्यान्वयन द्वारा की गई गणना में आमतौर पर एक कदम है।

आपका उदाहरण:

(+ (* 2 3) 5) 

संयोजन + संयोजन पर निर्भर है * पहले खत्म करने के लिए है। इस प्रकार (+ result 5) वास्तव में (* 2 3) की निरंतरता है। हालांकि यह इस संदर्भ में एक प्रक्रिया नहीं है। call/cc की उपयोगिता तब होती है जब आपके पास निरंतरता होती है और आप इसके बजाय कुछ और करना चाहते हैं या आप बाद में इसे वापस आना चाहते हैं। चलो पहला कार्य करें:

(define g 0) 
(call/cc 
    (lambda (exit) 
    (/ 10 (if (= g 0) (exit +Inf.0) g)))) 

जाहिर है, वहाँ एक विभाग है जो निरंतरता है जब का परिणाम है, तो किया जाता है, लेकिन exit के बाद से पूरी बात कम + Inf.0 वापस जाने के लिए सर्किट हो जाता है चलाया जाता है।

आप इसे बाद में विभाजन करने के बिना प्रक्रिया के साथ कैसे करेंगे? इस शैली में, आप नहीं कर सकते।

यह वास्तव में जादू नहीं है क्योंकि योजना आपके कोड को Continuation Passing Style(=CPS) में परिवर्तित करती है और सीपीएस कॉल/सीसी में कोई विशेष नहीं है। यह सीपीएस में मामूली लेखन कोड नहीं है।

यहाँ call/cc

(define (kcall/cc k consumer) 
    (consumer k (lambda (ignore v) (k v)))) 

Answer 2

बधाई के सीपीएस परिभाषा है! आपने अभी निरंतरता-गुजरने वाली शैली का आविष्कार किया है! आपने जो किया है और call/cc के बीच एकमात्र अंतर यह है कि call/cc स्वचालित रूप से करता है, और आपको अपने कोड को पुन: स्थापित करने की आवश्यकता नहीं है।

Answer 3

ए 'निरंतरता' गणना का पूरा भविष्य है। गणना में प्रत्येक बिंदु में निरंतरता होती है, जो बेवकूफ शब्दों में, आप वर्तमान प्रोग्राम-काउंटर और वर्तमान स्टैक के रूप में सोच सकते हैं। योजना call/cc फ़ंक्शन आसानी से वर्तमान कॉन्फ़िगरेशन को कैप्चर करता है और इसे फ़ंक्शन में पैकेज करता है। जब आप उस फ़ंक्शन का आह्वान करते हैं तो आप गणना में उस बिंदु पर वापस लौट जाते हैं। इस प्रकार, एक समारोह से एक निरंतरता बहुत अलग होती है (लेकिन निरंतरता समारोह ठीक है, एक समारोह)।

1. गैर स्थानीय बाहर निकलें:

   दो आम मामलों में जहां एक आम तौर पर call/cc देखता लागू किया हैं। आप निरंतरता का आह्वान करते हुए गणना को अचानक समाप्त करने के लिए निरंतरता स्थापित करते हैं, कुछ गणना करते हैं।

2. एक गणना को पुनरारंभ/पुन: प्रस्तुत करें। इस मामले में आप निरंतरता को बचाते हैं और फिर कृपया इसे फिर से कॉल करें।यहाँ

   (begin 
       ;; do stuff 
       (call/cc (lambda (k) 
          ;; do more 
   
         ;; oops, must 'abort' 
         (k 'ignore))) 
       ;; continue on 
   ) 
   

   और मामले # 2 के लिए एक उदाहरण है::

यहाँ # 1 मामले के लिए एक उदाहरण है

> (define C#f) 
> (let ((x 10)) 
    (display (list (+ 1 (call/cc (lambda (k) (set! c k) x))) 111)) 
    (display " more")) 
(11 111) more 
> (c 20) 
(21 111) more 
> (c 90) 
(91 111) more 

के लिए यह # 2 मामले यह ध्यान देने योग्य है कि लायक है निरंतरता आपको शीर्ष-स्तर के पढ़ने-eval-print loop पर वापस लाती है - जो आपको इस उदाहरण में निरंतरता को दोबारा शुरू करने का मौका देती है!