common-lisp
नियंत्रण संरचनाएं

सशर्त निर्माण

आम लिस्प में, if सबसे सरल सशर्त निर्माण है। यह रूप है (if test then [else]) और करने के लिए मूल्यांकन किया जाता है then अगर test सही है और else अन्यथा। दूसरे भाग को छोड़ा जा सकता है।

(if (> 3 2)
    "Three is bigger!"
    "Two is bigger!")
;;=> "Three is bigger!"

एक के बीच बहुत महत्वपूर्ण अंतर if कॉमन लिस्प में और if कई अन्य प्रोग्रामिंग भाषाओं में है कि सीएल के है if एक अभिव्यक्ति है, न कि एक बयान है। जैसे, if फॉर्म रिटर्न मान देते हैं, जो चर के लिए दिए जा सकते हैं, तर्क सूची में उपयोग किए जा सकते हैं, आदि:

;; Use a different format string depending on the type of x
(format t (if (numberp x)
              "~x~%"
              "~a~%")
           x)

कॉमन लिस्प की if त्रिनेत्र ऑपरेटर के बराबर माना जा सकता है ?: सी # और अन्य "घुंघराले ब्रेस" भाषाओं में।

उदाहरण के लिए, निम्नलिखित C # अभिव्यक्ति:

year == 1990 ? "Hammertime" : "Not Hammertime"

निम्नलिखित सामान्य लिस्प कोड के बराबर है, यह मानते हुए कि year पूर्णांक है:

(if (eql year 1990) "Hammertime" "Not Hammertime")

cond एक और सशर्त निर्माण है। यह कुछ हद तक if बयानों की एक श्रृंखला के समान है, और इसका रूप है:

(cond (test-1 consequent-1-1 consequent-2-1 ...)
      (test-2)
      (test-3 consequent-3-1 ...)
      ... )

अधिक सटीक रूप से, cond में शून्य या अधिक खंड होते हैं , और प्रत्येक खंड में एक परीक्षण होता है जिसके बाद शून्य या अधिक परिणाम होते हैं। संपूर्ण cond कंस्ट्रक्शन पहले क्लॉज का चयन करता है जिसका परीक्षण nil का मूल्यांकन नहीं करता है और क्रम में इसके परिणाम का मूल्यांकन करता है। यह परिणाम में अंतिम रूप का मान लौटाता है।

(cond ((> 3 4) "Three is bigger than four!")
      ((> 3 3) "Three is bigger than three!")
      ((> 3 2) "Three is bigger than two!")
      ((> 3 1) "Three is bigger than one!"))
;;=> "Three is bigger than two!"

मूल्यांकन करने के लिए एक डिफ़ॉल्ट खंड प्रदान करने के लिए यदि कोई अन्य खंड t मूल्यांकन नहीं करता t , तो आप एक ऐसा खंड जोड़ सकते हैं जो डिफ़ॉल्ट रूप से t का उपयोग करके सत्य है। यह SQL के CASE...ELSE की अवधारणा में बहुत समान है, लेकिन यह कार्य को पूरा करने के लिए एक कीवर्ड के बजाय एक शाब्दिक बूलियन सच का उपयोग करता है।

(cond
    ((= n 1) "N equals 1")
    (t "N doesn't equal 1")
)

एक if निर्माण एक के रूप में लिखा जा सकता है cond निर्माण। (if test then else) (cond (test then) (t else)) और (cond (test then) (t else)) समतुल्य हैं।

यदि आपको केवल एक खंड की आवश्यकता है, when या unless उपयोग करें:

(when (> 3 4)
  "Three is bigger than four.")
;;=> NIL

(when (< 2 5)
  "Two is smaller than five.")
;;=> "Two is smaller than five."

(unless (> 3 4)
  "Three is bigger than four.")
;;=> "Three is bigger than four."

(unless (< 2 5)
  "Two is smaller than five.")
;;=> NIL

लूप करते हैं

कॉमन लिस्प में अधिकांश लूपिंग और सशर्त निर्माण वास्तव में मैक्रोज़ हैं जो अधिक बुनियादी निर्माण को छिपाते हैं। उदाहरण के लिए, dotimes और dolist बनाया पर कर रहे हैं do मैक्रो। के लिए प्रपत्र do इस प्रकार है:

(do (varlist)
    (endlist)
   &body)

• varlist लूप में परिभाषित चर, उनके प्रारंभिक मूल्यों से बना है, और वे प्रत्येक पुनरावृत्ति के बाद कैसे बदलते हैं। लूप के अंत में 'परिवर्तन' भाग का मूल्यांकन किया जाता है।
• endlist में अंत स्थितियां हैं और लूप के अंत में दिए गए मान हैं। लूप की शुरुआत में अंतिम स्थिति का मूल्यांकन किया जाता है।

यहाँ एक है जो 0 से शुरू होता है और 10 तक (शामिल नहीं) तक जाता है।

;;same as (dotimes (i 10)) 
(do (( i (+ 1 i))
    ((< i 10) i)
   (print i))

और यहाँ एक है कि एक सूची के माध्यम से चलता है:

;;same as (dolist (item given-list)
(do ((item (car given-list))
     (temp list (cdr temp))
   (print item))

varlist भाग एक let स्टेटमेंट में एक जैसा है। आप एक से अधिक वेरिएबल को बांध सकते हैं, और वे केवल लूप के अंदर मौजूद हैं। घोषित प्रत्येक चर कोष्ठक के अपने सेट में है। यहाँ एक है कि एक सूची में कितने 1 और 2 हैं गिना जाता है।

(let ((vars (list 1 2 3 2 2 1)))
  (do ((ones 0)
       (twos 0)
       (temp vars (cdr temp)))
      ((not temp) (list ones twos))
    (when (= (car temp) 1)
      (setf ones (+ 1 ones)))
    (when (= (car temp) 2)
      (setf twos (+ 1 twos)))))
-> (2 3)

और अगर थोड़ी देर के लूप मैक्रो को लागू नहीं किया गया है:

(do ()
    (t)
  (when task-done
    (break)))

सबसे आम अनुप्रयोगों के लिए, अधिक विशिष्ट dotimes और doloop मैक्रोज़ बहुत अधिक doloop हैं।