scheme
वाक्य - विन्यास

एस अभिव्यक्ति

योजना में एक अभिव्यक्ति है जिसे निष्पादित किया जा रहा है। एक एस-अभिव्यक्ति, जैसा कि आमतौर पर कहा जाता है, एक ( और अंत के साथ ) शुरू होता है। अभिव्यक्ति का पहला सदस्य वह है जो निष्पादित होने वाला है। अभिव्यक्ति के निम्नलिखित सदस्य पैरामीटर हैं जो अभिव्यक्ति के मूल्यांकन के दौरान अभिव्यक्ति को भेजे जाएंगे।

उदाहरण के लिए संख्याओं को जोड़ना:

(+ 1 2 3)

इस मामले में, + एक ऐड फंक्शन का प्रतीक है जो कई मापदंडों को लेता है। 1 , 2 और 3 को + फंक्शन में भेजा जाता है।

एस-एक्सप्रेशन में एस-एक्सप्रेशन पैरामीटर के रूप में हो सकते हैं जैसा कि निम्नलिखित उदाहरण में दिखाया गया है:

(if (< x y)
  x
  y)

जिसे पढ़ा जा सकता है जैसे कि x , y रिटर्न x से कम है और रिटर्न y । इस उदाहरण में हम स्थिति की अभिव्यक्ति का मूल्यांकन करते हैं, जो कि निर्धारित मूल्य के आधार पर, या तो x या y को वापस कर दिया जाएगा। इसका मूल्यांकन किया जा सकता है

(if #t x y)
x
(if #f x y)
y

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

((if (< x y) + -) 
  1 2 3)

यदि x y से नीचे है, तो अभिव्यक्ति का मूल्यांकन इस प्रकार किया जाएगा:

(+ 1 2 3)
6

अन्यथा

(- 1 2 3)
-4

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

(यदि (<xy) (+ १ २ ३) (- १ २ ३))

इस विधि के साथ समस्या यह है कि हम बहुत सारे कोड को डुप्लिकेट करते हैं जबकि एकमात्र चीज जो परिवर्तन है वह विधि कहलाती है। यह उदाहरण काफी सरल है लेकिन अधिक स्थिति के साथ हम बहुत सी समान रेखाओं को डुप्लिकेट कर सकते हैं।

सरल चलो मैक्रो

योजना में निहित भाव वास्तव में मैक्रोज़ हैं। उन्हें लंबोदर के साथ व्यक्त किया जा सकता है। एक साधारण सा लग सकता है ऐसा:

(let ((x 1) (y 2))
  (+ x y))

यह 3 वापस आ जाएगा क्योंकि लेट बॉडी के अंतिम एक्सप्रेशन का मान वापस आ जाता है। जैसा कि आप देख सकते हैं, एक लेट-एक्सप्रेशन वास्तव में कुछ निष्पादित कर रहा है। यदि हम कोड के इस भाग का लंबोदर के साथ अनुवाद करते हैं, तो हमें कुछ इस तरह मिलेगा:

((lambda (x y) (+ x y)) 1 2)

यहां हम देख सकते हैं कि हम अनाम लैम्ब्डा को सीधे 1 और 2 के साथ बुला रहे हैं। तो इस मामले में परिणाम भी 3 है।

इसे ध्यान में रखते हुए, हम समझते हैं कि एक अभिव्यक्ति 2 भागों से बना है। इसके पैरामीटर हैं और एक लैम्बडा जैसा शरीर है, लेकिन अंतर यह है कि अभिव्यक्ति को उनके मूल्यांकन के ठीक बाद कहा जाता है।

यह बताने के लिए कि एक अमूर्त से ठोस दृष्टिकोण तक कैसे अभिव्यक्ति होती है, यह इस तरह दिखेगा।

(let params body ...)
(let (param1 param2 ...) body ...)
(let ((p1 val1) (p2 val2) ...) body ...)

पैरामीटर्स (name value) की जोड़ी की एक सूची है जो let के शरीर में उपयोग की जाती है।

अभिव्यक्ति का उपयोग क्यों करते हैं?

भाषा की तरह c में चर के आरंभीकरण की तरह ही चर को विशेष रूप से संग्रहीत करने के लिए अभिव्यक्ति विशेष रूप से उपयोगी है। यह define के उपयोग के अनुकूल है क्योंकि लेट एक्सप्रेशन में से, चर गए हैं ... परिभाषित का उपयोग करना वास्तव में वर्तमान निष्पादन वातावरण में एक चर जोड़ना है। वैश्विक परिवेश में जोड़े गए चर को हटाया नहीं जा सकता। कहीं भी उपयोग करने के लिए अभिव्यक्ति सुरक्षित हैं। इसका उपयोग पैरेंट स्कोप को छुए बिना भूत चर के लिए भी किया जा सकता है।

उदाहरण के लिए:

(let ((x 1))
  (let ((x 2) (y x))
    (display x)
    (display y))
  (display x))

यह प्रिंट होगा:

2
1
1

इस मामले में, x , 1 के साथ परिभाषित किया गया है तब तक ghosted x दूसरे में let मूल्य के साथ 2 । चर y को पैरेंट स्कोप के मान x के साथ आरंभ किया जाता है। आंतरिक let एक्सप्रेशन निष्पादित let बाद, यह x के प्रारंभिक मान को 1 के साथ प्रदर्शित करता है। इनर let एक्सप्रेशन ने पेरेंट स्कोप का मान नहीं बदला।

जब भी आपको वैरिएबल को इनिशियलाइज़ करने की आवश्यकता होती है, तो आपको इस तरह के लेट एक्सप्रेशंस का उपयोग करना चाहिए:

(let (
  (user (get-current-user session))
  (db (get-current-db session))
  (ids (get-active-ids session))
  )
  (mark-task-completed db user ids)
  (change-last-logged db user)
  (db-commit db))

यहाँ इस उदाहरण में, चर को प्रारंभ किया जाता है और कोड ब्लॉक में कई बार उपयोग किया जाता है। और जब अभिव्यक्ति समाप्त हो जाती है, तो चर स्वचालित रूप से मुक्त हो जाते हैं क्योंकि वे अब आवश्यक नहीं हैं।

जोड़े के लिए बिंदीदार वाक्यविन्यास

वहाँ एक विशेष वाक्य रचना है कि हम लिखने की अनुमति है cons का उपयोग करने से एक अधिक कॉम्पैक्ट तरह से सेल cons निर्माता।

एक जोड़ी इस तरह लिखी जा सकती है:

'(1 . 2) == (cons 1 2)

बड़ा अंतर यह है कि हम उद्धरण का उपयोग करके pairs बना सकते हैं। अन्यथा, स्कीम एक उचित सूची (1 . (2 . '())) बनाएगी।

डॉट सिंटैक्स अभिव्यक्ति को केवल 2 सदस्यों के लिए मजबूर करता है। प्रत्येक सदस्य जोड़े सहित किसी भी प्रकार का हो सकता है।

'(1 . (2 . (3 . 4)))
> (1 2 3 . 4)

ध्यान दें कि अनुचित सूची को एक बिंदु के साथ अंत में प्रदर्शित किया जाना चाहिए कि यह दिखाने के लिए कि सूची के अंतिम जोड़े की cdr खाली सूची नहीं है '() ।

सूचियों को दिखाने का यह तरीका कुछ समय के लिए भ्रमित करने वाला है क्योंकि निम्न अभिव्यक्ति को व्यक्त नहीं किया जाएगा जैसे कोई इसकी उम्मीद करेगा।

'((1 . 2) . ( 3 . 4))
> ((1 . 2) 3 . 4)

चूंकि सूची आमतौर पर छोड़ें . , सूची का पहला तर्क (1 . 2) , दूसरा तर्क 3 होगा लेकिन चूंकि सूची अनुचित है, अंतिम है . यह दिखाने के लिए दिखाया गया है कि सूची का अंतिम तत्व '() । यहां तक कि सोचा, डेटा को एक अलग तरीके से दिखाया गया है, आंतरिक डेटा वैसा ही है जैसा इसे बनाया गया था।