World: r3wp

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.

John: [end skip] is a rule that surely fails, while [end] may succeed 
(at end)

I see. That's also why my block parsing give false result with less 
input. So for block-parsing, it should be:

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

why, my rule should be usable as-is even for block parsing?

(I don't like fetched arguments)

>> 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']]
>> parse [a b c] rule
** Script Error: Invalid argument: a

in that case you can use either:

    a': once-only first ['a]

or

    a': once-only ['a]

Yup, works. Nice! :-)

Once (again)

Rebol is amazing, i think i found a simple and elegant dialect

Currently, it's not allowing recursive once usage, but it's obvious 
to do with a stack.


take: func [r] [n: 0 once/1: (length? r) + 1 / 3 once/2/2: r replace/all 
r '.. '.]
.: [(n: n + 1)]
..: [(n: n + 1) end skip]
once: [0 [(if n > 0 [poke once/2/2 n - 1 * 3 + 1  '..] n: 0) []]]


rule: [. "a" | . "b" | . "c"]
parse "CBA" [ (take rule) once]
== true
parse  "BAC" [ (take rule) once]
== true
parse  "CBA" [ (take rule) once]
== true
parse  "BBC" [ (take rule) once]
== true
parse  "CA" [ (take rule) once]
== false
parse  "CABA"[ (take rule) once]
== false
rule2: [. "a" | . "a" | . "b" | . "c"]
parse "CABA"[ (take rule2) once]
== true

(correction) 
>>parse "BBC" [(take rule) once]
== false

gnarly

:)

gnarly ?

ok,    http://www.urbandictionary.com/define.php?term=gnarly

data: "cab"
>> c: charset "abc" parse data [3 c]
== true

?

>>>parse "ccc" [3 c]
==true

we want any combination of "ABC"

without repeats

yep

and that works for any type of sub-rule, no only for constants

one shot concept

>> data: "abc"
== "abc"

>> c: charset "abc" parse data [3 [here:  c  (c: difference c to 
bitset! first :here)]]
== true
>> data: "ccc"
== "ccc"

>> c: charset "abc" parse data [3 [here:  c  (c: difference c to 
bitset! first :here)]]
== false
>>

hehe, doen't work if i check for any combinations of "AABC"

I should read the thread  when I have a few minutes

yes you should

but I will amuses myself as I please in the meanwhile.

huhu