World: r3wp

reboltalk.com would be a possibility if it wasnt so embarassingly 
full of spam

I think one of the most confusing things about leaning Parse, is 
the occurance of  some & any & | , and the use of [ ]  

the constructs are quite straight forward, but the need for [ ]  
etc is a raw mystery to me.

[ ] identifies rules which must ALL match as a group.

or a roll back occurs at the start of the [ ]  and tries the next 
rule following a "|" in the current rule (if any)

its pretty much the same as parens in regexp actually.

altme should use port 80 :-(

it is installing non aproved applications that is the issue, and 
the need for a proxy config? perhaps that is covered.  I may just 
install it I suppose.

So the parse keeps going inside the [] till all the | are exhausted 
or it gets a match. then looks for the next | in the outer nesting 
of [] ??

almost.  if one of the options match (  [option1 | option2 | option3] 
)

then the rule itself is considered a match and it won't attempt the 
other option.

That is what I meant to say.

so if the current rule is an option, then it will match too.

read the "|"  as: "continue if  previous rule didn't match"

I read "any" matches 0 or more occurances --- I dont understand what 
that means in practice. it sounds like a loop perhaps?

I can see any digit  makes sense

but not any [long expression]

parse {aaa} any [[here: "a" (print here)] | [skip] ]  does not work 
for how I imagine.. I expect it to return aaa aa a

it simply means that the following rule won't cause the current to 
fail even if it doesn't match any  [long expression]

that's what it returns here... ' :-/

note: above should be...

parse "aaa" [any [[here: "a" (print here)] | [skip] ]]

any outside of parse is something else.

even if it's similar in intent.

my first any needs to be inside the [ ... that would seem to mike 
it apply to the "a"

>> parse "aaa" [any [[here: "a" (print here)] | [skip] ]]
aaa
aa
a
== true

>> parse "zaz" [any [[here: "a" (print here)] | [skip] ]]
az
== true

>> parse "zzz" [any [[here: "a" (print here)] | [skip] ]]
== true

that seems logica, but this does not
 parse {aaa}  [any[here: "a" (print here)] | [skip] ]
aaa
aa
a

note that the rule returns true everytime.  it did not fail.

why does it skip in my example?

it doesn't... each time it hits "a" the first rule matches.

which moves the Parse pointer on

in your example, you have two rules, the any only applies to the 
first rule.


 the | skip basically will never be used, cause any will never fail.

any will repeat until it doesn't match, but it still doesn't fail.

& if i use data of zzz it returns false...  I see why now, I think 
this is key to why I have been so frustrated with getting these rules 
to work.

now be carefull... the parse function returns false IF it didn't 
match all of the input string.

oh, no I dont, not if   any makes it always return true

so the any actually didn't fail, and thus the skip never go to do 
its stuff.

other examples.

 >> parse "aza" [any [here: "a" (print here)] | skip]
aza
== false

>> parse "aza" [any [here: "a" (print here)]  skip skip]
aza
== true

so why did the parse return false?
>> parse {zzz}  [any[here: "a" (print here)] | [skip] ]
== false

is it because the skip never get called so the parse is stuck on 
the first position or match & parse needs to move to the tail to 
return true?

I need to dream about this EVERY night.

yep.  it hit the "z" stopped (but didn't "fail") so the skip isn't 
reached.

the second example, both skip ARE evaluated, thus it returns true.

Maxim, you are a very patient teacher.

:-)  I missed such a big feature of rebol for sooo long, just because 
I didn't get these nuances.  and its hard to make a tutorial out 
of this, cause it sooooo boring, and you don't realize why its so 
important until you really start to use parse.

btw, I keep logging off, cause the winds are wreaking havoc on the 
electricity lines!  there is probably a loose connector on some junction 
and my whole house has rebooted at least 15 times in the last 2 hours 
 :-/

I agree, it needs to be interactively taught. I know I will still 
get it wrong, but I fee more confident to analyse what is going wrong 
now.

wow, are you still in the winter? Are you in Canada?

all of northern usa should be affected the same way, it snowed yesterday 
in central canada!  yet we are already at temperatures of 65-70 on 
average... its just clash of northern and southern winds... creating 
a massive disruption here.

Hi, I am after some advice on creating a data structure please.
I read data from my file in this sort of order.
disabled
2/34
2/35

vlan 3
2/35
2/48

vlan 5
2/3
2/24

name
2/1 name one
2/35 second name

Then I want to export it in this sort of format.
port <tab> disabled <tab> vlan <tab> name 
2/1                                  name one
2/3                        5
2/24       disabled
2/34                       5
2/35       disabled        3         second name
2/48                       3


I am hoping that I can create a structure that mimics the data its 
self.
maybe like
data/2/35/disabled = "disabled"
data/2/35/vlan = "3"
data/2/35/name = "second name"


Then some how use the input data to define what part of the structure 
the item is recorded in.

Once I have it in a structure like this I am expecting it to be simple 
to enumerate each part to do my export.

Use blocks.

>> data: [[] [[vlan 3]]]
== [[] [[vlan 3]]]
>> data/2/1/vlan
== 3

And then probably PARSE should be used to scan the input and put 
values in the data block structure (maybe building the structure 
along the way, if it's known beforehand).