World: r3wp

>> probe get a/w
native

Heh! :-) I'm not so sharp today.

In the code above, I make an object which has a local word 'print 
(with a local value "local"), and another word 'w whose value is 
LOADed from the string "print" (which becomes the word 'print). This 
new word is bound to the global context. Where else could it be bound 
? The word 'load in the block above is not bound to the context I 
made, it retains its global binding (which is why it actually does 
what we expect it to).

I was doing this:
a: context [w: load "print"]
get a/w


Same thing. I understand you now, Anton. The words know, what context 
they're bound to. So it should all just be sorted out with BIND. 
And BIND can be confusing (at leat I find it confusing now and then).

Yes, the "invisible links" of bind can be confusing.

Thanks for the explanation! :-)

np

And we can make our own LOAD to do, what we want: :-)


>> c: context [print: "local" load: func [w] [bind to block! w self 
w] w: load "print"]
>> type? c/w
== string!
>> c/w
== "print"

Argh, that should return "local", shouldn't it? :-D

BIND is hard! Period! ;-)

This does it (I think):

>> c: context [print: "local" load: func [w] [first reduce bind to 
block! w self] w: load "print"]                                  
                           
>> c/w
== "local"

Maybe someone will know if this is possible.  I want to be able to 
set a value when parsing outside a function to a local value in context 
of a funciton.  I can do this with an object but want to know how 
to do it with a function.  Here is the object method:

a: [1]
b:  context [c: none]
parse a compose [set (in b 'c) integer!]

>> b/c
== 1

I want to be able to instead of having b as an object be able to 
have b as:    b: func [val /local s][print val + s]   where I want 
to set 's from the parsing.

I found, that making my own version of LOAD in a context in another 
way worked:

>> c: context [print: "local" my-load: :load w: my-load print]
>> c/w
== local
>> type? c/w
== word!

But it doesn't work as Henrik would like in a REPEAT block:

>> a: [(i)]
== [(i)]
>> repeat i 5 [print i my-load: :load compose my-load mold/all a]
1
** Script Error: i has no value

Paul; you've read through the Ladislav articles?  tfunc and lfunc 
and his Bindology paper?   http://www.fm.tul.cz/~ladislav/rebol/

I have read a lot of his stuff but not sure I ever read this.  I'll 
take a look into it.  Thanks Brian.

Paul, you need to do something like this:
	parse a compose [set (first second :f ) integer!]

where f is a function, second :f gives you the function's body, and 
FIRST picks a local word which just happens to be in first position 
in the body block. You will have to change FIRST to whatever navigates 
to a local word.

Example, given a function:
	f: func [var][
		print var: 10
	]

then you will navigate to the 'var: set-word in the function body 
like so:
	second second :f
because 'var: is in second position, after the 'print word.

(it doesn't matter that it's a set-word and not a word, you can still 
set it and bind to it, etc)

We can test this:
	set second second :f 20
	get second second :f
	; == 20
	?? f
	f: func [var][
		print var: 10
	]

Notice the 10 value is still the same (we didn't touch it.) But we 
know the 'var: set-word is 20 thanks to our setting it above. If 
the function is now evaluated it will not stay that way, obviously.

Keep in mind that the words local to a function's context are only 
really valid during the execution of the function. When referred 
to from outside the function, their bindings are valid but their 
assigned values are not, and will be overridden on next run.

This is even more the case in R3.

Much of the code in Ladislav's article wouldn't work in R3, because 
of the changes in functions and the different reflective accessors.

thanks Anton, I had tried that but I want to do something a bit differently. 
 I want to set a functions /local word instead of its arguments.

It's the same method; all of the words (including the /local refinement) 
in the following function spec are local to the function's context:

	func [arg /local var]

I tried it Anton and it didn't work.  I'm trying from within the 
same function.

I'm going to investigate other possible ways of doing it wonce I 
get a chance.

Ok, but did you navigate to the local word properly ?

Yes, but what I think the problem is that I need to do the setting 
of the word from within.

Perhaps you can show us the actual function, and the code which tries 
to set the word. I know this is entirely possible, and especially 
so if you are the author of the function involved.

I'm debugging my debugger right now. For some reason it does not 
log certain lines of debug information. The method I use is:

write/binary/append %debug-file.r string


By probing it in console, I get the correct output, but the same 
lines are always missing in the disk version. Would there be any 
time this write would not occur?

Maybe the write is occurring but the 'string is not containing anything?

I will check again with another probe

those lines are just not saved

write/binary/append %debug-file.r probe string

will print the string in the console, but it's not saved

You confirmed that 'string contains data and not just ""

this can't be... there _has_ to be something else wrong :-)

yes, but I have to check some other things now too

definitely not being saved

I'm suspecting a file lock problem, but if it was locked, one would 
think that REBOL would return an error on write.

Yeah I think it would.

is some lines writing while others aren't?

yes, it's always the same lines

Change the order of the lines and see if the same lines fail.

I was wondering why there was a "black hole" in the log where I expected 
something important to happen.

Maybe even number them to see if there is a pattern to what lines 
are not being saved.

good idea

ah

the 11th commandment: thou shalt not change-dir in the middle of 
a file save. :-)

lol