World: r3wp

http://www.mail-archive.com/[rebol-bounce-:-rebol-:-com]/msg01983.html

Janko: the only problem is, that you cannot use:

C: [to [A | B]]

, where A and B are "general rules", but you can always write:

C: [here: [A | B] :here | skip C]

, which would do what you want

Just would like to remember that there is something like R3 where:

>> parse "I like Apple . I like Windows ! I like Linux . I like Amiga 
." [any ["I like " copy x to [" ." | " !"] (probe x) to "I like "]]
Apple
Windows
Linux
Amiga

And Janko... if you don't use charsets at all, I think you should 
give it a try. It's not so difficult. I think that if I can write 
parser to colorize PHP code, than you can parse everything.

Ladislav, thanks.. I didn't know you could set the position back 
with :here , that is interesting and probably expands what you can 
do with parse a lot.

Oldes if that is in R3 >> copy x to [" ." | " !"]  << this is exactly 
as I was proposing above :) , very nice!


I know I have to .. I haven't really needed them yet I guess, I solved 
some things less elegantly in other ways without them. I intend to 
take the plunge next time I need them.

yes, you are right .. if you can write partser for php then you can 
make anything with it. I always supposed parse with charsets is like 
low level step by one char in a looop and call "events" and change 
states , with which you can parse anything from xml to languages 
.. well but parse with charsets is still much more elegant

but it is a level less simple and nice to use than simple parse modes 
that's why the simple ones should be powerfull *if possible* too 
- you can't get a newbie impressed with charset parsing because he 
won't understand it probably.

Just to complete the list of possible equivalents to the

    C: [to [A | B]]

rule, here is a way how to do it in Rebol3 parse:

    C: [while [and [A | B] break | skip | reject]]


you can find other equivalent idioms at http://en.wikibooks.org/wiki/REBOL_Programming/Language_Features/Parse#Parse_idioms

I didn't know you could set the position back with :here

 - you can set the position back even without :here, the choice operator 
 is sufficient for you to be able to do that, see the above idioms 
 as an example

It looks, that I could have used:

    C: [while [and [A | B] accept | skip | reject]]

Janko, charset is short for make bitset! so you can call them bitsets 
or charsets :)

Ladislav, what 'choice operator?

|

Help!  Still struggling to understand parse.  How could I replace 
any and all SINGLE occurrences of  the single-quote character anywhere 
in a string (beginning, middle or end) with TWO single-quotes?  But 
if there are already TWO single-quotes together, I want to leave 
them alone.

TIA for any and all help for a newbie!

easy, actually.  you match double quotes first then fallback to single 
quotes, adding a new one and skiping one char... 

give me a minute I should get something working...

R2?

yes, View 2.7.6 under Windows XP

>> parse/all str [ any [thru {"} [{"} | p: (insert p {"} skip) ]]]
something like this (not tested)

i think i misunderstood something, replace {"} by {'} maybe

>> str: {1 ''2 '3 4 ' '5 ''6 '7 8 9 '0'}

>> parse/all str [some [{''} | [{'} here: (insert here {'}) skip] 
| skip]]
>> print str
== {1 ''2 ''3 4 '' ''5 ''6 ''7 8 9 ''0''}

note all ticks... ( ' ) are single quote chars in the above.

same as mine, except i use THRU to speed up the process

Thanks!  I'm going to have to look @ this for awhile to understand 
why you even need to worry about the double-quote character.  Much 
to learn....

Thanks Maxim and Steeve for the prompt replies!

print it out in the rebol console... you will see that my exampe 
doesn't nave any double quote characters.. they just look like so 
in altme's font  ;-)

corrected version with thru:

>> parse/all str [ any [thru {'} [{'} | p: (insert p {'} ) skip ]]]

Ah!  when you said "...you match double quotes first then fallback 
to single quotes, ..." I was thinking double-quote character, not 
double single-quotes.  Need more coffee...

Thanks very much!

( I can see that being misleading when read hehehe :-)

Just curious, I tested both versions and Steeve's version is about 
2times faster than Maxim's :)

we should add a DONATE account somewhere, linked with Altme.

I'm sure people would be glad to add 1 dollar for such fast assistance.
Then, we could finance some interesting projects

actually, having a paypal account linked with your login and a "donate" 
button would be really nice :-)  right in the chat tool.

I sure would use it... some people have helped save days of work 
with free code and insight.

I'd gladly give back a few $ for their efforts

Jack, Parse is my fav REBOL command.  If I ever have time, this is 
the one funciton I would like to create hundreds of examples for 
in a Wiki.

newbie's solution,without  PARSE:
>> s2: {1 ''2 '3 4 ' '5 ''6 '7 8 9 '0'}

>> replace/all s2 {''} {'}     replace/all s2 {'} {''}      print 
str
1 ''2 ''3 4 '' ''5 ''6 ''7 8 9 ''0''
>> str == s2
== true

I just adopted a new notation standard for parse rules... the goal 
is to make rules a bit more verbose as to the type of each rule token... 
I find this reads well in any direction, since we encouter the "=" 
character when reading from left to right or right to left... and 
parse rules often have to be read from right to left.

example:

=terminal=: [

 =quote= copy terminal to =quote= skip (print ["found terminal: " 
 terminal])
]


on very large rules, and with the syntax highlighting in my editor 
making the "=" signs very distinct, I can instantly detect what parts 
of my rules are other rules or character patterns... it also helps 
out in the declarations... I see when blocks are intended to be used 
as rules quite instantly where ever they are in my code.


in my current little parser, I find I can edit my rules almost twice 
as fast and loose MUCH less time scanning my blocks to find the rule 
tokens, and switching them around.

wonder what you guys think about it...

another example.... in this dense block of text, I can spot the =eol= 
 (end of line) token instantly in both x and y dimensions of the 
rule paragraph:

=line-comment=: [
	=comment-symbol= [
		[thru =eol= (print "comment to end of line")]
		|[to end]
	]
	(print "success")
]

when using rules in other contexts, they also stick out...

=alphabet=: rejoin [=digit= =letter= bits "_"]


here I immediately see that bits isn't a rule, but a function or 
a word.

with syntax highlighting it's quite amazing how    bits   stands 
out. ... in my editor at least.

use color instead :)

what do you mean color?

Use an editor that colorises the words

Gab uses the == in his literate editor ..

Chuck Moore uses color extensively in his color forth .. to replace 
other types of syntactic markup.

syntax highlighting colorizes words ... stuff is colorized... but 
user words aren't colorised and they all get mixed up between functions, 
variables and rules... and having colors which are two strong next 
to each other and in relative distribution ... cancels out.

stuff is colorized... (*in my editor*)

so you could write a parser that reads your rules and colorises them 
...

without the need for all those = signs everywhere

but not while I'm coding... this is not for presentation, its for 
coding... I'm writing rules twice as fast now... just cause I'm not 
waisting time "searching" for the keywords within all of that text.

exactly ... for coding.