World: r3wp

For other applications, I use different dialects, like eText for 
simple text -> HTML layout.

Something to consider, when you have cases like Chris's href examples 
above, is the separation of syntax and semantics. Also, for Robert's 
examples, remember that most languages have very strict rules and 
a lot of "markers" to make parsing easier (at the expense of making 
things harder to write). VID is a great example of a language that 
works hard to be flexible.

Look at your dialect from the top down too, as a user will. Write 
example code in it and think about how you expect it to behave.

And remember, LANGUAGE DESIGN IS HARD.

Nah, it took Carl merely twenty years to come up with REBOL

:-D

My goal is to create the dialect in a way that it's easy to use for 
non-techies. Yes, it's hard but hey, otherwise it would be no challange.

Robert: you don't need to have any knowledge of PARSE to design a 
dialect. The only thing you need is to know how the dialect should 
look and work.

e.g. I am not implementing all my dialects using PARSE

Robert: Why not settings the words to none! just when you clear the 
block :

strings: copy [] integers: copy []

rule: ['keyword (clear strings clear integers   size: maxlength: 
caption: default: none  ) some [set p integer! (append integers p) 
| set p string! (append strings p)] (size: integers/1 maxlength integers/2 
caption: strings/1 default: strings/2)]

then, none! is default unless you specify Size and, maybe, Maxlength.

Ups, it's even not needed : if Integers is empty, then "size: empty/1 
--> none!"

So, mix the both : the 'maxlength and 'default keywords :

rule: [
	'keyword (clear strings clear integers)

 any [set p integer! (append integers p) | set p string! (append strings 
 p)]

 (size: integers/1 maxlength: integers/2 caption: strings/1 default: 
 strings/2)

 any ['maxlength set p integer! (maxlength: p) | 'default set p string! 
 (default: p)]
]

tests: [
	[]
	[keyword]
	[keyword 10 20 "Blue" "Orange"]
	[keyword 10 "Blue"]
	[keyword 10 20]
	[keyword "Blue" "Orange"]
	[keyword 10 "Blue" 20 "Orange"]
	[keyword "Blue" 10 20 "Orange"]
	[keyword "Blue" "Orange" 10 20]
	[keyword "Blue" maxlength 20]
	[keyword 10 default "Orange"]
	[keyword maxlength 20]
	[keyword default "Orange"]
	[keyword maxlength 20 default "Orange"]
	[keyword default "Orange" maxlength 20]
]

strings: copy [] integers: copy []
size: maxlength: caption: default: -1

foreach t tests [
	parse t rule
	print [mold t "==>" size maxlength caption default]
]

Dide, yes I have found the side effect of empty/1 == none! as well.

About mixing: I'm thinking of something like this:

(keyword: none)
any [

 opt ['maxlength (keyword: 'maxlength) | 'default (keyword: 'default)]]
	any [set p integer! (repend integers [keyword p])
	...

I think you get the idea.

I had this problem a couple of weeks ago when trying to write a function 
to repopulate a web page from the posted cgi object.

As said, my goal is to reduce the number of keywords as much as possible 
and make it easy to use.

Are you trying to parse html to see if it is valid or not?

No, I'm doing a dialect to create HTML forms with CGI etc.

I suspect a mixed positonal + keyword approach may be the best.
Positional for for common attrbutes.
Keyword for the more esoteric ones.
Maybe read up on CSS shorthand methods for inspiration.

Yes, right that's what I'm going to do. Thanks for the CSS tipp, 
I take a look at.

I've defined a new format, which is a REBOL version of XML. I already 
have scripts, that can convert between this format and XML. So far, 
I've called the functions "xml2rebol" and "rebol2xml", but maybe 
"rebol" isn't a good name for the new format. I've thought about 
"rebxml" as a name. Any ideas or suggestions? This is a quick explanation 
of the foremat:

tag (optional attributes) string or block

If the string is empty, it's an empty element tag. In XML: <tag/>

If attributes are present, they are one or more pairs of a word and 
a string.
A block can hold strings and new tags.

This XML example:

<person alive="yes"><name>Mr. Smith</name><male/><address><street>Sunnylane</street><number>44</number></address><person>
will look like this in the new format:

[ person alive "yes" [ name "Mr. Smith" male "" address [ street 
"Sunnylane" number "44" ] ]

Other examples:
<tag></tag> = tag [ "" ]
<tag>content</tag> = tag "content"
or tag [ "content" ]
Both are valid.

Correction!
This XML example:

<person alive="yes"><name>Mr. Smith</name><male/><address><street>Sunnylane</street><number>44</number></address></person>

I like this.. 
°Mr. Smith° (main °7°) has the following..
 
	°Class?° °Person°
	°Alive Dead Status° "Alive"
	°Address 1° "44"
	°Address 2° °Sunnylane°

Notice that °Sunnylane° and °Person° are themselves °7°s?  This means 
that more information is available regarding them.. ie:

°Sunnylane: last time paved?° 
or 
°Sunnylane: set last time paved -=24-Oct-2001=-°


Because °Mr. Smith° is a °Person°, we could make a query like.. °Mr. 
Smith: requires food to survive?°  and have the system respond "Yes."

:)

Geomol, you might want to look at my ML dialect which has something 
very similar to what you're doing. ML is my Rebol dialect for writing 
XML.

In ML

In ML
/tag   ->     <tag/>
tag []    ->   <tag> (stuff in block) </tag>

tag/attribute value []    ->   <tag attribute="value"> (stuff in 
block) </tag>

<tag attribute="value"> []   ->   <tag attribute="value"> (stuff 
in block) </tag>

And it's all in one function.

An "Internal dialecting" discussion. Currently REDUCE has got a REDUCE/ONLY 
option to specify, which words are *not* evaluated

I, OTOH, found an "opposite" approach specifying which words *are* 
evaluated very fruitful.

Examples are my BUILD dialect:

build/with [let's see what] build/with [what: [the rise of the (y)]] 
[
        y: 'sun
    ] ; == [let's see the rise of the (sun)]

or my SUBSTITUTE dialect:

Do you have an example where reduce/only works. I only get errors.

tests: substitute [
		generate-test [
			set variable value
			eq variable 1
		] [value] [1 2]
		return "OK"
		label fail
		do discard [print ["test:" mold testing "failed"] halt]
	] [generate-test]

Reduce/only example:

example:
!> reduce/only[green blue][green]
== [green 0.0.255]

>> reduce/only [a b c d] [b c d]
== [1 b c d]

Maybe we need both reduce? AFAIK currently it is to have a reduce 
which allows keywords.

Ah. Interesting. I think I needed this in the past I didn't know 
it existed.

Good idea IMHO. Sadly i managed to crash it in my first try.

I wish build was part of rebol. I find it a lot easier to use than 
compose. Only that slower.

Bill Gates says "We need dialects"
http://microformats.org

(Actually he said "microformats" -- but I can't see any real difference 
in intent)

Hum, not sure it's dialect equivalent. It looks like some "XML samples" 
to replace existing text format (ie iCal => hCalendar)

IMO nothing to do with dialect... AFAICT they are simply structured 
xml definitions...

vCard --> iCard --> hCard  ... plenty of alphabet to go for future 
formats ;-)