a quasiquote implementation in newLisp

[jsmall]

The following macro and function define

a quasiquote / unquote mechanism in newlisp.



Note the use of uq and uq@.

Code Select Expand



  ;; usage:  (qq (x y (uq (+ 1 2)) (uq@ (list 1 2 3))))
  ;;  ==>  (x y 3 1 2 3)

  (define-macro (qq s-expr)
    (qq-eval s-expr))


  ;; Since qq is a macro you can't use (args) within.
  ;; Use qq-eval instead which is not a macro and thus
  ;; (args) will not capture the qq's (args).

  ;; usage:  (qq-eval '(x y (uq (+ 1 2)) (uq@ (list 1 2 3))))
  ;;  ==>  (x y 3 1 2 3)


  (define (qq-eval s-expr , i)
    (if (list? s-expr)
      (begin
        (setq i 0)
        (while (< i (length s-expr))
          (let ((ss-expr (nth i s-expr)))
            (if (list? ss-expr)
              (cond
                ((= 'uq (first ss-expr))
                  (nth-set i s-expr (eval (qq-eval (last ss-expr))))
                  (inc 'i))
                ((= 'uq@ (first ss-expr))
                  (let ((ss-exprs (eval (qq-eval (last ss-expr)))))
                    (if (list? ss-exprs)
                      (begin
                        (pop s-expr i)
                        (dotimes (j (length ss-exprs))
                          (push (nth j ss-exprs) s-expr i)
                          (inc 'i)))
                      (begin
                        (nth-set i s-expr ss-exprs)
                        (inc 'i)))))
                 (true
                   (nth-set i s-expr (qq-eval ss-expr))
                   (inc 'i)))
              (begin
                (inc 'i)
                s-expr))))
           s-expr)
      s-expr))





The following demonstrates the use of qq and qq-eval.

Code Select Expand



  ;; Abbreviation for lambda or fn

  (define-macro ( )
    (eval (qq-eval '(lambda (uq (first (args))) (uq@ (rest (args)))))))


  ;; Abbreviation for define

  (define-macro (: _var-or-fn _value)
    (if (list? _var-or-fn)
      (eval (qq-eval '(define (uq _var-or-fn) (uq@ (rest (args))))))
      (eval (qq (set _var-or-fn (uq _value))))))




Notice that qq is not used whenever (args)

appears in the expression being quasiquoted.



I'm hoping this makes writing macros more

convenient in newLisp.



Warning: I've only briefly tested this.

[Lutz]

>>>

;; Since qq is a macro you can't use (args) within.

>>>



its is the other way around macros *can* use (args) normal functions *can not*:



(define-macro (foo) (println (args)))



(foo 1 2 3) => (1 2 3)



(define (foo) (println (args)))



(foo 1 2 3) => ()



Lutz

[Lutz]

Consider also using 'ref' for looking up 'uq' or 'uq@' expressions. This is how a qq-macro could look like for just handling the unquoting of uq:

Code Select Expand


(define-macro (qq s-exp)
  (while  (set 'idx (chop (ref 'uq s-exp)))
      (set 'qx (pop s-exp idx))
      (push (eval (first (rest qx))) s-exp idx))
  s-exp)

;; now use it
(set 'x 'hello)

(qq ( (uq (+ 1 2)) ((uq (+ 3 4)) (uq x)))) => (3 (7 hello))

;; something similar could be done for 'uq@'


'ref' returns the index positions of an expresssion found in a nested list in an index-list, which can be used directly in 'pop' or 'push' which can take index lists. 'pop' and 'push' are inverse of each other. The same index-list used to pop something can be used to push something else back into the same position.



Lutz

[jsmall]

I've been working on the uq and uq@ using your code example:

Code Select Expand



(define-macro (qq s-exp)
  (while  (set 'idx (chop (ref 'uq s-exp)))
      (set 'qx (pop s-exp idx))
      (push (eval (first (rest qx))) s-exp idx))
  s-exp)

;; now use it
(set 'x 'hello)

(qq ( (uq (+ 1 2)) ((uq (+ 3 4)) (uq x)))) => (3 (7 hello))

;; something similar could be done for 'uq@'





1. It would be nice if "ref" had a version that took a predicate, e.g.

Code Select Expand



     (ref? (lambda (s-expr) (or (= 'uq s-expr) (= 'uq@ s-expr)))
            s-exp)



and returned the ref path along with the value returned by

the predicate.



2. Also if the continuation bookmark could be captured and

returned as well so that the depth first? search could continue

from where it left off that would also be nice.



Essentially my longer version was taking this approach (1 & 2) but

the size and speed advantage of your approach is obvious.