> Hmm, read-macros seem indeed a lot misunderstood. NEVER use a
> read-macro to insert values which are defined at *run*time! As the
> name says, they are evaulated at *read* time!
Maybe I too have been misunderstanding all along. Alex, you seem to
be inferring here a strict separation between readtime and runtime;
however, I see "eval process" as "intertwining" them.
So, are you saying that the following is a kind of "abuse" (since I am
"insert[ing] values which are defined at *run*time" with a *read*
macro) and that it gives me the answer I'm looking for is some kind of
happy coincidence (despite my misunderstanding of the eval model)? :)
? (let X (+ 3 4) (glue " " '("Number" `X `(- 4 9))))
-> "Number 7 -5"
Or this, even?
? (let X (+ 3 4) (glue " " '("Number" `X `(- X 9))))
-> "Number 7 -2"
It seems to me that *read*ing is inherently involved in *run*time (the
"eval process", which is recursive of course).
For instance, X in the above expressions is at some point, in the
"eval process", bound to 7 before the expression
'("Number" `X `(- X 9))
is evaluated, and that the evaluation of this expression goes through
a reckoning of read macros first (under the "context" of the current
runtime environment which has X bound to 7).
If so, aren't then the `let` expression usages above *not*
Or am I thinking about this incorrectly? Thanks!