World: r3wp

the difference with your program is that [none] is not containing 
the none value but the none word.
if you reduce your example , it mays work
junk: reduce [none [1 2 [3 4]]]

Ah, forgot to copy that part - I'd done "junk/1: none" to make sure 
it was a none value

Steeve: that seems to have done it. thanks for clarifying.

or use #[none] instead

Gabriele what #[none] really does/means? I've seen it few times having 
no clue about its functionality.

Pavel, try:

mold/all none

it's just a serialized version of none!, so you can load it as a 
real none value instead of a word.

Pavel, this also works with datatypes.  For example:

>> mold/all string!
== "#[datatype! string!]"


This is useful if your loading values from a file.  This way your 
sure to set a value to a string datatype! when desired.

#[none] is the value of the word 'none. It is the literal representation 
of the value of type none!.

THX for description to all

Hi, I have one question .. can you somehow break out of some loop 
by rebol code .. for example


parse [ aa zzz cc ]  [ some [ set W word! ( ?? W if equal? W 'zzz 
[ break ] ) ] ]  ...  that break doesn't work that way, but is there 
some way to do this? I need to compare W with a runtime value

throw an error?

I solved it in a way that I can just return out of whole function 
(with return) at that point so it's ok .. first I had it thought 
out in a way that I would need to exit the some [ ] loop but continue 
parsing .. error probably wouldn't work that way either? This is 
now my code..match: 

match func [ data rules ] [
	parse rules [ 
		SOME 

  [ 	set L lit-word! ( either equal? L reduce first data [ data: next 
  data ] [ return false ] ) | 
			set W word! ( set :W first data  data: next data ) 
		] 
	]
]

; Here's one way to do it...

>> digit: charset "1234567890"
== make bitset! #{
000000000000FF03000000000000000000000000000000000000000000000000
}

>> rule: [s: some digit e: (print copy/part s e) | h: #"a" (h: tail 
h) :h | skip ]

== [s: some digit e: (print copy/part s e) | h: #"a" (h: tail h) 
:h | skip]
>> parse "12b34c56a78" [any rule]
12
34
56
== true

Another possible way is by setting at runtime a [break] rule :

branch-rule: [ ]

parse [ aa zzz cc ]  [ 
	some [ 
		set W word! ( 
			?? W
			if equal? W 'zzz [ branch-rule: [ break ] ]
		)
		branch-rule
	]
]

Ah, thanks Ammon and Dockimbel! haven't thought of these two ways 
(well I don't yet fully understant Ammon's)

charset create a "mask" in bitset form to be compared to the curent 
item read from the string

some digit since digit is a bitset containing the binary image of 
 what you looking for (numbers char from 1 to

that means each content of the string will be compare to the mask 
and if that mach then you proceed to the calculation

the equivalent lame would be someting like foreach a string [ either 
find?  "1234567890" a [ append e a ][probe e clear e ] ]

so the ammon solution using charset / bitset and parse is the totally 
rebolish way

parse [aa zzz cc][some [set w word! (?? w cont: if w = 'zzz [[end 
skip]]) cont]]

Essentially what I'm doing with the above code is simply skipping 
to the end of the parse input when a given rule is matched. This 
works because a get-word in the parse rules sets the current parse 
input.  The get-word can be any value of the same type as the original 
parse input.  You can't set the parse input to a string! if a block! 
was provided to parse to start with.

Using your code to do the same thing...

match func [ data rules ] [
	parse rules [ 
		SOME 

  [ 	set L lit-word! blk: ( either equal? L reduce first data [ data: 
  next data ] [ blk: tail blk ] ) :blk | 
			set W word! ( set :W first data  data: next data ) 
		] 
	]
]

I'd like to take an english sentence and tidy it up.  I want to automatically 
apply english grammar to it ... so capitalize the first letter after 
a period, and remove extraneous spaces eg. a comma after a space. 
 Anyone done anything like this with 'parse?

Not yet but I've been thinking about it for quite a while now... 
 I think I have a pretty good idea what the parse rules should look 
like but I haven't written any code for it yet.

Good start...

letter: charset [#"a" - #"z" #"A" - #"Z"]
dirt: complement letter
word: [some letter]
clean: [here: dirt :here (remove here)]
space: [here: (insert here #" ") skip]
capital: [here: letter (uppercase/part here 1)]
sentence: [
	some [
		  capital opt word break
		| clean
	]
	any [
		  [#";" | #","] any clean space word
		| #"." any clean space capital opt word
		| #" " word
		| clean
	]
]

parse/all text: {test  test . test;; test ..test } sentence
probe text
>>"Test test. Test; test. Test"

I have made auto capitalising first words for some bot once .. it 
wasn't anything special , I can find the code and send it to you

ah, Steeve's already works

Has to be ehanced indeed

Hey, nice start ...

indeed, i'm nice

:)

have to add #"'" ie. ' to the letter charset

#"-" too and what with the numbers ?

for #"'" you should add a rule to remove spaces

Mine was meant so I cold make pretty texts with all upper case in 
some search engine.. maybe it doesn't work that great in all cases..

smart-uc-after: func [ str sep ] [

 parse str [ ANY [ thru sep mark: ( uppercase/part trim mark 1 insert 
 mark " " ) :mark ] ]
	str
] 

smart-case: func [ str ] [
	calc-with X [ 	
		[ lowercase str ]
		[ uppercase/part X 1 ]
		[ smart-uc-after X "." ]
		[ smart-uc-after X "?" ]
		[ smart-uc-after X "!" ]
]]
>> smart-case "HI HOW ARE YOU! we will go. bye!"
== "Hi how are you! We will go. Bye! "

numbers aren't usually part of words.  Unless it's trademark like 
3M

but mine is also worse because it does 3 parses instead of one like 
Steeve

calc-with: func [ 'wrd bs ] [  foreach b bs [ set wrd do b ] ] ; 
it uses this func also

Stevee's looks faster :)

yes, I agree :)

this is the rule for #"-" 
| #"'" any clean word

with that you supress unwanted spaces.
it'  s a good day
 --> "it's a good day"

so don't add ""'" as a vali

d letter

ahh ...

do as you want... :-)

trailing "." or "," gets lost

Also, I think have to add ' to the letter charset because words ending 
in s can have a trailing ' for possession ...