Mailing List Archive: 49091 messages
  • Home
  • Script library
  • AltME Archive
  • Mailing list
  • Articles Index
  • Site search

[REBOL] problems with local vars??? Re:(6)

From: larry:ecotope at: 18-Aug-2000 17:34

Hi Galt You raise some interesting questions. I don't have time right now to go into much detail on this, so just a couple of quick comments.
> p.s. although Rebol may be "interpreted", > the body and params and etc. have been fully > "load"-ed and that means they are like typed > tokens and bound words that are ready to roll.
make function! which can be used directly and is called by 'func and 'function takes two block args: spec and body. The spec block contains a spec which is a REBOL dialect. It is parsed (internally) with the spec dialect rules to determine the meaning. make function! creates a local enviroment or frame with bindings for the local words. The local words include each arg, each refinement (as a word!), each refinement arg, as well as each local specified with /local. These are all bound locally and have the value unset!. When the function is executed, the interpreter evaluates the refinements to true or false, and evaluates the args and refinement args and binds the local words in the local frame to those values or, as appropriate to none. The interpreter then simply evaluates 'do body-block. third :f gives the original spec and first :f gives the word list including /local to separate those values specified with local. In both cases, the words in the returned block are not bound to the local context of the function. These are "dead" blocks, the original versions in the function cannot be modified by appending something to the "dead" blocks. In other words, the spec cannot be modified after the function is created, it is used during the function creation process (i.e. by make). After creation, these blocks provide reflective info about the function. Of course, they *can* be used to create a new function with the same spec or with a modification of the spec. second :f is different. It returns a "live" block of code (the body) with the contained words bound to the local frame of the function f. This block of code can be modified with and extended (with append etc. using 'bind if necessary) after the function is created. It seems clear that the interpreter executes the function by 'do-ing this body block.
> It's not like a lot of simple interpreters which are converting > straight from source as just a string of characters > for each and every line.
Well, it is not a string, it is a block defined within a context.
> when the function definition is executed > that baby creates the function! value and > assigns it to the function's name word, > and that value sure isnt just a string! of code.
As above, I think the body is a block of code with words bound in a private frame, which *is* actually evaluated by the interpreter each time the function is called. Of course, the arg values are bound to the local words first. Recursion requires more explanation. See some of the recent posts on contexts by Ladislav.
> so that makes sense and the interpreter can run > pretty fast. I am sure that it is the same > with Logo, Lisp, Scheme, etc... I think the > series type is also something that helps make > Rebol fast. I don't recall seeing its like > in those other cousins of Rebol.
REBOL blocks and more generally series combine the access and modification features of Scheme lists (head, tail, next, first) and Scheme vectors (pick, poke, at). Most of the above is just my current best guess about how function creation works. Cheers -Larry --------snip