World: r3wp

and avoid dubplicating the storage code in every context, or write 
stub-functions that reference the storage stuff.

Is it possible to bind the storage functions dynamically to the context 
that should be saved and switch this binding in the app depending 
on which context should be stored?

In other languages this is called delegates (IIRC).

Example:
context A [a: 1 b: 2 c:3 list-words: none]
context storage [list-words: does [probe first self]]

How can I execute storage/list-words in the context of A? So that 
I get back [a b c list-words]

I think I need to switch the way it works:
	do bind [first object] storage

Is this the correct way?

no it isn't...

>> c1: context [a: b: none]
>> c2: context [a: b: none]
>> do bind [a: 1 b: 2] c1
== 2
>> probe c1
make object! [
    a: 1
    b: 2
]
>> do bind [a: 100 b: 200] c2
== 200
>> probe c2
make object! [
    a: 100
    b: 200
]

Oh sorry, you specifically want to bind a function's body to the 
context.
Let's see, I think this will work:
	bind second get in storage 'list-words A
	storage/list-words

What's this SECOND about?

Just getting the function body.

>> A: context [a: 1 b: 2 c: 3]
>> storage: context [list-words: does [probe first self]]
>> storage/list-words
[self list-words]
== [self list-words]
>> bind second get in storage 'list-words A
== [probe first self]
>> storage/list-words
[self a b c]
== [self a b c]

read as: "bind the body of list-words to A"

Ok... now I think I got it. I was always trying to bind the WHOLE 
function, not only the body...

Yes, bind needs a block! value, not a function!

A function! is a more complex value, which contains a spec and a 
body.

You wouldn't want to bind the whole function, which would probably 
imply binding its spec block as well, since that would unlink the 
argument spec block relative to the body block.

Although, now that I think about it, that *could* be useful in some 
circumstance, maybe.... Many functions with similar argument lists 
could share a context.

ok. Thanks a lot.

no problem..

I think I can bind a bunch of functions as well, right?

I mean in one step.

So for example I specify a block of function names, that I want to 
bind.

You could append each function's body block to a single, large block. 
Then bind that.

And it will keep it's link to the original function spec?

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

Yes, remember it's possible for same-named but differently-bound 
words to coexist together in a block.

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.