Использование цикла внутри defmacro

Ваш макрос xond заканчивается на (return t), поэтому он оценивается как t, а не как ваши накопленные if выражения.

Вы можете использовать предложение loopcollect для накопления кода, который вы хотите вернуть. Например: (loop for x in '(1 2 3) collect (* 2 x)) будет оцениваться как (2 4 6).

Некоторые замечания

• Вам не нужен progn, когда вы расширяетесь только до одного if
• Использование pop может сбить с толку читателя (и программиста тоже), поскольку оно мутирует место, возможно, вы захотите начать с менее императивного подхода.

Кроме того, в этом случае я не думаю, что подход loop полезен, потому что вам нужно вложить выражения, которые следуют в теле, внутри ранее созданной формы, и хотя это можно сделать, это немного сложнее. сделайте это просто рекурсивной функцией или "рекурсивным" макросом.

Здесь я объясняю оба подхода, начиная с "рекурсивного" макроса (цитата здесь потому, что макрос не вызывает сам себя, а расширяется как вызов самого себя).

Фиксированная точка расширения макроса

Если бы мне пришлось реализовать xond, я бы написал макрос, который расширяется в другие вызовы xond, пока макрорасширение не достигнет базового случая, когда больше нет xond:

(defmacro xond (&rest body)
  (if (rest body)
      (destructuring-bind (test if-action . rest) body
        `(if ,test ,if-action (xond ,@rest)))
      (first body)))

Например, это выражение:

(xond (= n 1) (setq x 2) (= n 2) (setq x 1))

Первый макрос раскрывается в:

(if (= n 1)
    (setq x 2)
    (xond (= n 2) (setq x 1)))

И в конечном итоге достигает фиксированной точки с:

(if (= n 1)
    (setq x 2)
    (if (= n 2)
        (setq x 1)
        nil))

Будьте осторожны, вы не можете напрямую использовать xond внутри определения xond, происходит то, что макрос расширяется как вызов xond, который Lisp затем расширяет снова. Если вы не будете осторожны, вы можете получить бесконечное макрорасширение, поэтому вам нужен базовый случай, когда макрос не расширяется в xond.

Макрос, вызывающий рекурсивную функцию

В качестве альтернативы вы можете вызвать рекурсивную функцию внутри вашего макроса и развернуть все внутренние формы одновременно.

С помощью LABELS вы привязываете xond-expand к рекурсивной функции. Вот это реальный рекурсивный подход:

(labels ((xond-expand (body)
           (if body
               (list 'if
                     (pop body)
                     (pop body)
                     (xond-expand body))
               nil)))
  (xond-expand '((= n 1) (setq x 2) (= n 2) (setq x 1))))

 ; => (IF (= N 1)
 ;    (SETQ X 2)
 ;    (IF (= N 2)
 ;        (SETQ X 1)
 ;        NIL))

Как насчет

(ql:quickload :alexandria)

(defun as-last (l1 l2)
  `(,@l1 ,l2))

(defmacro xond (&rest args)
  (reduce #'as-last
          (loop for (condition . branch) in (alexandria:plist-alist args)
                collect `(if ,condition ,branch))
          :from-end t))

(macroexpand-1 '(xond c1 b1 c2 b2 c3 b3))
;; (IF C1 B1 (IF C2 B2 (IF C3 B3))) ;
;; T

alexandriaplist-alist использовался для объединения аргументов, внутренняя деструктуризация в loop используется для извлечения условий и ветвей.

Вспомогательная функция as-last складывает списки вместе в виде (a b c) (d e f) => (a b c (d e f)).

(reduce ... :from-end t) сворачивает вправо последовательность собранных (if condition branch) предложений, складывая их друг в друга с помощью #'as-last.

Без каких-либо зависимостей

(«хотя, alexandria вообще считается зависимостью? ;))

(defun pairs (l &key (acc '()) (fill-with-nil-p nil))
  (cond ((null l) (nreverse acc))
        ((null (cdr l)) (pairs (cdr l) 
                               :acc (cons (if fill-with-nil-p
                                              (list (car l) nil)
                                              l) 
                                          acc) 
                               :fill-with-nil-p fill-with-nil-p))
        (t (pairs (cdr (cdr l)) 
                  :acc (cons (list (car l) (cadr l)) acc) 
                  :fill-with-nil-p fill-with-nil-p))))

(defun as-last (l1 l2)
  `(,@l1 ,l2))

(defmacro xond (&rest args)
  (reduce #'as-last
          (loop for (condition branch) in (pairs args)
                         collect `(if ,condition ,branch))
          :from-end t))

(macroexpand-1 '(xond c1 b1 c2 b2 c3 b3))
;; (IF C1 B1 (IF C2 B2 (IF C3 B3))) ;
;; T

Вспомогательная функция pairs делает из (a b c d e f) => ((a b) (c d) (e f)).

(:fill-with-nil-p определяет в случае нечетного числа элементов списка, будет ли последний элемент в списке (last-el) или (last-el nil) - в последнем случае заполнен nil).