World: r3wp

Hmm. Using SKIP would be like using GOTO. The trouble it's trying 
to avoid is having lots of dummy empty brackets, of course - a noble 
goal.

It would be better to simply use a name-reference (keeping in mind 
that these are now, in Rebol 3,  local to the window context), for 
jumping across a (possibly varying, during code maintenance) number 
of empty action placeholders.

or, how about 

actions [ label [ ] panel [] ]

so we can assign by type

now we don't have to keep the actions in order unless there are more 
than one of the same type

view [
	; Structure
	label "hello"
	text-area
	my-text-list: text-list
	code-area

	actions [
		my-text-list [ set-face ... ] ; <--- action for my-text-list
		[ ] ; <-- action for code-area
	]
]

So, above, during code maintenance any number of extra fields can 
be inserted before my-text-list and it won't affect the actions assignment.

view [
	; Structure
	label "hello"
	text-area
	my-text-list: text-list
	code-area

	actions [
		text-list [ set-face ... ] ; <--- action for my-text-list
	]
]

there's only one text-list in the window

There can be an overlap in names, so we have to deal with this possible 
ambiguity:
view [
	text-list: text-list  ; <--- TEXT-LIST #1
	text-list  ; <--------- TEXT-LIST #2
]

Where the name-reference is the same as the element type (text-list).

we could just use order ... and not names

actions [
	text-list [
		[ text list 1 ]
		[ text-list 2 ]
	]
]

Perhaps lit-words could be used to indicate that it's a type, eg:

	actions [

  'text-list [ set-face ... ]  ; <-- Action for all text-lists in the 
  window.
	]

this would allow code reuse

(Ugh... the sight of hard-coded numbers make me a bit queasy...)

the numbers aren't there ...

just using the order  in the block

oh

so you meant:
	actions [
		text-list [
			[ ... ] ; <-- action for the first text-list
			[ ... ] ; <-- action for the second text-list
		]
	]

yes

Not bad.

And lit-words ? Another idea might to use them to identify the name-references 
(not the element types). eg

view [
	; Structure
	text-list: text-list  ; <-- Named text-list.
	text-list ; <-- Anonymous text-list.

	actions [
		text-list [
			[ ... ] ; <-- Action for first text-list
			[ ... ] ; <-- Action for second text-list
		]

  'text-list [ ... ] ; <-- Action for the specifically named text-list, 
  'text-list.
	]
]

the big question ... will this make making gui's harder or not?

Well, why are Unobtrusive Javascript people doing it ?

For quick little layouts we can see that the separation, with all 
those extra nested brackets and interpretation requires extra effort. 
But for large, complex layouts, the separation must have some benefit.

(<--- insert benefit here..)

I have lots of complex layouts ... so I think it will help.

Only way to find out is to test it though.

I think it makes things harder, at least for a short while. After 
that I cannot see...

The reason is that there is an extra name reference needed to associate 
the action to its element, because they are now separated. In large 
layouts, the separation of structure and behaviour puts these closely 
related aspects further apart, so it means more scrolling.

Except that the structure is now much smaller without all the behavior 
code mixed in .. so it's less scrolling :)

That's true, if you *just* want to look at structure.

But what makes "structure" an aspect that deserves such attention 
? It's still not clear to me.

http://en.wikipedia.org/wiki/Unobtrusive_Javascript

I think other aspects of a program could be more important, at other 
times, or simply at different places in the code. :-/

The unobtrusive solution is to register the necessary event handlers 
programmatically, rather than inline. 

so, say you had a number of text-lists that all had the same event 
handler, you just define it once instead of 3 times

where number = 3

for simple windows there is no gain.

It's only for large complex windows where the gains are seen.

Ah, that's why you mentioned stylize.

It's a form of code factoring.

It should be easy in rebol to define actions programmatically, or 
to make your own style of text-list before-hand.

why not make it automated by default?

Well.. why not?

I note the Unobtrusive Javascript wikipedia article example sets 
up the "hundreds of .. date fields" with the same action. (Of course 
I understand they could be subtly different, determined programmatically, 
but still..)

This could be done in rebol better using stylize-like functionality.

I think we don't really have the problem that's being solved in that 
article example.

inline syntax prevents the registration of more than one event handler 
for the element's onchange event

 - we don't have this problem in rebol. It looks like they are working 
 around a problem in html inline javascript specification.