World: r3wp

lol

we need a wiki just for parse

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

Exactly!

books books, scripts in rebol.org are enough for me

There is always another trick, and another level to Rebol, the docs 
NEED to be in a Wiki, where we can add to them, let them live, breath...

there is a rebol wikibooks

Yeah, it needs someone to kick it off, get it started, fill it with 
about 50 good words.  Where is a "kid" when you need one?

playing with their new iphones and parsing text messages internally 
:)

so, spending money to be cool

(but what is the interest to purchase what everyone wants, that's 
not cool at all)

REBOL is cool, and free

Steeve do you have any case where the self modifying recursive parse 
rule above fails?

>> ; insufficent pattern
>> data: "first rule second rule third "
== "first rule second rule third "
>> erode: [a | b | c]
== [a | b | c]
>> parse/all data rule
== false
>>
>> ;;; unused rule before pattern is consumed
>> data: "first rule second rule third rule "
== "first rule second rule third rule "
>> erode: [a | b | c | a]
== [a | b | c | a]
>> parse/all data rule
== false
>>
>> ;;; patterns and rules allowed in any order
>> data: "first rule second rule third rule "
== "first rule second rule third rule "
>> erode: [c | b | a]
== [c | b | a]
>> parse/all data rule
== true
>>
>> ;;; multiple (duplicate) rules allowed
>> data: "first rule first rule second rule third rule "
== "first rule first rule second rule third rule "
>> erode: [a | b | c | a]
== [a | b | c | a]
>> parse/all data rule
== true
>>

no i don't, it's an intersting alternative to my own code

a crazy simple alternative from DocKimbel (non repetitive pattern 
and limited to rules with single char)

>> rule: [(c: charset "ABC") 3 [copy v c (remove/part c v)]]

>> parse "ABC" rule
== true
>> parse "BAC" rule
== true
>> parse "CBA" rule
== true
>> parse "ABA" rule
== false
>> parse "ABCA" rule
== false

How do you build parse rules?

rule: copy []
word: "abc"

;; Want to compose the block to look like this  ["abc" (print ["found 
word len" 3])] 

insert tail rule compose [(word) (print "found word len (length? 
word))]  no go - obvious

I've tried  compose/deep [(word) (to paren! [print ["found word len" 
(length? word)])]  but length? word doesn't get composed, it gets 
included in the to paren! expression  compose/only/deep same thing


I guess the question is what is the technique to compose something 
that is to include paren! expressions with data inside that needs 
to be composed?  **With binding of course**  :)

reduce [word to paren! compose/deep [print ["Found Word of Length" 
(length? word)]]]

compose [(word) (to paren! compose/deep [print ["found word len" 
(length? word)]])]

was almost there

Thanks gentlemen.  I've struggled with that one on and off for...well 
forever.

compose/deep before the to paren! block, makes so much sense...ummm, 
now.  Now that I've seen it.  :)

after

well after  to paren!  before the block  ...in between.  :)   This 
trick is one of those V8 'tok' to the head moments.

How should string parsing work? I see something peculiar:

>> parse "1 2" [copy a1 integer! copy a2 integer!]
== true
>> a1
== "1"
>> a2
== " 2"
>> to integer! a2
** Script Error: Invalid argument:  2

Doing it this way make a2 different:

>> parse "1 2" [copy a1 integer! opt [copy a2 integer!]]
== true
>> a1
== "1"
>> a2
== "2"
>> to integer! a2
== 2

when using parse (not parse/all) you can skip spaces putting something 
like "" in the rule

eg [copy a1 integer! "" copy a2 integer!]

i always use /all though.

I ended up doing something similar. I just speculate, if parse can 
be made easier to use, when doing string parsing without /all.


Also string parsing can deal with the integer! datatype. Why not 
other datatypes? Are there deeper reasons for this?

Gabriele, do you know, if there are changes to parse in R3? Maybe 
string parsing without /all should be changed.

No changes yet. I agree that parse needs some improvements - we've 
written whole papers on that.

AFAIK, datatype matching is reserved for block! parsing. IMHO it 
should report a dialect error! in your example. Is string! matching 
supposed to support datatypes in latest core releases, maybe I missed 
an evolution ?

One of those proposals, brought up in the comments of one of Carl's 
blogs, is to unify the block and string parsing dialects.

doc, integer! works for strings for some reason. it's the only one 
that works, and seems to match a sequence of digits (not sure if 
it does anything more than that). it's been there since a long time 
(probably from the beginning ;) but not documented.

It looks to me more as a bug than as an intended feature (maybe a 
side effect of the block! parsing addition?). Anyway matching REBOL 
datatypes in string! parsing mode could be a useful feature and would 
make a lot of parsing rules shorter.

I asked Carl at the first devcon for the rest of the datatypes when 
string parsing and he agreed at the time that if integer! was in 
there others should be as well.

Is it possible to parse exact integer! value? something like parse 
[1.0][1.0] but with integer!. And something more "elegant" than parse 
[1][set val integer! (equal? val 1)] :)

parse [1 2 3] [1 1 1 1 1 2 1 1 3]   You have to trick the repeat 
ranges

Alternative:
parse form [1 2 3] ["1" "2" "3"]

Yet another alternative:
>> parse [1 2 3] [1.0 2.0 3.0]
== true

thanks for suggestions

Think, the last alternative only works, because both integer and 
decimal are categories of number. It doesn't seem to work with other 
'number'-like datatypes, like money or tuple.

I was just curious how to do pattern-matching in REBOL  with parse

Anyone know what "^-" is called?

is thta a tab?

>> tab
== #"^-"

yes :-)

ok

I'm trying to parse data using that but seem to get it parsing some 
spaces also

parse/all perhaps

I'll try it