common-lisp
बुनियादी छोरों

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

• (do ({var | (var [init-form [step-form]]])} *) (एंड-टेस्ट-फॉर्म result-form *) डिक्लेरेशन * {टैग | स्टेटमेंट} *)
• (do * ({var | (var [init-form [step-form]])} *) (एंड-टेस्ट-फॉर्म result-form *) डिक्लेरेशन * {tag | statement} *)
• (dolist (var list-form [result-form]) घोषणा * * टैग | कथन} *)
• (dotimes (var count-form [result-form]) घोषणा * * टैग | कथन} *)

dotimes

कुछ पैरामीटर मान के नीचे 0 से एकल चर पर पूर्णांक पुनरावृत्ति के लिए dotimes एक मैक्रो है। उदाहरणों में से एक होगा:

CL-USER> (dotimes (i 5)
           (print i))

0 
1 
2 
3 
4 
NIL

ध्यान दें कि NIL लौटाया गया मान है, क्योंकि हमने स्वयं को प्रदान नहीं किया है; चर 0 से शुरू होता है और पूरे लूप में 0 से N-1 तक मान बन जाता है। लूप के बाद, चर N बन जाता है:

CL-USER> (dotimes (i 5 i))
5

CL-USER> (defun 0-to-n (n)
           (let ((list ()))
             (dotimes (i n (nreverse list))
               (push i list))))
0-TO-N
CL-USER> (0-to-n 5)
(0 1 2 3 4)

सूची करो

dolist सूचियों के माध्यम से आसानी से लूप करने के लिए बनाया गया एक लूपिंग मैक्रो है। सबसे सरल उपयोगों में से एक होगा:

CL-USER> (dolist (item '(a b c d))
           (print item))

A 
B 
C 
D 
NIL ; returned value is NIL

ध्यान दें कि चूंकि हमने रिटर्न वैल्यू NIL है, इसलिए NIL लौटाया गया है (और A, B, C, D को *standard-output* ) प्रिंट किया गया है।

dolist भी मान लौटा सकता है:

;;This may not be the most readable summing function.
(defun sum-list (list)
  (let ((sum 0))
    (dolist (var list sum)
      (incf sum var))))

CL-USER> (sum-list (list 2 3 4))
9

साधारण लूप

लूप मैक्रो के दो रूप हैं: "सरल" रूप और "विस्तारित" रूप। विस्तारित प्रपत्र एक और प्रलेखन विषय में कवर किया गया है, लेकिन साधारण लूप बहुत बुनियादी लूप के लिए उपयोगी है।

साधारण लूप फॉर्म कई रूप लेता है और उन्हें तब तक दोहराता है जब तक कि रिटर्न या कुछ अन्य निकास (जैसे, फेंक ) का उपयोग करके लूप बाहर नहीं निकल जाता है।

(let ((x 0))
  (loop
     (print x)
     (incf x)
     (unless (< x 5)
       (return))))

0 
1 
2 
3 
4 
NIL