Как определить рекурсивный макрос cond с формой в lisp?

Question

Я хочу осуществить конд (с помощью LISP макросов лукавства) с, если, это моя попытка:

(define-macro (cond . clauses) 
    (if (pair? clauses) 
     (let ((first (car clauses)) (rest (cdr clauses))) 
     `(if ,(car first) 
       (begin 
       ,@(cdr first)) 
       ,(if (equal? (caar rest) 'else) 
        ',(cadr rest) 
        `(cond ,rest)))))) 

, но не работают, когда я называю его с этим кодом:

(cond ((= 1 0) (display "hello")) 
     ((= 1 1) (display "world")) 
     (else 
     (display "foo"))) 

Я получил эту ошибку:

ERROR: In procedure car: Wrong type argument in position 1 (expecting pair):() 

Почему я получил эту ошибку и как ее исправить? Я предпочитаю решение с макросами lisp.

Answer 1

Это работает Лисп версия:

(defmacro mycond (&rest clauses) 
    (if (consp clauses) 
     (destructuring-bind ((pred . forms) . rest-clauses) clauses 
     `(if ,pred 
      (progn ,@forms) 
      ,(if (and (consp rest-clauses) 
        (eq (caar rest-clauses) 't)) 
       `(progn ,@(cdar rest-clauses)) 
       `(mycond ,@rest-clauses)))) 
    nil)) 

Вы можете видеть, что есть четыре ошибки исправлено:

• запятой не внутри обратной кавычки
• остальные-пункты должны быть сращивания в
• По умолчанию T пункт необходимо ввести код
• не перезаписать встроенный COND

Расширяя пример:

CL-USER 67 > (walker:walk-form '(mycond ((= 1 0) (write "hello")) 
             ((= 1 1) (write "world")) 
             (t  (write "foo")))) 

(IF (= 1 0) 
    (PROGN (WRITE "hello")) 
    (IF (= 1 1) 
     (PROGN (WRITE "world")) 
    (PROGN (WRITE "foo")))) 

Немного простой вариант:

(defmacro mycond (&rest clauses) 
    (if (consp clauses) 
     (destructuring-bind ((pred . forms) . rest-clauses) clauses 
     (if (eq pred t) 
      `(progn ,@forms) 
      `(if ,pred 
       (progn ,@forms) 
      (mycond ,@rest-clauses)))) 
    nil)) 

Answer 2

Большинство программистов Схемы, включая меня, не любят использовать define-macro, потому что это абсолютно негигиенично. Я понятия не имею, почему вы предпочитаете их использовать. Имея это в виде (что я бы не писать никаких define-macro макросов себя), я пошарил Femtolisp (схему подобную реализации, также не использует гигиенические макросы) для its implementation of cond:

(define-macro (cond . clauses) 
    (define (cond-clauses->if lst) 
    (if (atom? lst) 
     #f 
     (let ((clause (car lst))) 
      (if (or (eq? (car clause) 'else) 
        (eq? (car clause) #t)) 
       (if (null? (cdr clause)) 
        (car clause) 
        (cons 'begin (cdr clause))) 
       (if (null? (cdr clause)) 
        ; test by itself 
        (list 'or 
         (car clause) 
         (cond-clauses->if (cdr lst))) 
        ; test => expression 
        (if (eq? (cadr clause) '=>) 
         (if (1arg-lambda? (caddr clause)) 
          ; test => (lambda (x) ...) 
          (let ((var (caadr (caddr clause)))) 
          `(let ((,var ,(car clause))) 
           (if ,var ,(cons 'begin (cddr (caddr clause))) 
            ,(cond-clauses->if (cdr lst))))) 
          ; test => proc 
          (let ((b (gensym))) 
          `(let ((,b ,(car clause))) 
           (if ,b 
            (,(caddr clause) ,b) 
            ,(cond-clauses->if (cdr lst)))))) 
         (list 'if 
          (car clause) 
          (cons 'begin (cdr clause)) 
          (cond-clauses->if (cdr lst))))))))) 
    (cond-clauses->if clauses)) 

Надеется, что это работает для Вас!

---

Если то, что вы предпочитаете не старый стиль антисанитарных макросы, а просто система макросов, что позволяет играть с входящей формой в сырье, многих реализациях Scheme обеспечивают явное переименование (ER) макросистему, который позволяет вам напрямую манипулировать формами и по-прежнему позволяет поддерживать гигиену (как следует из названия), явно переименовывая любые идентификаторы, которые должны быть защищены от затенения на сайте вызова макросов. Вот Chibi Scheme's implementation of cond:

(define-syntax cond 
    (er-macro-transformer 
    (lambda (expr rename compare) 
    (if (null? (cdr expr)) 
     (if #f #f) 
     ((lambda (cl) 
      (if (compare (rename 'else) (car cl)) 
       (if (pair? (cddr expr)) 
        (error "non-final else in cond" expr) 
        (cons (rename 'begin) (cdr cl))) 
       (if (if (null? (cdr cl)) #t (compare (rename '=>) (cadr cl))) 
        (list (list (rename 'lambda) (list (rename 'tmp)) 
           (list (rename 'if) (rename 'tmp) 
             (if (null? (cdr cl)) 
              (rename 'tmp) 
              (list (car (cddr cl)) (rename 'tmp))) 
             (cons (rename 'cond) (cddr expr)))) 
          (car cl)) 
        (list (rename 'if) 
          (car cl) 
          (cons (rename 'begin) (cdr cl)) 
          (cons (rename 'cond) (cddr expr)))))) 
      (cadr expr)))))) 

---

реализации Основные Схема, как правило, разделены на два лагеря с точки зрения того, что они используют для макросов низкого уровня: syntax-case и явного переименования. Racket, Chez Scheme, Guile и т. Д. Используют syntax-case. CHICKEN, MIT Scheme, Chibi Scheme и т. Д. Используют явное переименование. Таким образом, вы не сможете использовать явную версию переименования выше в Guile, потому что она находится в лагере syntax-case.