For example, I have function stack-push which pushes element onto the stack.
(defun stack-push (stack element)
(if (not (listp element))
(setf stack (cons element stack))
(dolist (current-el (reverse element))
(setf stack (cons current-el stack)))))
But when I invoke it like (stack-push *some-stack* '(a b c d e)), it doesn't affect on *some-stack*. Could you explain why?
setf with a symbol as place like (setf stack (cons element stack)) expands to (setq stack (cons element stack)). This usually happens when you create your function. Your function becomes this:
(defun stack-push (stack element)
(if (not (listp element)
(setq stack (cons element stack))
(dolist (current-el (reverse element))
(setq stack (cons current-el stack)))))
Note that I have only expanded setf here. Both defun and dolist becomes quite horrendous expansions that makes the code more unreadable. The system expands the forms fully so the code that runs has no macros.
setq updates a binding so when it updates stack that is what it updates, not *some-stack*. Here is exactly what is happening if you do (stack-push *some-stack* "a"):
*some-stack* and "a". It evaluates its arguments. *some-stack* evaluates to address A that has a cons cell eg. ("b")."a" is a literal residing at address Bstack points to A and element points to B. element points to B (not (listp element)) ; ==> t and the code follows the consequent.(setf stack (cons element stack)) was before runtime changed to (setq stack (cons element stack)). (cons element stack) calls cons with B and A as arguments. returns a new cell with address C ("a" "b")setq updates so that binding stack points to C. stack-push returns the last evaluated value, which is the result of the setq which is the second argument C. In the function there is no mention of *some-stack*. The binding is never references or updated. Only stack is updates with what new value to point to.
As a consequence of this being a function you can call your function with literals, which normally would not work if the argument was a variable meant to be updated.
(stack-push '("b") "a") ; ==> ("a" "b")
There is a form called push. It is not a function. You can see what it does:
(macroexpand '(push "a" *some-stack*))
; ==> (setq *some-stack* (cons "a" *some-stack*))
Thus for push to work you need that second argument is something setf-able. Trying it with literals expands to unrunnable code. For types you can make your own setf expander such that setf and push works.
As a note to Sylwester's answer, here is a version of your stack-push which at first sight looks correct but which in fact has an ugly problem (thanks to jkiiski for pointing this out!), followed by a simpler version which still has the problem, and finally a variant of the simpler version which does not.
Here is the initial version. This agrees with your signature (it takes either a single argument which cannot be a list, or a list of arguments, and decides what to do based on what it sees).
(defmacro stack-push (stack element/s)
;; buggy, see below!
(let ((en (make-symbol "ELEMENT/S")))
`(let ((,en ,element/s))
(typecase ,en
(list
(setf ,stack (append (reverse ,en)
,stack)))
(t
(setf ,stack (cons ,en ,stack)))))))
However I would be more tempted to write it with an &rest argument, as follows. This version is simpler because it always does one thing. It is still buggy though.
(defmacro stack-push* (stack &rest elements)
;; still buggy
`(setf ,stack (append (reverse (list ,@elements)) ,stack)))
This version could be used as
(let ((a '()))
(stack-push* a 1 2 3)
(assert (equal a '(3 2 1))))
for instance. And it seems like it works.
But it doesn't work, because it can multiply-evaluate things which should not be multiply-evaluated. The easiest way (I found) to see this is to look at what the macro expansion is.
I have a little utility function to do this, called macropp: this just calls macroexpand-1 as many times as you ask for, pretty printing the result. To see the problem you need to expand twice: first to expand stack-push* and then to see what happens to the resulting seetf. The second expansion is implementation-dependent, but you can see the problem. This sample is from Clozure CL which has a particularly simple expansion:
? (macropp '(stack-push* (foo (a)) 1) 2)
-- (stack-push* (foo (a)) 1)
-> (setf (foo (a)) (append (reverse (list 1)) (foo (a))))
-> (let ((#:g86139 (a)))
(funcall #'(setf foo) (append (reverse (list 1)) (foo (a))) #:g86139))
And you can see the problem: setf doesn't know anything about foo so it's just calling #'(setf foo). It carefully makes sure that the subforms are evaluated in the right order, but it just evaluates the second subform in the obvious way, with the result that (a) gets evaluated twice, which is wrong: if it has side-effects then they will happen twice.
So the fix for this is to use define-modify-macro whose job is to solve this problem. To do this, you define a function which makes the stack, and then use define-modify-macro to make the macro:
(defun stackify (s &rest elements)
(append (reverse elements) s))
(define-modify-macro stack-push* (s &rest elements)
stackify)
And now
? (macropp '(stack-push* (foo (a)) 1) 2)
-- (stack-push* (foo (a)) 1)
-> (let* ((#:g86170 (a)) (#:g86169 (stackify (foo #:g86170) 1)))
(funcall #'(setf foo) #:g86169 #:g86170))
-> (let* ((#:g86170 (a)) (#:g86169 (stackify (foo #:g86170) 1)))
(funcall #'(setf foo) #:g86169 #:g86170))
And you can see that now (a) is only evaluated once (and also that you only now need a single level of macroexpansion).
Thanks again to jkiiski for pointing out the bugs.
macroppFor completeness, here is the function I use to pretty-print macro expansions. This is just a hack.
(defun macropp (form &optional (n 1))
(let ((*print-pretty* t))
(loop repeat n
for first = t then nil
for current = (macroexpand-1 form) then (macroexpand-1 current)
when first do (format t "~&-- ~S~%" form)
do (format t "~&-> ~S~%" current)))
(values))
