Hi. Need help with creating the ‘for’ macro. It must take a parameter, an initial value, an end value, and a loop step. Macro must return amount of iteration. Various operations should take place inside it. It should be designed without leaks.The preliminary version looks like this:

(defmacro for ((param-name start-value end-value &optional (step1 1)) &body body)
  (let* ((func-name (gensym))
(start (gensym))
(param-name (gensym))
(comparison (if (< step1 0) '< '>))
(end (gensym))
(step (gensym))
(k (gensym)))
'(labels ((,func-name (,param-name ,start ,end ,step ,k)
(let ((new-exprs (progn ,@body))
(newK (+ 1 ,k)))
(if (,comparison ,end ,param-name)
(,func-name (+ ,param-name ,step) ,start ,end ,step newK)
newK))))
(,func-name ,param-name ,start-value ,end-value ,step1 0))))

I understand that it looks terrible. I don’t understand how you can access the parameter without violating the rule about leaks.

  • lispm@alien.topB
    link
    fedilink
    English
    arrow-up
    1
    ·
    10 months ago

    why would evaluate the comparison? The comparison is a symbol, which a name for the function. Just use that symbol and insert it into the code.

    (defmacro for ((param-name start-value end-value &optional (step1 1)) &body body)
      (let* ((func-name (gensym))
             (comparison (if (< step1 0) '<= '>=))
             (start (gensym))
             (end (gensym))
             (step (gensym))
             (k (gensym)))
        `(let ((,start ,start-value)
               (,end ,end-value)
               (,step ,step1))
           (labels ((,func-name (,param-name ,k)
                      (if (,comparison ,end ,param-name)
                          (progn (progn ,@body)
                            (,func-name (+ ,param-name ,step)
                                        (1+ ,k)))
                        ,k)))
             (,func-name ,start 0)))))
    

    If you actually want to make sure that function does not get redefined, you need to understand that functions and variables are in different namespaces. You would need to get a function object and funcall it.

    (defmacro for ((param-name start-value end-value &optional (step1 1))
                   &body body)
      (let* ((func-name (gensym))
             (comp (gensym))
             (comparison (if (< step1 0) '#'<= '#'>=))
             (start (gensym))
             (end (gensym))
             (step (gensym))
             (k (gensym)))
        `(let ((,start ,start-value)
               (,comp ,comparison)
               (,end ,end-value)
               (,step ,step1))
           (labels ((,func-name (,param-name ,k)
                      (if (funcall ,comp ,end ,param-name)
                          (progn (progn ,@body)
                            (,func-name (+ ,param-name ,step)
                                        (1+ ,k)) ) ,k)))
             (,func-name ,start 0)))))
    

    But you don’t need that.

    If you want to debug macros, you need to see the expansion. Do it like this:

    CL-USER 14 > (pprint
                  (macroexpand
                   '(for (i start end)
                      (print i))))
    
    (LET ((#:G1788 START) (#:G1789 END) (#:G1790 1))
      (LABELS ((#:G1787 (I #:G1791)
                 (IF (>= #:G1789 I)
                     (PROGN
                       (PROGN (PRINT I))
                       (#:G1787 (+ I #:G1790) (1+ #:G1791)))
                   #:G1791)))
        (#:G1787 #:G1788 0)))