World: r3wp

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

i just don't understand what you mean

ah ok, it doesn't work :-)

do all three characters need to be present?

I tried  parse "AB" [some [1 "A" | 1 "B" | 1 "C"] | none]   ...returns 
true

or can characters be duplicated?

no Brock

the | none handles situations where the rule doesn't apply, so almost 
everything will return true

Brock;  Without it it'll endless loop no?

no

just never use an ''opt" rule in a some or any block

will it just be instances of A B & C?

one instance of each in any order (but just one instance)

the awaiting result is 
a: b: c: false

parse "CAB" [some ["A" (a: true) | "B" (b: true) | "C" (c: true)]] 
if all [a b c ] [print "ok"]

*expecting result

except that this code is wrong for series with repeting characters 
like "AABCC"

(should increment a b and c instead using boolean)

anyway , that's not the point , i know how to do that, but i just 
 think it's ugly

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

nevermind...  :)  AAA returns true

yep

i really think it's not feasible without using counters

I think I have it
define a rule;
rule: [1 ["A" | "B" | "C"]]
then parse
parse "cAB" [[rule] [rule] [rule]]

the one indicates that there must be an occurence of one of the three 
characters... supplying the rule then requires three characters to 
be entered.

... but it allows multiple characters... damn

and it works too with the serie "AAA"

which is bad

yrp

parse can change the string as it goes right?  What if you tried 
marking them off with X's as you found them?

I was thinking the same thing, removing each character from a block 
as each rule is processed.

yeah it's possible but it's like hanging counters, you need to have 
some code to check the result and allowing the parser to continue 
further

so your ideal solution would not use anyting other than parse?