योजना

Question

में अंतर और चलो * के बीच अंतर से उलझन में कोई भी अंतर को समझा सकता है? मुझे नहीं लगता कि मैं उन पाठ्यपुस्तकों/साइटों से अवधारणा को समझता हूं जिनसे मैंने परामर्श किया है।

Answer 1

यदि आप let का उपयोग करते हैं, तो आप पहले let अभिव्यक्ति में परिभाषित बाइंडिंग का संदर्भ नहीं दे सकते। उदाहरण के लिए, इस काम करेंगे नहीं:

(let ((x 10) 
     (y (+ x 6))) ; error! unbound identifier in module in: x 
    y) 

लेकिन अगर आप let* उपयोग करते हैं, यह एक ही let* अभिव्यक्ति में पिछले बाइंडिंग का उल्लेख किया जा सकता है:

(let* ((x 10) 
     (y (+ x 6))) ; works fine 
    y) 
=> 16 

यह दस्तावेज में सभी here है।

Answer 2

Let समानांतर है, ^{(एक तरह से, नीचे देखें)}let* अनुक्रमिक है। Let रूप

((lambda(a b c) ... body ...) 
    a-value 
    b-value 
    c-value) 

लेकिन let* रूप

((lambda(a) 
    ((lambda(b) 
     ((lambda(c) ... body ...) 
     c-value)) 
    b-value)) 
    a-value) 

तब्दील हो और इस तरह नेस्टेड गुंजाइश ब्लॉक पैदा कर रही है जहां b-value अभिव्यक्ति a का उल्लेख कर सकते हैं, और c-value अभिव्यक्ति b और a दोनों का उल्लेख कर सकते। a-value बाहरी दायरे से संबंधित है। यह भी

(let ((a a-value)) 
    (let ((b b-value)) 
    (let ((c c-value)) 
     ... body ...))) 

के बराबर है, यह भी letrec नहीं है पुनरावर्ती बाइंडिंग, जहां सभी चर और भाव एक साझा दायरे से संबंध रखते हैं और (प्रारंभ से संबंधित कुछ कैविएट्स के साथ) एक दूसरे के लिए उल्लेख कर सकते हैं के लिए अनुमति देता है। यह (भी, के रूप में letrec* योजना में उपलब्ध R6RS के बाद से in Racket)

(let ((a *undefined*) (b *undefined*) (c *undefined*)) 
    (set! a a-value) 
    (set! b b-value) 
    (set! c c-value) 
    ... body ...) 

के लिए या तो बराबर है, या

(let ((a *undefined*) (b *undefined*) (c *undefined*)) 
    (let ((_x_ a-value) (_y_ b-value) (_z_ c-value)) ; unique identifiers 
    (set! a _x_) 
    (set! b _y_) 
    (set! c _z_) 
    ... body ...)) 

(in Scheme) करने के लिए।

अद्यतन: let वास्तव में समानांतर में अपने मूल्य-अभिव्यक्तियों का मूल्यांकन नहीं करता है, यह सिर्फ इतना है कि उनका मूल्यांकन उसी प्रारंभिक माहौल में किया जाता है जहां let प्रपत्र प्रकट होता है। यह भी lambda आधारित अनुवाद से स्पष्ट है: पहला मान भाव प्रत्येक मूल्यांकन किया जाता है एक ही है, बाहरी वातावरण में, और जिसके परिणामस्वरूप मूल्यों एकत्र कर रहे हैं, और केवल तो नए स्थानों प्रत्येक आईडी के लिए बनाई गई हैं और मान प्रत्येक स्थान पर रखे जाते हैं। हम तब भी अनुक्रमिकता देख सकते हैं यदि मूल्य-अभिव्यक्तियों में से कोई एक स्टोरेज (यानी डेटा, एक सूची या संरचना जैसे) को बाद में एक्सेस करता है।