World: r3wp

Yes, but second FUNC doesn't return the function word. So where is 
this link kept? Or is the reference to the func body bound?

example:
>> blk: reduce [in system 'options in face 'options]
== [options options]
>> type? get blk/1
== object!
>> type? get blk/2
== none!

Are you talking about the words you have set to function values ? 
eg:   my-word: func [][]

Each word has a single value slot (per context).

If I'm binding SECOND FUNC the body's reference is used, so this 
particular block is bound. Not a copy.

Correct.

Ok.

The 'blk part doesn't work. I get an error for SECOND

Did you put function! values into the funcs input block ?

eg:
>> my-func: func [arg][print arg]
>> funcs: reduce [:my-func]
>> type? first funcs
== function!

Hmm... it's not working....

It doesn't look as simple operation as I thought...

That's weird. When you insert the function body into another block 
for binding it doesn't work. These two examples are not producing 
the same result:

>> ctx-A: context [a: 60]
>> my-func: func [][a: 5]
>> bind second :my-func ctx-A
== [a: 5]
>> ?? ctx-A
ctx-A: make object! [
    a: 60
]
>> my-func
== 5
>> ?? ctx-A
ctx-A: make object! [
    a: 5
]

>> ctx-A: context [a: 60]
>> my-func: func [][a: 5]
>> blk: [] append blk second :my-func
== [a: 5]
>> bind blk ctx-A
== [a: 5]
>> ?? ctx-A
ctx-A: make object! [
    a: 60
]
>> my-func
== 5
>> ?? ctx-A
ctx-A: make object! [
    a: 60
]

Insert copies the words into the block unbound from their original 
context.

Ok, so we can do this instead:

foreach func funcs [bind second :func ctx-A]

No reason for that not to work.

Yes, that works:

>> ctx-A: context [a: none]
>> f1: does [a: 1]
>> f2: does [a: 2]
>> foreach func reduce [:f1 :f2][bind second :func ctx-A]
== [a: 2]
>> ?? ctx-A
ctx-A: make object! [
    a: none
]
>> f1
== 1
>> ?? ctx-A
ctx-A: make object! [
    a: 1
]
>> f2
== 2
>> ?? ctx-A
ctx-A: make object! [
    a: 2
]

This stuff is always really tricky.

Ok, thanks a lot. That's stuff I'm really going nuts by. I think 
I will collect all kind of examples and publish them.

A BIND how-to, that not only explains what's going on but shows examples, 
examples, examples is what we need.

Ladislav's Bindology article might help. I think it's on rebol.org...

His article is good, but only for gurus to follow.

Nothing for people getting into first touch with BIND.

I actually think that your best bet here is to pass the context you 
will be saving to the saving function as a parameter, like your original 
example  storage/save-record context-to-save  or if you really want 
to delegate you can assign the function as a member of context-to-save 
and call it like  context-to-save/save-record context-to-save , but 
then you are changing the context you are saving wih saving overhead. 
REBOL does direct delegation by default, rather than mixin delegation 
like Delphi, because REBOL doesn't pass the object reference as a 
hidden parameter like object-oriented languages do. Rebinding your 
function body every time would be time-consuming and either non-recursion-safe 
(bind) or consume a lot of memory (bind/copy) - just passing the 
context as a parameter would be quicker.

Also, you could have some conflict with names in both the storage 
context and context-to-save that could cause the block you are rebinding 
to accidently lose its meaning in unexpected ways.

Not that learning about bind wouldn't be fun...

I might fall back to the parameter solution. My goal is, that with 
BIND the code becomes much more natural to read and maintain. Because 
teh storage context needs some knowledge about the context to save, 
as I'm using a dynamic field-mapping method. Hence I only need to 
alter the context-to-save (add / remove words) and the storage context 
can handle it automatically. I have to deal with scheme evolution 
and versioning.

In that case, try the stub functions to hide the parameter passing. 
It will use less space, be more efficient and safer.

Logically though, you do have an object that is providing the storage 
infrastructure and is acting on other objects. The objects aren't 
storing themselves and their storage isn't their primary function. 
They are delegating that function to another object. So, other than 
the data that the storage engine needs, you don't really need to 
be distributing the code for storage throughout the data to be stored, 
unless these objects need per-object-specific serialization and versioning 
algorithms.


All the dynamic context manipulations cal be done by your storage 
engine working on the objects to be stored as data - they really 
are anyways.

Ok, I have tested some ways. The bind solution is nice but has the 
disadvantage, that I can't handle more than one currenct storage-context.

So, back to setting the storage-context and than all functions work 
on this context.

Anton: "
>> ctx-A: context [a: 60]
>> my-func: func [][a: 5]
>> blk: [] append blk second :my-func
== [a: 5]
>> bind blk ctx-A
== [a: 5]
>> ?? ctx-A
ctx-A: make object! [
    a: 60
]
>> my-func
== 5
>> ?? ctx-A
ctx-A: make object! [
    a: 60
]


 - you would have to change it to:

ctx-A: context [a: 60]
my-func: 
 func [][a: 5]
blk: [] append/only blk second :my-func
bind blk ctx-A
?? 
 ctx-A
my-func ; == 5
?? ctx-A

:-)

Ah yes, that would leave the block as is, instead of "unwrapping" 
it, which surprisingly unbinds the words.

unwrapping does not unbind; unwrapping copies.

that is, b: [] append b block   and b: copy block   are basically 
the same thing

Oh ok. So more specifically, the insert copies the words, but not 
their binding.

insert copies words *and* their binding of course

your problem is, that if you do 

    bind copy block 'context

the original BLOCK will stay unaffected

Ah of course! What am I thinking.!  So yes, as Gabriele said, my 
confusion was in not understanding that the words were copied.

does make-dir/deep not work on FTP sites?

No, and it caused me grief. But there is help at hand !  I patched 
make-dir to support FTP.

Use the first definition, second one still has issues.
http://home.wilddsl.net.au/anton/rebol/patch/make-dir-patch.r

I think it works. Thanks.

is this patch submitted to RAMBO?

No.  I think I didn't think I still wanted to think about it, perhaps 
finding a better way as the second function is attempting to do.