World: r3wp

So, if Rebol gets the datatype wrong ( and real word data is dirty 
), you're screwed.

That's the tradeoff. :\

real world data is dirty ..

Maybe there should be no invalid datatypes .... everything can be 
converted to a datatype

if the parser thinks a datatype is invalid, well, let's call it an 
invalid! datatype!!

I think that's where string parsing comes in, and where having rules 
for REBOL datatypes would ease the pain.

I do screen validation by datatypes ( for data input ).  If the user 
enters an invalid datatype ... ..

anyway, I think rebol should recognise all data ..

have a catchall for stuff it thinks is wrong

I agree with you Graham, I was mentioning this many times, that there 
could be something to handle datatype exceptions

About the spaces charset - most people do not know that we have one 
more space char - non braking space:  >> to-char 160 <<

How about another way: integrate datatypes in string-parser. Basically 
a  load/next and check for type.
Then we can write (note i parse a string): 
parse "1 a , #2" [ integer! word! "," issue! ]

'invalite! has a problem: its easy to recognize where the wrong part 
starts, but harder to recognize where the wrong part ends.

Is there any RTF (Rich Text Format) parser  for Rebol?

hm, maybe this one: http://www.codeconscious.com/rebol/scripts/rtf-tools.r
:-)

Quick question for the parse experts. If I have a parse rule that 
looks like this:

parse spec [
	any [
		set arg string! (...) | set arg tuple! (...) | ...
	]
]

How would I add a rule like:

	set arg paren! (reduce arg)


that always occurred prior to the any rule and evaluated parenthesized 
expressions (i.e. I want parenthesized expressions to be reduced 
to a REBOL value that can be handled by the remainder of the parse 
rule).

I only parse strings  not blocks so this may be compleatly off  but 
I would try
parse spec [
	any[
		opt [here: set arg paren! (change :here reduce arg) :here]
		[	set arg string! (...) | 
			set arg tuple! (...) | ...
		]
	]
]

(here/1: do arg)

Thanks both, works a treat.

My brain is still asleep.  How to go thru a document and add <strong> 
</strong> around every word that is in capitals and is more than 
a few characters long?

hmm, quite a challenge ...

somehow to look-up words, mark: before, find its end (another space), 
check for if first is capital or not, change at position, :mark at 
end ...

but don't ask me for code, it would last few hours to get somewhere, 
if even :-)

pattern search on capitals, mark, copy to space, mark, count length 
of copy, if long, insert at mark2, and then at mark1, continue ??

I agree - a bit much to ask.  A more specific question would get 
a more specific answer :)

Something like:

file: read filename2parse
newfile: ""
Foreach word file [
   if Is-Capitals Word [
      newfile: join newfile ["<strong> " word " </strong> "]
]

The Is-Capitals function would have to be defined
Is-Capitals func [Word2Check] [
   some code here
]

that won't work because file is just text and not a block.

but my brain is gradually waking up now ... all I need to do is get 
dressed!

:-)

;thinking loud:
capitals: charset["#"A" - #"Z"]
capital: [5 capitals any capitals]

can you do this in one pass?

.Yes "Newfile would have to be "parsed" into words

something like:

Newfile: parse file

or 

file: parse/with file {separator character}

troubel is, parse doesn't only just parse on " " if specified ...

so, you might lose other characters.

I think this can be done in one pass.

I would not rely on parse helpers, as parse string delimiter, but 
use full parse/all, if you need precise result ...

Yes, give me a minute...

capitalize-word: func [

    s [string!]
    /local len

][

    either 5 < len: length? s [

        s: rejoin ["<strong>" uppercase s/1 next s </strong>]

    ][

        s

    ]
 
]



capitalize-text: func [
    s [string!]

    /local result word-rule alpha non-alpha w c
][

    result: copy {}
    alpha: charset [#"A" - #"Z" #"a" - #"z"]

    non-alpha: complement alpha

     word-rule: [copy w [some alpha] (insert tail result capitalize-word 
     w)]
    other-rule: [copy c non-alpha (insert tail result c)]

    parse/all s [some [word-rule | other-rule] end]
    result

]

>> capitalize-text {The result changes according to formating.}  
          

; 
== {The <strong>Result</strong> <strong>Changes</strong> <strong>According</strong> 
to <strong>Formating</strong>.}

Not quite the problem I was stating!

search for a series of capitalised words and strong them

Ah. Very easy modification.

bolden-word: func [
    s [string!]
    /local len
][
    either 5 < len: length? s [
        s: rejoin ["<strong>" s </strong>]
    ][
        s
    ]
 ]

enhance-text: func [
    s [string!]
    /local result word-rule alpha non-alpha w c
][
    result: copy {}
    alpha: charset [#"A" - #"Z"]
    non-alpha: complement alpha

    word-rule: [copy w [some alpha] (insert tail result bolden-word w)]
    other-rule: [copy c non-alpha (insert tail result c)]
    parse/all s [some [word-rule | other-rule] end]
    result
]

Thanks Jaime.

capitals: charset ["#"A" - #"Z"]
alpha: charset ["#"A" - #"Z" #"a" - #"z"]
non-alpha: complement alpha
parse/all/case [any non-alpha any [
    a: 5 capitals any capitals b: non-alpha (

        b: change/part a rejoin ["<strong>" copy/part a b "</strong>"] b
    ) :b |
    some alpha any non-alpha
] to end]

This is the Parse group after all.

ohhhh... shorter :)

; A few fixes
capitals: charset ["#"A" - #"Z"]
alpha: charset ["#"A" - #"Z" #"a" - #"z"]
non-alpha: complement alpha
parse/all/case [any non-alpha any [
    a: 5 capitals any capitals b: [non-alpha | end] (

        b: change/part a rejoin ["<strong>" copy/part a b "</strong>"] b
    ) :b |
    some alpha any non-alpha
] to end]

capitals: charset ["#"A" - #"Z"] ... remove  leading "

I think I missunderstood the problem. I thought the the emphasis 
was not for words all in uppercase. Just ther first char.

Yeah ... it was a way to mark up text wherever a sequence of CAPS 
occurs