World: r3wp

notice that, forall was initially done that way, and converted to 
use forskip for simplicity (ie. avoiding having the same code twice 
in the source)

I tried to enclose parse in loop 1 [] and it seems to handle break. 
I guess you'll probably prove me wrong, Brian :)

parall: func [
	'word body
	/loc data
][
	loop 1 [
		data: get :word
		parse data compose/deep [
			some [(to set-word! word) skip (to paren! [do body])]
		]
	]
]

re: continue - this is not r3 ;)


>> n: [1 2 3 4 5] parall n [if n/1 = 4 [break/return "break"] if 
n/1 > 4 [print "bad"]]
== "break"

good :) now... if Ladislav was here he'd probably find at least ten 
wrong things in that function. ;)

you need to add [throw] for example, and return the last return value 
of the body

but... as long as we're not replacing forall... this could be a very 
fast alternative to use in cases when you don't need all the features...

and actually... i'd call parse directly in that case ;)

forall replacement not...an experiment in using parse for maybe not 
obvious purposes - yes :)

You could make something new. like this:
 parall [p: set x integer! set y integer!] [?? p ?? x ?? y]

parall [p: set x integer! set y integer!]  DATA [?? p ?? x ?? y] 
;..

To be able escape from infinite loops use () somewhere in the parse 
rules as for example:

 >> parse "abc" [any [()]]
 *** YOU CAN PRESS [ESC] NOW TO STOP THE LOOP ***

>> parse "abc" [any []]
*** HANGS REBOL ***

Cool!

Oldes: does using () inside a parse loop slow things down? I'm wary 
of () as they do seem to slow the interpreter down in many cases.

Peter it does slow interpreter down, it's better to use this trick 
when designing your rules. If you're happy with them, remove the 
parens to make your rule faster.

What about a new word “all” which would allow  to parse several successives 
conditions whatever their order  ?

parse [a: 1 b: 2] [all ['a: integer! | 'b: integer!]] would be true 
only if it exists successivly [a: integer!] and [b: integer! ] whatever 
their order

need it

Umm...I'm not really a parser but


parse [a: 1 b: 2] [set-word! integer! set-word! integer!] returns 
true.

yeah but what ? if the entry is [b:2 a:  1] instead

hum sorry, it works too

but if the entry is more complex like [a: 1 huge tight  b: 1] and 
that i want parse all this values in any order ?

and in your example , you don't test that we must encounter 'a and 
'b

i give another one example , more simple

i want to parse the serie "ABC" but it could be the serie "BCA" , 
"CBA" , "ACB" ... any combination

so if i could write parse "ABC" [all ["A" | "B" [ "C" ]]  , it should 
be more simple

Again, I'm not a parser, but parse's support of alternates with some 
and any covers these cases no?

no

if you write  parse "AB" [some ["A" |  "B" | "C"]]

parse "ABC" [ 0 1 "A" | 0 1 "B" | 0 1 "C"] ?

you get a true answer, but that not the case

I think I'm clue'in to what you mean.  I'll leave this to the pros... 
 :)

like my use of 0 1 can be opt...  :)

anyway, you're example just don't work ^^

*anyway your example just doesn't work (fewwww)

Yep.  I'm out.  Not experienced enough to have piped up...  ;)

and what is your mater ? ;-)

we can talk of rebcode if you want :-)

Thinking about this one, you'd have to repeat all the alternatives. 
 Defeating the purpose...but I'll bet Chris or Geomol or Anton or... 
will have a workable solution posted before ya know it.

i h'ave many alternatives (all comsuming lot of code)  that's not 
the point, i just think it could be more elegant to have such a command

Maybe we could hold side bets on which rebol will come up with the 
solution first...I'd put money down on Oldes or Volker giving you 
a workable  :)

if you say so, i  tried many alternatives, but they are all uggly

try this... parse "AB" [some ["A" |  "B" | "C"] | none 
]

i don't want to parse "AB" but any combinations of "ABC"

His works.  I tried it without the terminating  | none  and it spun 
out, so I didn't mention it  :)

parse "AB" sould return false

not true

why would AB return false?

so it must be three characters?

because i want parse the complete serie "ABC" in any combination

yes 3 characters

What it you put 1 repeats inside the some?

write it plz

nevermind...  just tried it.   piping up out of turn again  :)