World: r3wp

Probably. Only the domains are uppercased.

Then with the find command I don't think it will be possible.

At least not without a table lookup.

What's the most economical way to do this.  I have a line of text, 
and I want to classify each line.  So, if I find the word "tablet" 
in it, I class this as a U2, and if I find "capsule", it's AV.

I can do a sequence of finds inside a case statement, or I can use 
a parse.  But in the first instance I have multiple find statements, 
but in the latter I have mutliple assignments in my code.

Economical how, in space, speed, or complexity? e.g., repeated FINDs 
can seem inelegant, but are easy to understand and maintain.

If lines match more than one rule, what is the desired behavior?


Assuming you have test data, and if performance is the key, have 
you done any quick tests?

elegant in looks :)

the lines are so few in number that it won't make any practical difference 
... just wondering if there were a preference on how to do this without 
code duplication.

I decided that since the way I was going to use parse, or case meant 
the code was mixed in with the data .. it was better to do it differently.

you need to maintain a map of keywords and codes   to that  in its 
own file and read it in to build your rules

sort it by keyword length  longest first

before building the rules 
then when codes change or mor are added you just update your map

basically what  ended up doing  :)

I'm puzzled about the difference result when using [to end end] and 
[thru end}. Anybody know why?

 >> parse "123456789" [to end end]
== true


>> parse "123456789" [thru end]

== false

note: 

parse "123456789" [to end]
== true

this has also puzzled me, since:

>> parse "123456789" [thru end here:] index? here
== 10
>> parse "123456789" [to end here:] index? here
== 10

maybe the rule thru fails because you can't actually go past the 
end.

just like this fails too. even though we are at the end:

>> print parse "123456789" [9 skip here:] index? here
true
== 10
>> print parse "123456789" [10 skip here:] index? here
false
== 10

it does make sense, and its consistent with parse... it only returns 
true when the last rule ends Exactly AT the end.

maybe the rule thru fails because you can't actually go past the 
end
 - but does [thru end] go past the end?

yes it goes one past the end. it does not stop AT the end.

end has no length, so to end and thru end mean the same thing.

I guess you could answer that end is past the end of the input. But 
the behavior seems inconsistent:

>> parse "123456789" [thru "8" "9" end
]
== true

>> parse "123456789" [thru "9" end]
  
== true
>> parse "123456789" [thru end]
        
== false

but brian, skipping past the end, still puts you at the end of the 
series, but the parser know you tried to go beyond the end... ITs 
the thru wich is failing, cause it knows you are trying to go beyond 
the end.

It's different in R3 :-)

>> parse "123456789" [thru end]

== true

thru consumes the end word, and then detects that, as a result, it 
would put you beyond the end.  
really, its quite logical.  


but in practically, thru shouldn't complain.... cause as you say, 
in this specific context, thru and to really do mean the same end.

I prefer the R3 behaviour. I really hope that it doesn't change.

I'll make sure of that, Peter.

Thanks.

yes, Peter, I am sure R3 behaviour is correct

In R2:

>> parse/all { X X  XX X X} [(prin 'a) some [(prin 'b) "X" (prin 
'c) [(prin 'd) "X" (prin 'e) | (prin 'f) skip (prin 'g)] (prin 'h) 
| (prin 'i) skip (prin 'j)] (prin 'k)]
abijbcdfghbcdfghbijbcdehbijbcdfghbcdfijbik== true

In R3:

>> parse/all { X X  XX X X} [(prin 'a) some [(prin 'b) "X" (prin 
'c) [(prin 'd) "X" (prin 'e) | (prin 'f) skip (prin 'g)] (prin 'h) 
| (prin 'i) skip (prin 'j)] (prin 'k)]
abijbcdfghbcdfghbijbcdehbijbcdfghbcdfijk== true


In both cases the fij near the end should should be fgh - a bug in 
PARSE.

Never mind, I missed that the last X is at the end of the string. 
No bugs.

the more i try to understand parse the less i understand it

i want to try to make a tutorial about parse but my knowledge of 
it is poor 

 so as we have a wiki we could start a project to write a documentation 
  with the goal to make people understand what is the interrest of 
 parse

Parse question on stackoverflow (unanswered as yet:)

http://stackoverflow.com/questions/1060727/rebol-parse-dealing-with-whitespace-and-copy-var

Answered :)

Fast!

http://www.rebolfrance.info/articles/allaboutparse
documentation to put all what we want to now about parse

There's also a lot of documentation about parse's behavior (in theory) 
at the beginning of the Parse Proposals page on DocBase.

BrianH yea but that's really too light you can't expect people gaining 
Guru level in parse with so poor documentation ... I want to know 
all about parse and i want that knowledge to be sahred

Alas, to know all about parse you have to go to the guru level. To 
know enough to get by, you don't :)

Code like that example above with all the (prin) calls can help a 
lot wiith understanding parse though.

What would be useful would be a parse cookbook.....HowTo questions 
with sample answers.

That way, we could build up a set of carefully graded examples of 
putting parse to work.

sunanda that's what i have in mind

but not only ...

first you give the basic you say what is parse you eplain how you 
can use it and then for the very hl part of the documentation you 
have examples working or not and answers from gurus explaining what 
 you missed in your implementation

sunanda look the page i submited if you have any comments

parse is a part of rebol which needs a complete book to be written 
about it.   To go from zero to hero it could easily span 100 or more 
pages.

Maxim i agree lets do it :P

to me parse is something that is useless until you understand it.... 
at which point, you are a guru.   There is no real middle ground, 
which is the problem.

but really i have a thousand projects in mind and i'm locked because 
of  my parse low knowlege i can add things to existing parse rules 
 but building a rule or a dialect from scratch is impossible for 
me