common-lisp
Boucles de base

Syntaxe

• (do ({var | (var [init-form [step-form]])} *) (end-test-form result-form *) déclaration * {tag | statement} *)
• (do * ({var | (var [init-form [step-form]])} *) (end-test-form result-form *) déclaration * {tag | statement} *)
• (dolist (var list-form [result-form]) déclaration * {tag | statement} *)
• (dotimes (var count-form [result-form]) déclaration * {tag | statement} *)

dotimes

dotimes est une macro pour une itération d'entier sur une seule variable de 0 sous une valeur de paramètre. Un des exemples simples serait:

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

0 
1 
2 
3 
4 
NIL

Notez que NIL est la valeur renvoyée, puisque nous n'en avons pas fourni nous-mêmes; la variable commence à 0 et dans toute la boucle devient des valeurs de 0 à N-1. Après la boucle, la variable devient le 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)

faire une liste

dolist est une macro en boucle créée pour parcourir facilement les listes. Une des utilisations les plus simples serait:

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

A 
B 
C 
D 
NIL ; returned value is NIL

Notez que puisque nous n'avons pas fourni de valeur de retour, NIL est renvoyé (et A, B, C, D sont imprimés dans *standard-output* ).

dolist peut également renvoyer des valeurs:

;;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

Boucle simple

La macro de boucle a deux formes: la forme "simple" et la forme "étendue". La forme étendue est traitée dans une autre rubrique de documentation, mais la boucle simple est utile pour les boucles très simples.

La forme en boucle simple prend un certain nombre de formes et les répète jusqu'à ce que la boucle soit sortie en utilisant return ou une autre sortie (par exemple, throw ).

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

0 
1 
2 
3 
4 
NIL