World: r3wp

so this is close, with the exception that it does not allow for easy 
testing of unique terms being passed?
r1: "Sent frag 1"
r2: "Sent frag 2"
r3: "Sent frag 3"
r4: "Sent frag 4"

rule: [1 [r1 | r2 | r4 | r3]]


parse "Sent frag 1 sent frag 3 sent frag 4 sent frag 2" [[rule] [rule] 
[rule] [rule]]

wrong, same problem ever, if it's the same sentence many time

yes, that's what I stated above, if it wouldn't allow for the same 
value to be passed twice, this would work.

yep

I guess I don't understand why a unique function wouldn't work as 
a test prior to parsing.

;very basic example - 
unique: func [str][
	compare-set: "ABC"

 either "" = difference str compare-set [return true][return false]
]

;;;; and yes, that is very ugly

replace;   either "" =
with:   either empty?

... and of course 'unique shouldn't be used as a name due to Rebol 
already having a unique function.

unique works for the rules which use simple constants, but i said 
it, i use more complex rules

parse data [all [rule1 | rule2 | rule3 | rule4]] 

all rules must apply 1 time and 1 time only  in any order, don't 
focus on what is inside rules (it contains sub-rules which contains 
sub-rules).

Ok, this is convulted and probably wrong


rule: [copy res subrule (remove/part find subrule compse [| (res)] 
2)]
subrule: ["filler" | "a" | "b" | "c"]
parse "fillerabc" [4 [rule] end]


Remove the alternatives from the rule as you find them...the filler 
is to allow | "a" to be found.

argh, this is uggly :-)
not better than my current solution using counters

Yep...convoluted and hard to verify all the cases to boot.  :)  I 
wouldn't use it to be honest, but it was teasing my brain too much...

Now, I'll slowly back out of the room...ducking and dodging...  :)

take a whisky on the rocks

i got a beer

This has it...
r1: "A"
r2: "B"
r3: "C"

rule: [opt [r1 r2 r3]]

parse "ABC" [[rule] [rule] [rule]]

opt = match zero or one time

don't ask me to explain it, but it seems to meet your sample requirements

have you tested ? doesn't work at all for many cases

>> parse "BC" [[rule] [rule] [rule]]
== false

>> parse "ABC" [[rule] [rule] [rule]]
== true

>> parse "BBC" [[rule] [rule] [rule]]
== false

parse "CBA"  = false

in any order, i said

damn, doesn't handle the varying order of elements

:-)

Yeah, this problem needs to allow alternatives and then remove them 
(or Steeve's counter)

agree

but  i'ts not very elegant

and i have such rules like this

sniff

so i have to build a pre-parser to transform rules in an elegant 
maner

I'm still slowly backing out of the room...but I would not be completely 
surprised if another rebol gives you a "tada" solution...but I'd 
bet less money now.  :)

hihi

well, I'm stumped.  Tried many variations on the theme and couldn't 
get any to work.  Good luck.

Basically you're asking for [all ["A" | "B" | "C"]] -->
ABC
 = true
BAC
 = true
BBC
 = false
ABCB
 = false

I think Steeve just left...but yep he wants a once and once only 
in any order

i'm here

yeah Chris you got the thing

assuming "A" "B" and "C" could be more complex rules

You may want to check Gabriele's 'compile rules' to see if this has 
been solved.  I have another solution, but needs hashed out a little.

i know how to build a complex solution but i would prefer a new word 
in the dialect , if other peoples think it's a good improvment

I think so -- it's a common enough pattern...

.333

sorry, cat on keyboard :)

unfortunately the cat did not type a useful parse rule.

huhu

I thought the zen answer was imminent...

steve - not sure this should be a new dialect word, since it is a 
very specific case. basically you want all permutations of a set 
of rules.