World: r3wp

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

Steve, wondering if your take function solution was coded in french, 
I can't understand it  without studying it a bit more.

;-)

it's the french touch ;-)

hey Brock , still alive ?

do rules: [
	set 'a "first rule "
	set 'b "second rule "
	set 'c "third rule "
]

rule: [ 
	[end (if empty? erode[here: back tail :here]) :here skip]| 
	[here: erode there: 
	(	all[
			token: copy/part :here :there
			word: find rules token
			word: first back word
			remove/part find erode word 2 
		]

  all[empty? erode not tail? there insert/only erode [] there: tail 
  there]
	)] :there
    rule
]

data: "first rule second rule third rule "
erode: [ a | b | c | a]  parse/all data rule

left expanded for clarity

i would have to discuss what follow before posting it in Rambo

parse "  a" [copy r "a"]

>>r
== " a"

i think it should be r = "a" instead

*i would have speech

>> parse/all " a" [any " " copy r "a"]
== true
>> r
== "a"

I try toi allways yse /all when I give a block of rules

and use pases by itself aith the none rule

r: parse " a" none

["a"]

hi Toms, as always don't focus on the example i give but on the issue 
i suggest, another one example:
>>parse "ld   a  b" ["ld" "a" copy reg ["b" | "c"]]
>> r == " b" 
>> i just think it will be more logic to have r == "b"

(replace r by reg)

i well know how to skip blank chars, but i think it's not logic in 
that case

We so need a Wiki for Rebol, and shove every word and example into 
it.  Just Parse needs 100 pages of examples and descriptions.

lol

we need a wiki just for parse

and a new book.. Dialects for The Rest of Us (forget the Dummies 
version..)