World: r3wp

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.

the simplest way may be to just generate all the permutations.

that is, parse string [a b c | a c b | c a b | c b a | b c a | b 
a c]

i give another one example: imagine you have a dialect which describes 
a rectangle with coordinates length and color.

You could write [rectangle 10x20 300 red] but [rectangle 30 red 10x20] 
should be correct too (and other combinations).
So a parser should handle this with not too much complication.

that can also be written as: parse string [a [b c | c b] | b [c a 
| a c] | c [b a | a b]]  (faster)

steve, we do that all the time, and we just take the last value when 
it is put more than once.

Steeve: In that situation, you have a little discretion to ignore 
excess attributes, as VID does.

but what if i have 10 rules to complete ?

that is, two pairs is not an error, the parser just ignores one. 
if vid errored out it would be worse.

you make a function that taken a list of rules generates all the 
permutations.

ok, it was a bas example

*bad

yes Gabriele, it's what i do currently

Not bad, we're just forgiving here : )

but it's uggly

i don't see any better approach, because you are parsing for the 
permutations.

and it's become huge if i have lot of rules to combinate

if you use the above approach (second example i wrote) it is reasonably 
fast.

otherwise, you need self-modifying rules, or use flags.

yes we talked about other solutions

but i have just posted here because i thought it will be a good improvment 
to have a new word in parse dialect

the point is, this has just been asked once in 7 years, so not sure 
how common ;)

but my problem is not so common, it seems...

I haven't asked, but I have come across this too.

The workarounds do seem a little unwieldy, but I'm not sure what 
the complexity in the proposed 'all keyword would be...

internally it would probably have to check flags or do the permutations 
on the fly.

this is possible, but my guess, that Steeve would call it ugly too:


>> once-only: func [rule] [use [rule'] copy/deep [rule': :rule [rule' 
(rule': [end skip])]]
]

>> rule: [(a': once-only a b': once-only b c': once-only c) 3 [a' 
| b' | c']]

== [(a': once-only a b': once-only b c': once-only c) 3 [a' | b' 
| c']]

Ladislav, that's not ugly, it's beautiful! :-)

I have a question though. Do you need the skip at the end of once-only? 
Wouldn't it work just with
rule': [end]

To do block parsing, I suggest:

>> once-only: func [:rule] [use [rule'] copy/deep [rule': :rule [rule' 
(rule': [end])]]]

>> rule: [(a': once-only 'a b': once-only 'b c': once-only 'c) 3 
[a' | b' | c']]
>> parse [c b a] rule
== true

hmm, the block parsing give wrong result, if there are less than 
3 values to parse.