Binding a changed function within a context

Hi, List, I am working on an enhanced version of a field widget. In order to get the enhanced functionality, I need to modify a function within the context of edit-text in REBOL. The code is too long for easy use on the list (in my opinion), so I have created a very simple example that (hopefully) recreates the problem in the "small." Here is my hypothetical context. It contains a local variable and a function that prints that variable. my-context: context [ local-var: 5 my-func: does [ print local-var ] ] where then executing: my-context/my-func ;yields 5 Now, let us say that I wish to dynamically change the function in this object to the following: my-func: does [ print ["new print" local-var] ] where my-func will be bound into the context of my-context. For your ease in running the code samples, I have included the original context object with each example. In my non-hypothetical case, the shortest code method would be to change the code in place like: ;### Method 1 ;original my-context: context [ local-var: 5 my-func: does [ print local-var ] ] ;make change insert remove remove pick pick pick my-context 2 3 2 [print ["new print" local-var]] This makes my-context "look" correct (meaning that the data representation of the code is correct when viewed with probe), but the inner function is not bound into the context: my-context/my-func ;expectedly yields an error For completeness (to be sure that I understood the precept behind bind), I also directly reassigned the function: ;### Method 2 ;original my-context: context [ local-var: 5 my-func: does [ print local-var ] ] ;make change my-context/my-func: does [ print ["new print" local-var] ] and again confirmed that an error occurs with my-context/my-func, because it has not been bound into the context. In the past, my tried and true way to make it work has been to "re-make" the object with the new function: ;### Method 3 ;original my-context: context [ local-var: 5 my-func: does [ print local-var ] ] ;make change my-context: make my-context [ my-func: does [ print ["new print" local-var] ] ] which then works correctly when executing my-context/my-func (yields "new print 5"). I understand the basic concepts behind scope and binding, and how these play out in REBOL. It seems as though it should be easy enough to use bind, but I can't figure out how to (successfully) do this when changing a function within a context, at least with methods 1 and 2. Nothing wrong with method 3, but I would love to also be able to use method 1 or 2 with a strategically and correctly placed bind statement. Any ideas? --Scott Jones

Not a general solution but given you are talking about edit-text, you could try something like: my-context: context [ local-var: 5 my-func: does [ print local-var ] ] my-context/my-func: does bind [ print ["new print" local-var] ] in my-context 'self Regards, Brett.

Hi Scott, On Saturday, October 5, 2002, 2:27:53 PM, you wrote: GSJ> ;### Method 1 GSJ> ;original GSJ> my-context: context [ GSJ> local-var: 5 GSJ> my-func: does [ GSJ> print local-var GSJ> ] GSJ> ] GSJ> ;make change GSJ> insert remove remove pick pick pick my-context 2 3 2 [print ["new print" GSJ> local-var]]

>> insert remove remove pick pick pick my-context 2 3 2 bind [print ["new print" local-var]] in my-context 'self

>> my-context/my-func

>> my-context/my-func: does bind [print ["new print" local-var]] in my-context 'self >> my-context/my-func

Hi, Brett and Gabriele, From: "Brett Handley" ...

> my-context: context [ > local-var: 5 > print ["new print" local-var] > ] in my-context 'self

> insert remove remove pick pick pick my-context 2 3 2 bind [print ["new

> my-context/my-func: does bind [print ["new print" local-var]] in

Hi Gabriele,

>>> my-context/my-func: does bind [print ["new print" local-var]] in my-context 'self >>> my-context/my-func > new print 5

>> bind [print ["new print" local-var]] in my-context 'self

>> probe self

>> type? self

Hi Laurent, On Saturday, October 5, 2002, 6:51:14 PM, you wrote: LG> reading your second example I came to the conclusion that 'bind must actually do LG> the binding then return the exact words it was passed as parameters. It changes the argument block (unless the /COPY refinement is used) and returns it. LG> First of all, in that test the word "self" is used in a context where it seems LG> to be innapropriate (there is no object lying around) : what does 'self refer to LG> in such a case ? First of all, notice it is a lit-word, and not a word. I.e. if you write:

>> 'self

>> help in

> For better readability, one could write: > bind-to-object: func [block object] [bind block in object 'self] > and use that instead.

For amusement, below are some examples of words bound to different contexts. Just move throught the code by copying from the email and pasting bits of it at a time into the console. Regards, Brett. ; ; Amusement 1 ; ; BIND matches up words it can find in the target context. ctx-1: context [country: "Australia"] ctx-2: context [city: "Sydney"] ctx-3: context [name: "Brett"] expression: [join name [{ lives in } city {, } country]] repeat ctx reduce [ctx-1 ctx-2 ctx-3] [bind expression in ctx 'self] print expression ; ; Functions create a new context binding the words of their body block ; to their arguments: my-func: func [name] expression my-func "My wife" ; ; Amusement 2 ; ; This first bit is straight forward - what appears to be ; nesting of contexts. As others have pointed out (probably ; more clearly than me) this is an effective or apparent ; nesting. ctx-1: context [ word-a: #1a word-b: #1b word-c: #1c ctx-2: context [ word-a: #2a word-b: #2b ctx-3: context [ word-a: #3a set 'print-it does [ print ["First function" word-a word-b word-c] ] ] ] ] print-it ; ; We can simulate the apparent scoping of CONTEXT with ; script that is obviously not nested... ; ctx-1: context [word-a: #1a word-b: #1b word-c: #1c] ctx-2: context [word-a: #2a word-b: #2b] ctx-3: context [word-a: #3a] contexts: reduce [ctx-1 ctx-2 ctx-3] expression: [print ["Expression" word-a word-b word-c]] repeat ctx contexts [bind expression in ctx 'self] do expression ; ; Or indeed reverse it, or perhaps do other odd ; bindings. ; reverse contexts repeat ctx contexts [bind expression in ctx 'self] do expression ; ; Amusement 3 ; ; REBOL represents words to you using ; their names but does not have a visual representation for ; the context of those words. ; When you print the mold of the expression of this example ; you cannot see the difference between the two words that ; have the same name 'sample-word. ; Philosophical point: ; It is easy to fall into the trap of mistaking the name ; of a thing for the thing itself. As always with REBOL, ; the items you see in the console or in a file are not ; the things themselves but representations of the things. ctx-1: context [sample-word: "Context1"] ctx-2: context [sample-word: "Context2"] expression: [{A word: }] append expression in ctx-1 'sample-word append expression [{^/A different word with the same name: }] append expression in ctx-2 'sample-word print expression ; This last example was admittedly contrived, and you ; wouldn't expect to see it used much. But I think ; it has value in showing a different way to look at ; REBOL words.