World: r3wp

I didn't mean to stress "using FUNC", just pointing out that we are 
using FUNC in this case.

ok, thanks a lot .... for me the interesting part was 'head ...

Of course you can check each step using PROBE.

because .... copy/deep still returns block ... I thought the position 
does not matter

I know ....

It's only because INSERT returns the block at the position *after* 
the newly inserted part that we need HEAD.

I know - but I thought that func simply accepts the block, regardless 
of position ....

I thought ti would work without the head, but it does not ...

Well, most functions care about the series index. We can easily test 
if FUNC does:
>> body: tail [print "hello"]
== []
>> f: func [] body
>> f
<---- nothing is printed

it is imo bug :-)

Nah...

func accepts the second argument as a block ... not a block at certain 
position :-) it should automatically move to the head, but ... maybe 
not ...

no way, it would be bug if it worked differently

Blocks are series and series are fundamental to understanding rebol. 
You must understand this behaviour and be comfortable with it, because 
understanding it opens up a lot of the power of series.

Here's a different way, which puts the new code in the key handler 
part:
view layout [
	field feel [
		use [body blk][
			body: copy/deep second :engage 
			blk: next find select body [switch act][key]
			change/only blk compose/only [if event/key <> #"^M" (blk/1)]
			?? body
			engage: func [face act event] body
		]
	]
]

Ladislav - I do understand it from the series pov ... the code is 
surely ok .... but from the func specs, I am not so sure:

body -- The body block of the function (Type: block)

You probably don't spend enough time playing with function creation 
:)

I would expect pointer to the block, not to some concrete position 
inside that block

I don't, never :-)

Here's the "copy, paste and bind" way:

view layout [
	field feel [
		engage: func [face act event] bind bind [
			switch act [
				down [

     either equal? face focal-face [unlight-text] [focus/no-show face]
					caret: offset-to-caret face event/offset
					show face
				]
				over [
					if not-equal? caret offset-to-caret face event/offset [
						if not highlight-start [highlight-start: caret]
						highlight-end: caret: offset-to-caret face event/offset
						show face
					]
				]

    key [if event/key <> #"^M" [edit-text face event get in face 'action]]
			]		
		] system/view ctx-text
	]
]

Notice we are binding the code first to system/view, then to ctx-text. 
(Then it is also bound to the function context.)

why is there a difference?

>> body: [print "hello"]
== [print "hello"]
>> f: func [] body
>> same? body second :f
== false
>> probe second :f
[print "hello"]
== [print "hello"]

Obviously FUNC copies the body block.

Why is that good ? Probably because that's what people expect most 
of the time.

ah, ok, thanks

to your double bind example - what does it do internally? you first 
bind the block to system/View - what happens in that context, and 
what happens in next context - ctx-text?

When you bind a block, eg:
	bind [all my words] some-context

an attempt is made to bind each of the words in the block to the 
specified context.

If the context contains the word in question, then the word is bound, 
otherwise the word is left with the same binding as it had before.

So if I
	bind [caret: "hello"] system/view

then the first word in the block gets the same context as this word:
	in system/view 'caret

and thus it also references the same value, because it is the context 
which determines what value a word has.

what does it mean the word it bound? it is registered somewhere at 
memory, in some word table, as belonging to that new context, or 
it just is assigned particular value of tha word in the context we 
are binding it to?

now I seem to understand, just did some small example myself:

block: [print a]
do block ; 'a is not known
my-context: context [a: 1]
do bind block my-context ; now 1 is printed

And note that it works also for sub-blocks:
	do bind [print [a]] context [a: 1]

I don't use bind, as it is more guru stuff, but is the bind as it 
is sufficient for you? e.g. wouldn't you prefer bind not binding 
for sub-blocks by default, and e.g. having bind/deep for such thing?

Yes, I would prefer more options for binding particular parts of 
a block "surgically".

hehe, I can rebind whatever, even functions? do bind [print a] context 
[a: 1 print: :probe]

yes, you can

hmm, but maybe mine is not example of binding anyway, it just simply 
created alias, no?

I would prefer more options for binding particular parts of a block 

surgically"" - that is possible e.g. using my BUILD dialect or other 
instruments...

It *is* an example.

That's true, Ladislav, I was just about to write that it is possible 
to write higher-level functions.

yes, it seems so ... print: :probe is known only in a newly created 
context, or so it seems ...

right, Pekr

'bind offers whole level of interesting low level (or high level, 
it depends how you look at it :-) magic ...

right again

you can "borrow" your values here or there ...

actually, you "borrow" variables, when using BIND

(which is almost the same in many cases)

and when such variable "points to" some other context, you get there 
too with newly binded word? Well, that is interesting also from security 
pov - we have powerfull instrument on one hand, but we have to be 
carefull on the other hand ...

yes, that is why REBOL modules are hard to implement