Pass the list correctly to the macro in Common Lisp

Question

I wrote a macro to execute several nested loops. I understand that there are other possibilities for this, but I'm trying to learn how to write macros, and this seemed like a good use case. It works too (sort of):

(defmacro dotimes-nested (nlist fn)
  (let ((index-symbs nil)
        (nlist (second nlist))) ;remove quote from the beginning of nlist
    (labels 
      ((rec (nlist)
            (cond ((null nlist) nil)
                  ((null (cdr nlist))
                   (let ((g (gensym)))
                     (push g index-symbs)
                     `(dotimes (,g ,(car nlist) ,g)
                        (funcall ,fn ,@(reverse index-symbs)))))
                  (t (let ((h (gensym)))
                       (push h index-symbs)
                       `(dotimes (,h ,(car nlist) ,h)
                          ,(rec (cdr nlist))))))))
      (rec nlist))))

works:

(macroexpand-1 '(dotimes-nested '(2 3 5)
                #'(lambda (x y z) (format t "~A, ~A, ~A~%" x y z))))

outputs:

(DOTIMES (#:G731 2 #:G731)
  (DOTIMES (#:G732 3 #:G732)
    (DOTIMES (#:G733 5 #:G733)
      (FUNCALL #'(LAMBDA (X Y Z) (FORMAT T "~A, ~A, ~A~%" X Y Z)) #:G731 #:G732
               #:G733))))

and call the macro as follows:

(dotimes-nested '(2 3 5)
                #'(lambda (x y z) (format t "~A, ~A, ~A~%" x y z)))

returns correctly what I expect:

0, 0, 0
0, 0, 1
0, 0, 2
0, 0, 3
0, 0, 4
0, 1, 0
0, 1, 1
0, 1, 2
0, 1, 3
0, 1, 4
0, 2, 0
0, 2, 1
0, 2, 2
0, 2, 3
0, 2, 4
1, 0, 0
1, 0, 1
1, 0, 2
1, 0, 3
1, 0, 4
1, 1, 0
1, 1, 1
1, 1, 2
1, 1, 3
1, 1, 4
1, 2, 0
1, 2, 1
1, 2, 2
1, 2, 3
1, 2, 4
2

However, if I call it this:

(let ((dims '(3 4)))
    (dotimes-nested dims
                #'(lambda (x y) (format t "~A, ~A~%" x y))))

I get an error message:

; in: LET ((DIMS '(3 4)))
;     (DOTIMES-NESTED DIMS #'(LAMBDA (X Y) (FORMAT T "~A, ~A~%" X Y)))
; 
; caught ERROR:
;   during macroexpansion of (DOTIMES-NESTED DIMS #'(LAMBDA # #)). Use
;   *BREAK-ON-SIGNALS* to intercept.
;   
;    The value DIMS is not of type LIST.

;     (LET ((DIMS '(3 4)))
;       (DOTIMES-NESTED DIMS #'(LAMBDA (X Y) (FORMAT T "~A, ~A~%" X Y))))
; 
; caught STYLE-WARNING:
;   The variable DIMS is defined but never used.
; 
; compilation unit finished
;   caught 1 ERROR condition
;   caught 1 STYLE-WARNING condition

How to pass a variable that is not interpreted as a symbol, but as a value? Should I evaluate it in a macro using? But I can’t figure out how to do this. Also, how will both situations work: a: calling a macro with the literal '(3 4) and b: passing the character associated with the list' (3 4)? Do I need separate macros for each?

, . nlist, (second nlist) . , , '(3 4) (quote (3 4)) ​​. ? , , , ?

Answer 1

, . DIMS . , , , ,

(dotimes-nested dims ...)

DIMS ( ), .

, . (dotimes-nested (2 3 4) ...) ( ).

runtime , . - :

(defun dotimes-nested (nlist function)
  (labels ((rec (nlist args)
             (if (endp nlist)
                 (apply function (reverse args))
                 (destructuring-bind (first . rest) nlist
                   (dotimes (i first)
                     (rec rest (cons i args)))))))
    (rec nlist nil)))

CL-USER> (let ((dims '(3 4)))
           (dotimes-nested dims
                           #'(lambda (x y) (format t "~A, ~A~%" x y))))
0, 0
0, 1
0, 2
0, 3
1, 0
1, 1
1, 2
1, 3
2, 0
2, 1
2, 2
2, 3
NIL

Answer 2

, second ; remove quote from the beginning of nlist

, , , . , .

. , , , - .

- :

(dotimes-nested dims
                #'(lambda (x y) (format t "~A, ~A~%" x y))))

dims. dims, , , .

:

(dotimes* ((a 3) (b 2) (c 10))
  (format t "~A, ~A, ~A~%" a b c))

(defmacro dotimes* ((&rest binding-initials) &body body)
  (loop :for (binding initial) :in (reverse binding-initials)
        :for result := `(dotimes (,binding ,initial nil) ,@body) 
                    :then `(dotimes (,binding ,initial nil) ,result)
        :finally (return result)))

: :

(defparameter *x* 10) 
(defparameter *y* 10)
(dotimes* ((x *x*) (y *y*))
  (format t "(~a,~a)~%" x y))

, , @kiiski, .