में लेट SICP 1.2.1 में के बजाय का उपयोग कर वहाँ इस प्रकार, एक समारोह एक तर्कसंगत संख्या बनाता है:लैम्ब्डा योजना
(define (make-rat n d)
(let ((g (gcd n d)))
(cons (/ n g) (/ d g))))
मैं सिर्फ उत्सुक कैसे आप के बजाय लैम्ब्डा का उपयोग कर एक ही बात लागू कर सकते हैं कर रहा हूँ जीसीडी को दो बार बुलाए बिना चलो। मैं इसे खुद समझ नहीं पाया।
SICP section 1.3.2 को देखते हुए,
(let ((<var1> <exp1>)
(<var2> <exp2>)
...
(<varn> <expn>))
<body>)
((lambda (<var1> ...<varn>)
<body>)
<exp1>
...
<expn>)
तो अपने प्रक्रिया,
(define (make-rat n d)
(let ((g (gcd n d)))
(cons (/ n g) (/ d g))))
(define (make-rat n d)
((lambda (g)
(cons (/ n g) (/ d g)))
(gcd n d)))
ये दोनों बातें एक ही हैं:
((lambda (p1 p2...) body) v1 v2...)
और
(let ((p1 v1) (p2 v2)...) body)
(define-syntax let-as-lambda
(syntax-rules()
((_ (x value) body)
(let ((x value))
body))))
(printf "~s~n" (let-as-lambda (x 1) (+ x 1)))
के बराबर होना चाहिए हमें दो साधारण मामलों की जांच ताकि हम समझ सकते हैं कि कैसे हम किसी भी समारोह लैम्ब्डा के साथ जाने का उपयोग करता है पुनर्लेखन कर सकते हैं:
हमारे पहले मामले में हमारे पास एक है। यह समारोह बहुत सरल है यह यह करने के लिए 10 जोड़कर किसी दिए गए इनपुट देता है,:,
(define (test-lambda x)
((lambda (b)
(+ x b))
10))
आप देख सकते हैं:
(define (test x)
(let ((b 10))
(+ x b)))
अब हम लैम्ब्डा का उपयोग कर एक अभिव्यक्ति में इस गौर करें परीक्षण लैम्ब्डा एक लैम्ब्डा मूल्यांकन कि मूल्य से 10 परीक्षण के साथ मूल्यांकन किया जाता है देता है यह हम कह सकते हैं:
(test-lambda 10)
जो वापस आ जाएगी 20.
हमारी देना मामला हम दो बयान करते है तो अब हम उन्हें दे लैम्ब्डा भाव से प्रत्येक का मूल्यांकन कर रहे
(define (lets-lambda x)
((lambda (a)
((lambda (b)
(+ x a b))
20))
10))
:
(define (lets x)
(let ((a 10)
(b 20))
(+ x a b)))
हम तो जैसे लैम्ब्डा के साथ यह लिख सकते हैं एक मूल्य, और सबसे निचला लैम्ब्डा अभिव्यक्ति इस बात का ख्याल रखती है कि हम परिवर्तनीय नामों का उपयोग करके गणना करना चाहते हैं कि प्रत्येक लैम्ब्डा अभिव्यक्ति असाइन की गई है।
आशा है कि यह स्पष्ट था और दूसरों को और अधिक स्पष्ट रूप से देखने में मदद कर सकता है!