I don't understand what I'm doing wrong here. Is it variable capture?
Using the example from the define-macro description in the newLISP doc I wrote two identical test functions, apart from the name of the parameter:
(letex (var (args 0 0)
lst (args 0 1)
cnd (args 0 2)
body (cons 'begin (1 (args))))
(let (res)
(catch (dolist (var lst)
(if (set 'res cnd) body (throw res)))))))
(define (test1 a-list)
(dolist-while (x a-list (!= x 'd)) (println x)))
(define (test2 lst)
(dolist-while (x lst (!= x 'd)) (println x)))
(test1 '(a b c d e f))
(test2 '(a b c d e f))
here is the output
>
(lambda-macro ()
(letex (var (args 0 0) lst (args 0 1) cnd (args 0 2) body (cons 'begin (1 (args))))
(let (res)
(catch
(dolist (var lst)
(if (set 'res cnd)
body
(throw res)))))))
(lambda (a-list) (dolist-while (x a-list (!= x 'd)) (println x)))
(lambda (lst) (dolist-while (x lst (!= x 'd)) (println x)))
a
b
c
nil
ERR: list expected in function dolist : lst
called from user defined function dolist-while
called from user defined function test2
>
Think so. It looks like the same example as here:
//http://en.wikibooks.org/wiki/Introduction_to_newLISP/Macros#Symbol_confusion
and the fix should be the same...
The example is wrong but can be fixed this way:
(define-macro (dolist-while)
(letex (var (args 0 0)
lst (eval (args 0 1))
cnd (args 0 2)
body (cons 'begin (1 (args))))
(let (res)
(catch (dolist (var 'lst)
(if (set 'res cnd) body (throw res)))))))
Note the
The variable capture happened during expansion of the
But having
ps: the example is also fixed in the online manual.
Hi and thanks both for replying. I'm still trying to puzzle it out.
I don't quite get why your fix, Lutz, affects just the lst variable. Why aren't the other variables susceptible to the same problem?
They are not a problem only in this function.
There is a second potential trap with the
Probably the example should be taken out of the manual completely. Or only the safe solution should be shown with the function in it's own namespace.
Quote from: "Lutz"
Exactly.
Sometimes I think we need a "Style Guide" defining certain conventions, how to use newLISP's feature set. Then again, I think that would be a bad thing. One of the things many newLISP users are attracted to, is it's malleability and flexibility, which is also the reason that so many people from creative professions like newLISP.
newLISP gives you the freedom to express the same functionality in different ways and styles, without trying to box you into the "one right way" of doing things.
But definitely, there are conventions emerging from the community. Enclosing define-macro's in their own namespace, is one convention frequently adopted.
I am a newLISP noob. There is almost nothing I understand of the culture. I thought I was using the style suggested in the article //http://www.newlisp.org/downloads/newlisp_manual.html#define-macro. I thought it meant: use letex with args to avoid variable capture. I'm still confused. I don't understand why only lst is affected. In fact, this
(println "test3")
(dolist-while (x '(a b c d e f) condition) (println x)))
(define (test4 cnd)
(println "test4")
(dolist-while (x '(a b c d e f) cnd) (println x)))
(test3 nil)
(test4 nil)
gives this
test3
nil
test4
a
b
c
d
e
f
f
In fact, I can't work out how to safely use args in a macro at all. E.g.
(let ((x 3))
(println "(args 0)=" (args 0) " x=" x " (eval(args 0))=" (eval(args 0)))))
(define (foo y)
(ant y))
(define (bar x)
(ant x))
(foo 7)
(bar 7)
gives
(args 0)=y x=3 (eval(args 0))=7
7
(args 0)=x x=3 (eval(args 0))=3
3
Hello ant,
This seems to work (the macro definition is the same as your original on this thread
(define-macro (dolist-while:dolist-while)
(letex (var (args 0 0)
lst (args 0 1)
cnd (args 0 2)
body (cons 'begin (1 (args))))
(let (res)
(catch (dolist (var lst)
(if (set 'res cnd) body (throw res)))))))
(context 'MAIN)
> (test3 nil)
test3
nil
> (test4 nil)
test4
nil
Don't know why, but it seems that you have to have those
______________
- -- Not *exactly*. The definition is the same as your original except for the "dolist-while:" qualification. Leave that out and newLISP will complain about the symbol being protected.
The problem with the
Your last example behaves as expected per the rules of dynamic scoping: the variable
But
(let (a (eval (args 0)) b (eval (args 1))) (+ a b)))
(set 'a 3 'b 4)
> (my-add a b)
7
> (my-add b a)
7
In all other cases, put the
If you feel uncomfortable to program in a dynamically scoped environment, do the following:
(1) Never pass quoted symbols into functions. To pass references, use contexts, default functors.
(2) Never use free variables inside a function, except for variables clearly marked for global usage by some naming convention.
(3) Always put define-macros's in their own namespace. Or ignore them completely. They are not an essential newLISP feature as
Now, newLISP will behave like a lexically scoped language. If you are looking for a closure-like mechanism study this page for alternatives in newLISP:
http://www.newlisp.org/index.cgi?Closures
I think I'm starting to understand. Thank you every one who patiently explained and suggested alternatives.
I'm using macros because I'm passing large-ish objects around (bitmaps) and for performance reasons I don't want newLISP to create a copy of these objects every time I call a function passing one as an argument.
Possibly my problem was that when I read the doc on define-macro it said (still says) you can avoid variable capture by using (args n), but it didn't mention all the various caveats that I now have a little more understanding of thanks to this thread.
Pass your bitmap around like this:
(define (process-bitmap bitmap)
...
...
)
(process mybitmap)
it's now passed by reference.
Or you could do something like this:
(set 'mybitmap:config other-stuff)
(define (process bitmap)
; do something with bitmap:data
; and with bitmap:config
)
(process mybitmap)
last not least, look into FOOP, which also passes objects by reference.
My experience is that dynamic scope almost never causes the problems. I think it happened to me something like two times in last four years, and then I fixed it easily. I have two functions in my library,
(protect1 'my-function '(x y)) ; in case I want overshadowing of z, say, it is some global counter
and that
(lambda(function/macro-name definition-code variables)
(set function/macro-name
(expand definition-code
(map (lambda(x)
(list x (sym (string function/macro-name "." x))))
variables)))))
(set 'protect1 (lambda(function/macro-name variables)
(set-protected1 function/macro-name
(eval function/macro-name)
variables)))
;-------------
; your code with additional 'protection'
(define-macro (dolist-while)
(letex (var (args 0 0)
lst (args 0 1)
cnd (args 0 2)
body (cons 'begin (1 (args))))
(let (res)
(catch (dolist (var lst)
(if (set 'res cnd) body (throw res)))))))
(protect1 'dolist-while '(var lst cnd body res))
(define (test1 a-list)
(dolist-while (x a-list (!= x 'd)) (println x)))
(define (test2 lst)
(dolist-while (x lst (!= x 'd)) (println x)))
(test1 '(a b c d e f))
(test2 '(a b c d e f))
;----------------
It works.
Here is how your macro looks like after 'protection':
(letex (dolist-while.var (args 0 0) dolist-while.lst (args 0 1) dolist-while.cnd
(args 0 2) dolist-while.body
(cons 'begin (1 (args))))
(let (dolist-while.res)
(catch
(dolist (dolist-while.var dolist-while.lst)
(if (set 'dolist-while.res dolist-while.cnd)
dolist-while.body
(throw dolist-while.res)))))))
In most cases, I do not use that
This solution is equivalent to officially recommended use of contexts.
Very rarely, accidental overshadowing might happen between two instances of the same function or macro (if function calls itself recursively.) It is particularly severe form of the name overshadowing, it cannot be solved with
With very little experience, one learns how to prevent accidental overshadowing, and problems are very rare in practice.
Thanks again for the suggestions. I have a lot to learn!