World: r3wp

Post it to the idioms group in R3 chat #754, either the file, a link 
to the original, or as source in a message.

The CATCH-ANY function above catches almost all REBOL exceptions. 
One that it does not catch is HALT. Is HALT meant to be "uncatchable", 
or not?

(shall this question be CureCoded?)

My preferences are, that HALT should be catchable, since that would 
allow us to e.g. write a REBOL console in View.

catch halt could be a nice wish

Done

Examining the core-tests suite results I wonder, which alternative 
do you prefer:

a:

>> for i 1 3 1 [print i if i = 1 [i: 2]]
1
2
3
== none

b:

>> for i 1 3 1 [print i if i = 1 [i: 2]]
1
3
== none

latter

it's like a loop

sort of

actually that's a construct I miss....

eg. in dbase we had

do loop [ ............ ] endloop or something like that.


but you could exit anyway inside that block to restart the loop like 
this

do loop [ .... loop .... ] endloop

we only have break which exists a loop

exits

You can do it with an idiomatic use of LOOP 1 [...]
But that loses an easy way to use BREAK for real.

    for n 1 5 1 [
      loop 1 [
         if n < 3 [break]
         print n
         ]
  ]

R3 has CONTINUE
    for n 1 5 1 [
         if n < 3 [continue]
         print n
      ]

need a break^2

you mean for this?:

for n 1 5 1 [
	catch/name [
    	if n < 3 [throw/name none 'continue]
    	print n
    ] 'continue
]

yes .. but in one word :)

cc: func [[throw] body [block!]] [catch/name body 'continue]
continue: func [[throw]] [throw/name none 'continue]

for n 1 5 1 [
	cc [
		if n < 3 [continue]
		print n
	]
]

Can be made even more elegant, since FOR is a mezzanine

that would be good

CC being a function, would that mean RETURN or BREAK could not be 
used?
eg.
	myfunc: func [][
		for n 1 5 1 [
			cc [
				if mycondition [return]
			]
		]
	]
(until converted to native?)

Do you have any problem with it?

(you should not)

Of course, this construct is just for R2, for R3 you have native 
solution

No, just wondering.

A different idea, instantly causing any R2 cycle to "understand continue":

cc: func [
	{convert a cycle body to "understand" CONTINUE}
	body [block!]
] [
	compose/only [catch/name (body) 'continue]
]

continue: func [[throw]] [throw/name none 'continue]

; usage:
for n 1 5 1 cc [
	if n < 3 [continue]
	print n
]

Hope, this is sufficient even for Graham ;-)

Any name improvements (the 'cc name looks a bit unnatural)

?

Could you put CONTINUE into the CC func context?

(I mean, wouldn't it be better ?)

yes, that can be done

Ah, but then you need to bind BODY.

no problem with that, but it would be incompatible with R3 CONTINUE, 
then

oh I had forgotten it was in R3.

better outside then.

CC -> MAKE-CONTINUABLE ;)

Very understandable, but a little bit too long for my taste

I can't think of a better name. The reason is because it shouldn't 
be there at all. I think all the rebol loop constructs should be 
adjusted to use CC by default.

All REBOL loop constructs use CONTINUE, but, unfortunately, not in 
R2 :-(

Well, there's a wish...

I don't think you get CONTINUE in R2, if you don't want this "cheap 
one"

Hmmm... hard decision.

On the balance of things, I think it would make things better; code 
more readable and more consistent with R3 code, so I'm for it.
A better name for CC is definitely needed, though.

What amazes me, (as always in REBOL) is, that the hardest part is 
to find the best name, not to implement the feature :-)

Well, that just means that the name of a feature is really part of 
the feature.

Regarding the CONTINUE in R2 - I may be wrong, though, maybe Brian 
would know better?

But, of course, Carl would know best!