Как определить функцию в LISP, которая рекурсивно возвращает обратно цитируемый список - PullRequest
1 голос
/ 20 апреля 2019

У меня проблема с макросами в интерпретаторе lisp, написанном на JavaScript.проблема в этом коде:

(define log (. console "log"))

(define (alist->object alist)
  "(alist->object alist)

   Function convert alist pairs to JavaScript object."
  (if (pair? alist)
      ((. alist "toObject"))))


(define (klist->alist klist)
  "(klist->alist klist)

   Function convert klist in form (:foo 10 :bar 20) into alist
   in form ((foo . 10) (bar . 20))."
  (let iter ((klist klist) (result '()))
    (if (null? klist)
        result
        (if (and (pair? klist) (pair? (cdr klist)) (key? (car klist)))
            (begin
              (log ":::" (cadr klist))
              (log "data" (. (cadr klist) "data"))
              (iter (cddr klist) (cons (cons (key->string (car klist)) (cadr klist)) result)))))))




(define (make-empty-object)
  (alist->object '()))

(define empty-object (make-empty-object))

(define klist->object (pipe klist->alist alist->object))

;; main function that give problems
(define (make-tags expr)
  (log "make-tags" expr)
  `(h ,(key->string (car expr))
      ,(klist->object (cadr expr))
      ,(if (not (null? (cddr expr)))
           (if (and (pair? (caddr expr)) (let ((s (caaddr expr))) (and (symbol? s) (eq? s 'list))))
               `(list->array (list ,@(map make-tags (cdaddr expr))))
               (caddr expr)))))


(define-macro (with-tags expr)
  (make-tags expr))

Я называю этот макрос, используя этот код:

(define (view state actions)
  (with-tags (:div ()
                   (list (:h1 () (value (cdr (assoc 'count (. state "counter")))))
                         (:button (:onclick (lambda () (--> actions (down 1)))) "-")
                         (:button (:onclick (lambda () (--> actions (up 1)))) "+")))))

, который должен расшириться почти до того же кода:

(define (view state actions)
  (h "div" (make-empty-object)
     (list->array (list
                   (h "h1" (make-empty-object) (value (cdr (assoc 'count (. state "counter")))))
                   (h "button" (klist->object `(:onclick ,(lambda () (--> actions (down 1))))) "-")
                   (h "button" (klist->object `(:onclick ,(lambda () (--> actions (up 1))))) "+")))))

Эта функция работает.У меня проблема с расширенным кодом, использующим мой макрос, который вызывает основную функцию, не знаю, как LIPS должен вести себя, когда находит:

(:onclick (lambda () (--> actions (down 1))))

внутри кода, и вы пытаетесь обработать его следующим образом:

,(klist->object (cadr expr))

Прямо сейчас мой lisp работает так, что лямбда помечается как данные (имейте флаг данных, установленный в true, это хак для предотвращения рекурсивной оценки некоторого кода из макросов), а функция klist->object получает лямбда-код в виде списка,вместо функции.

Как это должно работать в Scheme или Common Lisp?Должен ли klist->object получить объект функции (лямбда получит оценку) или структуру списка с лямбдой в качестве первого символа?Если второй, то как я должен написать свою функцию и макрос для оценки лямбды, если я использую eval (что-то вроде хака для меня).

Извините, не знаю, как это проверить, с большим количеством безошибочных LISP.

РЕДАКТИРОВАТЬ:

Я пытался применить подсказку от @jkiiski в guile (потому что в моем lisp он не работал)

;; -*- sheme -*-

(define nil '())

(define (key? symbol)
  "(key? symbol)

   Function check if symbol is key symbol, have colon as first character."
  (and (symbol? symbol) (eq? ":" (substring (symbol->string symbol) 0 1))))

(define (key->string symbol)
  "(key->string symbol)

   If symbol is key it convert that to string - remove colon."
  (if (key? symbol)
      (substring (symbol->string symbol) 1)))


(define (pair-map fn seq-list)
  "(seq-map fn list)

   Function call fn argument for pairs in a list and return combined list with
   values returned from function fn. It work like the map but take two items from list"
  (let iter ((seq-list seq-list) (result '()))
(if (null? seq-list)
    result
    (if (and (pair? seq-list) (pair? (cdr seq-list)))
        (let* ((first (car seq-list))
               (second (cadr seq-list))
               (value (fn first second)))
          (if (null? value)
              (iter (cddr seq-list) result)
              (iter (cddr seq-list) (cons value result))))))))


(define (klist->alist klist)
  "(klist->alist klist)

   Function convert klist in form (:foo 10 :bar 20) into alist
   in form ((foo . 10) (bar . 20))."
  (pair-map (lambda (first second)
              (if (key? first)
                  (cons (key->string first) second))) klist))

(define (h props . rest)
  (display props)
  (display rest)
  (cons (cons 'props props) (cons (cons 'rest rest) nil)))


(define (make-tags expr)
  `(h ,(key->string (car expr))
      (klist->alist (list ,@(cadr expr)))
      ,(if (not (null? (cddr expr)))
           (if (and (pair? (caddr expr)) (let ((s (caaddr expr))) (and (symbol? s) (eq? s 'list))))
               `(list->array (list ,@(map make-tags (cdaddr expr))))
               (caddr expr)))))


(define-macro (with-tags expr)
  (make-tags expr))

(define state '((count . 10)))

(define xxx (with-tags (:div ()
                             (list (:h1 () (cdr (assoc 'count state)))
                                   (:button (:onclick (lambda () (display "down"))) "-")
                                   (:button (:onclick (lambda () (display "up"))) "+")))))

но получил ошибку:

ОШИБКА: несвязанная переменная:: onclick

Я нашел решение длямой код, вот код:

(define (pair-map fn seq-list)
  "(seq-map fn list)

   Function call fn argument for pairs in a list and return combined list with
   values returned from function fn. It work like the map but take two items from list"
  (let iter ((seq-list seq-list) (result '()))
    (if (null? seq-list)
        result
        (if (and (pair? seq-list) (pair? (cdr seq-list)))
            (let* ((first (car seq-list))
                   (second (cadr seq-list))
                   (value (fn first second)))
              (if (null? value)
                  (iter (cddr seq-list) result)
                  (iter (cddr seq-list) (cons value result))))))))

(define (make-tags expr)
  (log "make-tags" expr)
  `(h ,(key->string (car expr))
      (alist->object (quasiquote
                      ;; create alist with unquote for values and keys as strings
                      ,@(pair-map (lambda (car cdr)
                                    (cons (cons (key->string car) (list 'unquote cdr))))
                                  (cadr expr))))
      ,(if (not (null? (cddr expr)))
           (if (and (pair? (caddr expr)) (let ((s (caaddr expr))) (and (symbol? s) (eq? s 'list))))
               `(list->array (list ,@(map make-tags (cdaddr expr))))
               (caddr expr)))))

Так что в своем коде я пишу какой-то мета-макрос, я пишу квазицитатуру в виде списка, который будет оцениваться так же, как если бы я использовал в своем исходном коде:

(klist->object `(:onclick ,(lambda () (--> actions (down 1)))))

Я использую alist->object и новую функцию pair-map, чтобы я мог заключить в кавычки значение и преобразовать символ ключа в строку.

- вот как это должно быть реализованов схеме?не уверен, если мне нужно исправить мой lisp или макросы там работают правильно.

...