This is odd:
graph
graph> (define (foo x y z) {...})
(lambda (x y z) "...")
graph> (set 'var 123)
123
graph> (symbols)
(foo var x y z)
graph> ; What are 'x, 'y, & 'z doing in there?
You may recognize this as the manual's example from the
Defining functions within MAIN caused the symbols I used for the parameters to be added to MAIN, as well. The "locals" from the likes of
Actually, I've been playing with ways of hiding these symbols (using contexts variously called
m i c h a e l
P.S. I recently installed 8.8.6, and for this test I commented out my init.lsp file. I'm not sure if this was happening in 8.8.5.
The definition of 'foo' is done while the current context is 'graph', so they are correctly added to the 'graph' context. Inside the 'graph' context 'x','y' and 'z' are treated as dynamically scoped variables but in their own lexical space isolated from other contexts like MAIN
Ther are also local in their behaviour as function parameters of 'foo':
> (context 'graph)
graph
graph> (define (foo x y z) (+ x y z))
(lambda (x y z) (+ x y z))
graph> (set 'x 1 'y 2 'z 3)
3
graph> (foo 10 20 30)
60
graph> x y z
1
2
3
graph>
(context MAIN)
> x y z
nil
nil
nil
After 'foo' was used 'x','y' and 'z' still have theire original values of 1 2 3, but duing the scope of 'foo' they where 10 20 30.
Lutz
ps: where did you see in the manual the contrary?
... more on symbols:
There is a MAIN symbol tree
MAIN:
abs
acos
...
graph:
foo
x
y
z
write-line
x
y
z
xml-parse
xml-type-tags
and their are subtrees hanging of context symbols, part of MAIN (like graph). So there are actually to sets of 'x','y' and 'z' one in MAIN and another one in 'graph:'.
symbols are created in their current context as soon as they are 'seen' during loading of a program or as soon as you type them. And they are created in the current context. In their own context they behave according the rules of dynamic scoping. Their contents changes 'dynamically' during funtion execution if function parameters. But each context is a lexical unit by itself and protected from symbols of same name in other contexts/namespaces.
The default function 'foo' from our previous example is just syntactic sugar for 'foo:foo' to make it feel as in the current space, so (foo ...) behaves as if statically scoped, because its really (foo:foo foo:x foo:y foo:z) with it's parameter variables isolated from 'MAIN' and all name spaces not 'foo'
Lutz
Hi Lutz. Thank you for taking the time to explain this to me. I'm still reading through your responses for comprehension ;-)
Quote from: "Lutz"
I found this as
m i c h a e l
Thanks, found it, I was looking in the Users Manual part in the Contexts section, will be corrected, as you mentioned it should be:
(foo-draw var x y z)
Lutz