एसआईसीपी chpt 4.1 के बारे में प्रश्न: कैसे (expr का विश्लेषण) तेजी से eval मदद करते हैं?

Question

मैं SICP के निम्न अनुभाग

http://mitpress.mit.edu/sicp/full-text/book/book-Z-H-26.html#%_sec_4.1.7

पाठ के अनुसार, eval के निम्नलिखित परिवर्तन में सुधार होगा एक प्रदर्शन में सुधार प्रदान करता है पढ़ रहा हूँ, एक अभिव्यक्ति कई बार का मूल्यांकन किया जाता है कि केवल एक बार विश्लेषण किया जाएगा के बाद से ?

(define (analyze-if exp) 
(let ((pproc (analyze (if-predicate exp))) 
    (cproc (analyze (if-consequent exp))) 
     (aproc (analyze (if-alternative exp)))) 
    (lambda (env) 
     (if (true? (pproc env)) 
      (cproc env) 
       (aproc env))))) 

मुझे समझ नहीं आता क्यों किताब का कहना है कि analyze केवल एक बार चलेंगे:

(define (eval exp env) 
    ((analyze exp) env)) 

यहाँ एक analyze समारोह पुस्तक में दी गई है। eval का शरीर नहीं है, जो ((analyze exp) env)) है मूल रूप से कहते हैं कि प्रत्येक बार eval कहा जाता है, analyze को इसके पैरामीटर के रूप में exp के साथ बुलाया जाएगा? इसका मतलब यह होगा कि analyze हर बार eval कहा जाता है।

मेरी समझ में क्या गलत है? मैं किसी भी प्रतिक्रिया की सराहना करता हूं, धन्यवाद!

Answer 1

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

Answer 2

गिंटौटास का जवाब सही है, लेकिन शायद एक उदाहरण क्रम में है। मान लीजिए कि आपने स्कीम बोली विकसित की है जो एक लूप निर्माण

(do-n-times n expr) 

स्पष्ट अर्थशास्त्र के साथ खेलता है। अब, जब आप एक पाश है कि दस बार

(eval '(do-n-times 10 (print 'hello))) 

चलाता है तो यह पाश शरीर में दस गुना का विश्लेषण करेगा मूल्यांकन करने के लिए अनुभवहीन eval कहते हैं। eval के संस्करण के साथ जो मूल्यांकन से मूल्यांकन को अलग करता है, लूप बॉडी analyze डी एक बार है, फिर दस बार मूल्यांकन किया जाता है।

विश्लेषण चरण एक प्रक्रिया देता है, जो आपकी योजना दुभाषिया में तेज़ हो सकता है या नहीं। हालांकि, यह सभी प्रकार के अनुकूलन (मृत कोड विश्लेषण, JIT compilation मशीन कोड आदि) को अनुमानित रूप से कर सकता है।

Answer 3

लार्समैन के उत्तर बेहद अच्छे हैं।

पूरक उत्तर के रूप में, analyze(environ) को eval(expr, environ) के एक करीबी रूप के रूप में भी देख सकते हैं जहां पैरामीटर expr समय से पहले पारित किया गया है।

(define (analyze-assignment exp) 
    (let ((var (assignment-variable exp)) 
     (vproc (analyze (assignment-value exp)))) 
    (lambda (env) 
     (set-variable-value! var (vproc env) env) 
     'ok))) 

जब आप एक let (([var] [preprocessed stuff])) देखते हैं, जो पूर्व प्रसंस्करण को बंद करने में संग्रहीत किया जा रहा है जब तक यह आवश्यक है बाद में जब environ में पारित हो जाता है

: SICP में, आप की तरह उदाहरण कोड पढ़ सकते हैं।