World: r3wp

in 2.7.7 at least

Part of R2/Forward.

Ah... I'm using 2.7.6 and they're not there

Then just write the single line that is flatten :)

done that ...

I thought there might be some other trick I could use

well,  I will use the to-block form and if that errors out drop back 
to flatten

Try parse, it should be quick:


>> parse [["xxx"] ["yyy"] ["zzz"]] [(f: copy []) any [set b block! 
(append f first b)]]                                             
                           
== true

>> 
f
== ["xxx" "yyy" "zzz"]

Of course, it would be quicker using insert back tail but that would 
have made the one-liner longer ;-)

Nevermind, it's already verbose enough :)

parse it is then!

Speed, speed, speed! :)

well, I thought we should really have a native for this ....  where's 
Cyphre's JIT compiler??

Why should it be native?

cause its going to be A LOT faster and for things like database queries, 
this can become quite a bottleneck.

Give me some numbers. Show me scenarios where it's a bottleneck. 


I should have a second log in here. P.O., because I'm sure I Piss 
Off a lot of people by always questioning Premature Optimization. 
:-)

LOL

How about a LINE-NUMBER? function yielding a line-number of a string, 
would you want such a function to be a mezzanine?

(the function is available at

http://github.com/rebolsource/rebol-test

, BTW)

I want pretty much *everythihng* to be a mezzanine until we know 
the gains are worthwhile and will benefit enough people. That still 
gives us room to be subjective. ;-)

I am the author, so if somebody different from myself wants to have 
the function as a mezzanine, fill in a CC ticket

gregg. such simple functions cannot be optimized in rebol simply 
because the lowest-level loops are VERY slow.  this is a simple function 
which requires no special treatment.


for such a function, the moment its written as a mezz, we can't say 
"premature" optimisation... its done.   the only improvement is to 
make it 20 times faster.

You're missing my point Max. I'm saying it doesn't need to be optimal 
yet, because we have no idea if it's worth optimizing.

Heck, we don't even have it as a standard function. :-)

You are also missing another point. Graham's original statement was 
meant to be ironic :)

I missed the irony. My apologies.

Another potentially useful function: CATCH-ANY. Can be found at:

http://github.com/rebolsource/rebol-test

as well.

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?)