World: r3wp

What I want is work with first four numbers and not with the last 
one

Is it always 5 numbers ?

No :(

>> parse [1 2 3 4 5][4 [set val number! (print val)] number!]
1
2
3
4
== true

Actually, the real elements may be very different. I just simplified 
the example.

Ok, so you don't know how many numbers you have until you fail to 
find another one.

I want to process all elements excluding the last one.

And do you want to avoid putting them into a block first ?

They are in block already

Actually, you can do it like this:

>> parse [1 2 3 4 5][any [set val number! pos: number! (print val) 
:pos] number!]
1
2
3
4
== true

Interesting, that should probably work, thanks!

Welcome.

Actually, the last   number!   can probably become   opt number!

for the case when there are no numbers at all.

there is at least one. I f theres at least one, don't do any action. 
If there are two do one action and so on.

Ok, that should be ok then.

Man, I wish you could do:

	parse [1][integer! -1 skip]

and arrive back at the head of the input.

infinitive loop?

(infinite)

Another possible way:

>> parse [1 2 3 4 5] [any [set val number! pos: (if not tail? pos 
[print val])]]

Anton, you can do:
>> parse [9] [integer! to 1]
and arrive back at the beginning.

Oh yes! forgot about that. :) Great !

Can you explain this curious results ?

REBOL/View 1.3.2.3.1 5-Dec-2005 Core 2.6.3

>> parse [1 2 3 4][any [number! set val number!] (print val)]
4
== true
>> parse [1 2 3 4 5 ][any [number! set val number!] (print val)]
4
== false
>> parse [1 2 3 4 5 6][any [number! set val number!] (print val)]
6
== true

>> parse [1 2 3 4 5 6 7][any [number! set val number!] (print val)]
6
== false

>> parse [1 2 3 4 5 6 7 8][any [number! set val number!] (print val)]
8
== true

note the results with odd numbers of items!

Forget my  question. I see that the block tries to consume two items.(

:)

'parse' is the path to great explorations and inventions - and also 
to great confusion and maybe despair. ;-)


No really, it can be a bit confusing at times, but I guess, it can't 
be done otherwise to have such great functionality. There's no short 
cut with 'parse'. Learning by doing is the way to go. And it's a 
brilliant tool!

So it is

parse [1 2 3 4 b 5][ some [ set val number! v:   number! :v (print 
val)]  to end (?? val)]

too late.(

Maybe someone will find this usefull:

count-word-frequency: func[
	"Counts word frequency from the given text"
	text [string!] "text to analyse"
	/exclude ex [block!] "words which should not be counted"
	/local counts f wordchars nonwordchars
][
	counts: make hash! 100000

 wordchars: charset [#"a" - #"z" #"A" - #"Z" "�������������̊�؎����ύ�Ѫ�"]
	nonwordchars: complement wordchars
	parse/all text [
		any nonwordchars
		any [
			copy word some wordchars (
				;probe word
				if any [not exclude none? find ex word][
					either none? f: find/tail counts word [
						repend counts [ word 1 ]
					][
						change f (f/1 + 1)
					]
				]
			)
			any nonwordchars
		]
	]
	counts: to-block counts
	sort/skip/compare/reverse counts 2 2
	new-line/skip counts true 2
]

If you know some other chars, which should be included in the words, 
please let me know, now it should be complete for czech language 
and hope that for spanish too (as I use it to count spanish words:).

found missing czech chars->  wordchars: charset [#"a" - #"z" #"A" 
- #"Z" "���������������̊�؎����ύ�Ѫ����"]

Is this a bug?
parse/all {"some words"} {" }
;== ["some words"]
parse/all {and "some words"} {" }
;== ["and" "some words"]
parse {and "some words"} {" }
;== ["and" "some" "words"]
parse {"some words"} {" }
;== ["some words"]

Good question! It's in a tough corner of REBOL - parsing. REBOL is 
in many ways more like a human language, than a computer language. 
Strictly speaking, you can argue, that those examples have a bug 
or two, but can you live with it? The behaviour might make it difficult 
to parse input strings, written by humans, because people write all 
sorts of things. (If it can go wrong, it will.)


Try change the quotation marks to something else and see the results 
change, like:

>> parse/all {Xsome wordsX}�{X }
== ["" "some" "words"]

parse, without a rule, treats quotes specially. this is to allow 
parse to be used directly with things like csv data.

I think it's a bug! I was trying to use this to divide large string 
to words and found that I have all sentences inside , instead of 
just words. It's problem only if you have the divider on the edge.

In the Geomol's example I would expect the result to be ["some" "words"] 
so it must be bug - it's inconsistent

this behavior is the one intended by Carl. so, it's so by design, 
and not a bug. but, you may try to convince Carl that you don't like 
it. ;)

I still think it's a bug - I cannot see the diference between parse 
and parse/all in this example. If Carl don't want to fix it, no problem 
for me, I used more complicated rule to do the same thing, just still 
think, it's a bug and it will confuse more people in the future as 
well.

but the true is, that in CSV is logical to have: parse {,d ,d} {,} 
== ["" "d" "d"]

and parse {,"a b, d"  ,d} {,} == ["" "a b, d" "d"]  (so probably 
Carl has true;-)

But it should be in documentation, that the quotes are very special 
characters for such a type of parsing!

There is also bug in doc: http://www.rebol.com/docs/core23/rebolcore-15.html
(section 2 - Simple Splitting) -> there is sentence: "To avoid that 
action, you can use the /any refinement." where shoud be /all as 
there is no /any refinement in parse!

oldes, rambo the documentation problem.

done

.

I think it would be good to have some standard place for common parsing 
rules and charsets used in parse rules, like 'digits, 'spaces' and 
other, what do you thing?

I like the idea in theory, but what are standard parse rules ? There's 
an argument already - look, I'm arguing ! :)

I would prefer to call the "digit" rule "digits". Also, for this 
example, it's faster to define and be clear with it:
	digit: charset "0123456789"
than being abstract: (even though it would become well known):
	digit: system/parse/rules/digit

Oldes a regex context will be a good addition. Where regex are the 
basic rules for numbers, white space, *words* and their negations.