World: r3wp

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

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.