World: r3wp

I used the method to drag-and-drop as used in Nick's Guitar Chords 
app.  It worked great for that type of drag and drop.

Hi, I'm starting with Rebol and I'm asking myself how to split a 
given string according to a pattern delimiter : "2 linebreaks or 
more" ?

Simplest way I can think of:
parse "One^/Two^/^/Three^/^/^/Four" "^/"
The ^/ is an escape character meaning newline

Izkata: thanks for answering me. In fact that's what I'm currently 
using, but that's not satisfying because I'm splitting with one linebreak, 
to two.  I'm looking for something that outputs : ["One^/Two" "Three" 
"Four"]

>> out: []

>> parse "one^/two^/^/three^/^/^/four" [any [copy arg to "^/^/" (append 
out arg) any newline] copy arg to end (append out arg)]
== true
>> out
== ["one^/two" "three" "four"]

Geomol, you are faster than me, but that's almost the same as I was 
coming up with :-)

:-) Now, is there any shorter/smarter way to do it?

it is probably easier in R3.

Thanks a lot Geomol (can you explain to me a bit your snippet? I'm 
currently studying the parse dialect)

Henrik: why would it be easier in R3 : does parse gained some additional 
tricks ?

The second argument to parse can be a string, and then parse split 
up the first argument, or the second argument can be a block of parsing 
rules. out is just my output block.

So the parsing rules go:
1) first any of a sub-block of sub-rules

2) sub-block copy the input string to a point, where two newlines 
are found, the result in the variable: arg

3) the paranthesis is evaluated (as normal REBOL code), and it append 
arg (the part of the string, we just copied) to the variable out
4) the parser then skip any number of newlines (2, 3 or more)

5) when the sub-rules are not valid any longer, the input string 
is copied till the end (and appended to out as before)

kib2: not yet, but there are some more logical string splitting functions 
in R3.

particularly string parsing needs to be improved. the above code 
should be simpler to do.

Geomol: thanks for the explanations. If I understand it well, that 
means that we can add actions during the parsing phase? That seems 
really powerful!

parse is ridiculously powerful (and equally hard to learn/use) :-)

yes, paranthesis can hold any normal REBOL code (or actions as you 
call it).

Henrik: you mean things like python's "...".split(delimiter) ?

yes

kib2, if you're going to use parse, go read this: http://www.rebol.com/docs/core23/rebolcore-15.html

Geomol: nice, I've made a print version of a nice doc I've found 
here http://www.codeconscious.com/rebol/parse-tutorial.html, but 
I don't know if it's up to date.

Henrik: from what I've seen so far, such things are quiet easy with 
parse.

That should be up to date too.

Geomol: ok, thanks. From what I'm reading, that's how Rebol builds 
all those dialects too.

I think, parsing in REBOL is really strong. It makes us read about 
any kind of input without too much hazzle (once you've taken the 
time to get a feel for parse).

yes, dialects can be processed with parse, however it's not the only 
method.

what makes parse truly powerful is multiple levels of dialects.

So Rebol does not really need regexps, that's it ?

What was the definition of a dialect? Something that LOAD can handle?

Geomol. yes I think so.

Parse seems to me like packrat parsers (pegs)

I can read parse dialects. I can't read regexp. :-)

Henrik: well, I think that's their purpose : your code becomes very 
readable. But what about the perfs ?

hehe :-)

Geomol: what do you mean ?! Poor or better than regexps ?

kib, I think, you'll find performance of parse to be really good, 
and I think, the reason is, that parse is native.

Geomol: you mean parse is C implemented ?

kib, I would say REBOL parse is a lot better than regexps. Yes, native 
words in REBOL is implemented in C.

parse is surprisingly fast, yes.

Geomol: cool. And does parse uses Unicode with R3 now ?

I think, Henrik is better to answer that.

R3 parse project: http://www.rebol.net/wiki/Parse_Project
It mention unicode.

I think it will support unicode, yes.

That's very nice. Is parse inspired from something (another langage 
maybe ?).

no

I have some rather large paring rules here:
http://www.fys.ku.dk/~niclasen/nicomdoc/nicomdoc.r
http://www.fys.ku.dk/~niclasen/nicomdoc/ndmath.r
and it's very fast to create a huge document from those rules.

*parsing*

shadwolf: thanks.

parse in the way it work is exclusive from rebol

Geomol: funny, I'm currently trying to port one of my Python project 
to Rebol : a markup langage with html/latex output !

ofcourse parsing a string with any language is a ground base (one 
of the 1st exercice of coding a studient will learn )