World: r3wp

Watch out when porting to R3 though, as PARSE itself is considered 
a loop there for BREAK in parens.

ah yes... forgot about that, even better.

in R3, does ( BREAK ) return the whole parse?

(BREAK) breaks out of the whole parse, as does RETURN; BREAK breaks 
out of an interation, which all enclosing rules are, so it will break 
out of any block, not just ANY, SOME and WHILE blocks.

what's the best practice for recognizing words with certain syntax? 
(besides using the various word variants)

i was thinking about using the datatype notation or similar pre-/postfix 
characters

Can you give us examples of these words, you want to get recognized 
by parse? Then it may be easier to give opinions.

If you mean things like "word!", then this is a way:

alfa: charset [#"a" - #"z" #"A" - #"Z"]
numeric: charset [#"0" - #"9"]
alfa-numeric: union alfa numeric

parse "word!" [copy word [some alfa any alfa-numeric "!"] (probe 
word)]

Will also parse "word2!, but not "1word!".

i was not talking about matching string input. that's obvious

parse [some word! other* stuff']

I'm not sure, I understand, but maybe you mean something like:


>> parse [a few words of type word! "string" 1] [some word! string! 
integer!]
== true

Else it would be easier with an actual example.

this was an actual example.

i can match it with [some word!] but i would like to differentiate 
between the words based on what is their last character

i know it's suboptimal, just wondering if still possible somehow 
to reject a matching rule later somehow

parse [xxx*] [set w word! (unless #"*" = last to-string w [doesnt-match])]

Ah ok, then you need to convert the word to a series, for example 
a string, and check on last letter:


parse [some word! other* stuff'] [some [set word word! (print last 
form word)]]

It's tricky to reject a rule later, and PARSE has changed over time, 
so I'm not sure.

ok, this is how i imagine a solution would look like:
>> parse [normal-word  word-with-star*] [word! starred-word!]
== true

I would use string parsing in this case.

i would rather use a separate word as a modifier then. makes things 
a lot simpler. maybe i would do a pre-processing 1st to break up 
these words into separate ones

is this in R2 or R3?

doesn't matter, since im just curious.

in R2,  the best way is to set a word to the value you're evaluating, 
and conditional to that value's pass/fail, you switch the following 
rule to allow it to continue or track back, so it matches another 
rule.


here is a rather verbose example.  note that this can be tweaked 
to be a shorter rule, but it becomes hard to map out how each part 
of the rules relate.. here, each part is clearly layed out.

rebol []


pass-rule: [none]
fail-rule: [thru end]

condition-rule: pass-rule



parse [
	word-a
	"ere"
	835
	word-b
	15
	word
	86
	bullshit
	#doglieru3
	word-c
][
	any [
		
		[
			; this rule only matches words ending with "-?"
			set val word! 
			[
				[
					(
						val: to-string val
						either #"-" = pick (back back tail val) 1  [
							condition-rule: pass-rule
						][
							condition-rule: fail-rule
						]
					)
					condition-rule
					(print ["PATTERN WORD:" val])
				]
				|[
					(print ["Arbitrary word: " val])
				]
			]
		]
		
		| skip
	]
]

ask ""

in R3 there are some new Parse ops which allow to make this almost 
a one-liner

(I just don't have time to build you an example... :-p  )

R3 but obfuscated.

match: [
	  some [thru #"-"] skip end 	(print [w "end with -?"])
	| some [thru #"*"] end		(print [w "end with *"])
]

parse  [
	word-a 	"ere" 	835 	word-b 	15
	word* 	w86	bullshit*	#doglieru3 	word-c
][
	some [
 		  and change set w word! [(form w)]
		  change [do into match | skip] w
		| skip
	]
]

hmm.. thanks a lot guys!
so practically i can fail in R2 by trying to match 'none?

no, by trying to match  [thru end]

none    *never* fails.

oh, so u can't go THRU end only TO end ?

yep.

it going thru end would break space-time, so its not allowed by the 
interpreter    ;-)

going thru end would break space-time

 - it is allowed in R3 and there is no reason to break anything, in 
 fact. It is just about the implementation.

Ladislav: any other pass/fail technique in R2?

imean dynamic pass/fail

Did you check the


http://en.wikibooks.org/wiki/REBOL_Programming/Language_Features/Parse/Parse_expressions#Parse_idioms

article?

I guess, that the methods described in the idioms section can be 
used (but have not read the above discussion thoroughly).

[thru end] is not a good rule to use to fail. A much more reasonable 
rule is [end skip]

i just read carl article about the call for making that idiom page. 
but when i checked it didn't have much stuff yet. thx for the reminder!

Lad   [thru end] means *exactly* the same thing as  [end skip].  
 I don't know why R3 decided to change that, but I find that a regression.

It does not, Max.

[thru end] is supposed to mean:

[end | skip]

, i.e. it fails in R2 only because of the faulty implementation

Err, correcting myself

a: [thru end] is supposed to mean the same as a: [end | skip a]

And that should never fail

See the above section.

thru is supposed to move the cursor *past* a match,  you cannot go 
past the end, you can only be at the end (the same way you cannot 
go past the tail).

Where do you think the cursor is after matching the [end] rule?

Just try the idiom

a: [b | skip a]

and you will see, that it always means the same as

a: [thru b]

(no matter how many characters the B rule matches)

to doesn't match the end... it moves to it..  its different than 
simply putting  end in a rule.  thru is supposed to move PAST the 
result of a to.

>> parse/all "12345" [[to "5"] a: (probe a)]
5
== false
>> parse/all "12345" [[thru "5"] a: (probe a)]

== true

>> parse/all "12345" [[to end] a: (probe a)]

== true


so if I try to move past the end, its logical that it raises a failure, 
since it cannot advance one more character.

That "advance one more charactef" is where you are wrong. The THRU 
directive has to stop after matching the rule, not "advance one more 
character".

In this case there is no right or wrong, its a question of opinion. 
 There is no *after* the end, as far as I am concerned.