World: r3wp

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

no that parses every letter

I'm beginning to wonder if it is a bug in parse

Anyone know how to parse a string such that the newlines and tabs 
are parsed?  I'm not getting the results I'm expecting.

Hoping to see someone elses command in case I'm just brain farting 
something.

>> a: join "line1" [newline "line2"]
== "line1^/line2"
>> parse a [any [newline (print "newline found") | skip]]
newline found
== true

yeah, never had problems when parsing tabs and newlines

When parsing strings without the /all refinement, words are separated 
by space. Example that work:

>> parse "word1 word2^-word3^/word4" ["word1" "word2" "word3" newline 
"word4"]
== true
You can also explicit specify the tab:

>> parse "word1 word2^-word3^/word4" ["word1" "word2" #(tab) "word3" 
newline "word4"]
== true

Actually the #(tab) seems to be ignored, because you can specify 
it anywhere:

>> parse "word1 word2^-word3^/word4" ["word1" "wo" #(tab) "rd2" "word3" 
newline "word4"]
== true

But you get false, if specifying the space (which may be a strange 
thing):

>> parse "word1 word2^-word3^/word4" ["word1" #" " "word2" "word3" 
newline "word4"]
== false
Also you need to specify newlines, they are not seen as space:

>> parse "word1 word2^-word3^/word4" ["word1" "word2" "word3" "word4"]
== false

If you need to parse for tabs at certain places, use: parse/all
I hope, it helps!

>> b: [#(tab)]
== [# (tab)]
>> length? b
== 2
>> first b
== #
>> type? first b
== issue!
>> second b
== (tab)
>> type? second b
== paren!

so your "tab" is ignored because it's not a tab at all. it's the 
same as doing "" (tab) in the rule, ie empty string (always matches) 
followed by code that basically does nothing.

Aha! :-)

How did I get #(tab) in my head!?

So to explicit specitying the tab, it must be:

>> parse "word1 word2^-word3^/word4" ["word1" "word2" "^(tab)" "word3" 
newline "word4"]
== false

So that doesn't parse, meaning tabs are seen as spaces.

Sorry about any confusion! :-)

And I guess, tab can be specified in the rule-block more simple as 
in::
["word1" "word2" tab "word3" newline "word4"]

you need parse/all to be able to parse spaces and tabs.

Thanks everyone for your posts on this

Paul, it could be good to know, if you got it to work!?

G: #"^(tab)"

Probably.

Hi all,

Are there any good references to learn PARSE?

There is a parse page on the Wikibook.

Found it -- Thanks

Also this about parsing: http://www.rebol.com/docs/core23/rebolcore-15.html

parse/all  and used "^-" for tab