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

[REBOL] Re: The truth about scope

From: mokkel:gmx at: 16-Apr-2005 2:06

Hi Gabriele, (or whoever dares to read this :-) - I appologize for the length beforehand ) sorry for the wrong name, I should have seen it in the e-mail address. I guess I got now the model correctly, also with the different views, which have come up during the thread. I tried to create below some small showcase of how Rebol works, if I'm not too wrong that should be pretty all. If one adds evaluation of words and their different types, then this should be the basic components. Of course during evaluation things get much more complicated, but the basic issues should be like that. 1) - every Rebol object is somehow put into or referenced from a container (gets the name value-slot - for now) - a block is simply a list (however implemented) of value-slots ------------------------------------------------------- e.g. [1 "hallo" a] -> [(1) (|,1) (a)] | | | (unset!) | (h)-(a)-(l)-(l)-(o) () = represents a value slot (|,0) = a pointer to some other slot and with series position (1) = value slot with native value (a) = value slot with word which references a value slot a: 5 [1 "hallo" a] -> [(1) (|,1) (a)] | | | (5) | (h)-(a)-(l)-(l)-(o) 2) words have a context, which is a mapping of words with different spelling to a value-slot (in the most extreme case just to one value-slot if every words referes to the same ------------------------------------------------ a: b: c: 1 d: next "hallo" context-table: word -- value-slot a --\ b -- (1) c --/ d -- (|,2) | (h)-(a)-(l)-(l)-(o) 3) creating new objects out of other object simply copies its value-slot --------------------------------------------------------- a: 5 bl: [a 1 "hallo"] bl2: [] append bl2 bl bl -> [(a) (1) (|,1)] | | (5) | | (h)-(a)-(l)-(l)-(o) | | | | bl2 -> [(a) (1) (|,1)] 4) binding a word to a new context simply changes the pointer to the value-slot of the word in the new context ----------------------------------------------------------- a: 1 c: context [a: 5] bl: [a] global-context-table: word -- value-slot a -- (1)* c -- (|) ;references a block of dataelements | [(a:) (5)] bl-- (|) | [(a)] | (1)* ;is the same value-slot as in the context table, thus a is bound to global context c-context-table: word -- value-slot a -- (5)*** binding 'a in the block 'bl to context of block attached to 'c bind bl in c 'a bl -> [(a)] | (5)*** ; bound to the context of the block attached to 'c or via global context-table global-context-table: word -- value-slot a -- (1)* c -- (|) | [(a:) (5)] bl-- (|) | [(a)] | (5)*** ; bound to the context of the block attached to 'c 5) obviously words with the same spelling in the same context reference the same value-slot ---------------------------------------------------------------------------- a: 1 bl: [a a] c: context [a: 5] append bl bind 'a in c 'a append bl bind 'a in c 'a bl -> [(a) (a) (a) (a)] \ / \ / \ / \ / (1) (5) global-context-table: word -- value-slot a -- (1) bl-- ..... c -- ..... c-context-table: word -- value-slot a -- (5) Maybe I was mainly so confused because the double pointer analogy is helpful only when one thinks of values as attached directly to words, then the indirection layer is needed, to make clear that it's just a place which is referenced. If one thinks like above then they are not necessary (as a desciption). I stumbles over another interesting binding issue and I guess it also proves the above description (and what you wrote). E.g. why 'bind is not able to in-place bind a single word like bl: [a b] c: context [a: 5] bind first bl in c 'a ; the 'a in 'bl would be supposed to be bound to the context This looks quite logical actually. The next would make less sense: a: 2 a: 1 c: context [a: 5] bind 'a in c 'a ; Which 'a to bind? But when one thinks about the code=data duality and thinks in value-slot terms, its logical that neither of the two examples above can work. The first would look like: (bl:) [(a) (b)] (c:) (context) [(a:) (5)] (bind) (first) (bl) (in) (c) ('a) the last line reduces for evaluation to (bind) (a) (in) (c) ('a) ;just for this example, there happens more of course So we got actually a word 'a in a value-slot and again there is no sense where 'a belongs to, it has no place. On the opposite with a block we would have: bl: [a] c: context [a: 5] bind bl in c 'a -> (bl:) [(a)] (c:) (context) [(a:) (5)] (bind) (bl) (in) (c) ('a) | [(a)] ; so we can change a word in a block, and only this word So this time we have a word to reference (indirectly) and due to the reference character of blocks it will stay referenced (if we have a reference of course). In the first case because the value-slots are always copied when a new value-slot is created due to some action, it wouldn't work, because we can't keep a reference to a single particular word (there are no "instances" of words - as I understood it in a previous post and now has been clarified). So thanks a lot for the patience. :-) Michael