Hello,

I'm here as a simple amateur of all kinds of languages (including some human ones ;-)).
Discovered this project while searching for improvements for the [[http://www.wikidot.org | wikiDot]] markup, a really great wiki which engine is beeing delivered as open source. Have looked around, thought and designed //a lot// already. I'll try to expose the results of this reflexion progressively, here and on talk pages for specific topics.



= personal position

I'm rather looking for a basically better wiki markup language, than for one compatible with the present markups. So that principles such as
* no conflict
* not new
or
* (not really expressed but very present:) mostly used
are not relevant for me: they're rather second stage criteria. What I mean is that, to my opinion, these criteria are fundamental for a interwiki-only markup, precisely for mixing creole with local markup -- which sounds a bit alien to my ears. Otherwise
* author-friendliness
* **clarity/simplicity/consistency**
&
* speed to learn/memorize/master
are much more prominent goals.



= glossary

**segment :**
A bit of text inside a logical_line \\
May be enclosed in delimiter tag to indicate its style.

**style tag :**
A kind of mark/tag used to enclose a segment of text. \\
Used to apply the same formatting to the whole segment. \\
In creole, double characters are used.

**logical & visual lines :**
A chunk of text ended by a newline mark. \\
In regular text, a logical line is a paragraph ; it can also be a simple line, a header, a list item, a table row, when started with the appropriate layout tag.\\
A //logical// line may be split into //visual// lines with a soft newline.

**logical & visual newlines : ** a mark usually inserted by pressing the return/enter key. \\
A newline is both a plain character that creates a new visual line and, in most cases, a tag that starts a new line-component (see comment about this below under 'page structure'). \\
Logically enough, a newline preceeded by an escape (plain-character) tag becomes a visual newline : it loses its tag function but remains a plain character, thus starting a new visual line without marking the end of the logical line. \\
In many wiki languages, including creole, a newline works as above specified for all kinds of logical lines //except for regular text paragraphs//. In that case, a single newline is ignored ; a logical newline is marked by a double newline ; a visual newline is set by a special break tag.

**layout tag :** A kind of mark/tag placed at the start of a logical line \\
Used to set its layout.

**block :** Either a sequence of segments of the same type (e.g. a list made of list items), or a part of page included as a hole instead of beeing written (e.g. TOC, note list, image) \\
see "page structure"

**section = header / content :** Major semantic tailoring of a page. \\
A header is a segment ; may be split into title / subtitle. \\
A content is a sequence of blocks \\
//see "page structure"//



= page structure
// please improve & criticize on talk page//

=== page component tree

{{{
page
	section
section
	header
	content
header
	title
	subtitle
content
	block
		line (logical)
			line (visual)
				segment
					character
}}}

(A header could be a single-section block, thus both a section and a block ? Then, how to mark a subtitle ? There should be a tag. Splitting a header with a visual newline is not coherent, as it's not a tag. If we choose a new tag (e.g. '!'), then a header becomes a block with 2 logical lines. Similar to a definition block.)

This is a semantic, informal, structure : it is not actually marked by the tagged format, the reader only deducts it from the sequence of different page elements. Note that a header marks the start of a section (also if the following content is blank or even empty). But there is no delimited section in fact. //Idem// for logical lines in a block. //Idem// for segments in a line. \\
However, even if not formally marked, this structure could rather easily be constructed by an dedicated parser.

The page itself is a section, //id est// a header-body pattern. But it's not a sequence of sub-sections, as its body (content) can start -- and often actually starts -- with an untitled introduction. Idem for the sub-sections. \\
Thus, each body, including the page's content, is a series of blocks. Some of them can be headers, thus informally creating new sections.

=== semantic page structure

**key** :
? ==> this element can be present or not (0 or 1 time) \\
+ ==> this element can be repeated (1 or more times) \\
¤ ==> this element can be present any number of times (0, 1 or more times)

{{{
page                : header body
header              : title sub_title?
body                : block¤
block               : header | paragraph_block | bullet_list | number_list | table | imported_block | computed_block 
paragraph_block     : paragraph+
bullet_list         : bullet_list_item NL
number_list         : number_list_item NL
table               : table_row
imported_block      : {{//type// //ID// (|//parameter//=//value//)*}}
computed_block      : ((//type// //ID// (|//parameter//=//value//)*))
'|')*
}}}

** note the major difference between //semantic// & //markup// page structures** (lol)

=== markup page structure
{{{
page         : logical_line¤
logical_line : title | sub_title | paragraph | bullet_list_item | number_list_item | table_row | imported_block | computed_block
}}}

=== logical line components structure
{{{
header              : title sub_title?
title               : =+ text NL
sub_title           : !+ text NL
bullet_list_item    : *+ text NL
number_list_item    : *+ text NL
table_row           : (|text)+ |
paragraph           : logical_line_style_mark* text NL
}}}

=== inline text structure
{{{
text                : plain_text | styled_text | link | variable
styled_text         : distinct_text | important_text | litteral_text | monospace_text
distinct_text       : //plain_text//
important_text      : **plain_text**
litteral_text       : ??plain_text??
monospace_text      : ??plain_text??
link                : [[#?address (| text)?]]
variable            : <<//name//>>
plain_text          : (text_character | \tag_character)*
}}}

=== style markers :
{{{
distinct   : /
important  : *
litteral   : ?
monospace  : ?
code       : ?
}}}

=== special tags
raw character (escape) : '\' \\
glue  & scissor (see below) : '__' \\
//This mark is used to make a visual line out of two source lines, or the contrary -- may be useful ? Don't confuse with the logical line / visual line distinction discussed above. This tag marks a difference between source and displayed text.



= what I prize in creole

* the word "creole"
* the consensus processus
* the focus on the most important features
* the trend toward intuitiveness (self-explaining tags)
* more & more



= what I miss / what I don't like

//topics that will be further explained below/later//

* page title (!=page_name) & subtitle
* sub-headers
* "distinct" (example, quotation, remark, advice) & "important" segments parallel to "distinct" (italic) & "important" (bold) segments
* syntax for all kinds of magic-words, variables & functions -- see for instance [[http://meta.wikimedia.org/wiki/Help:Variable | wikiMedia variables]]
* syntax for "imported" blocks (page, image, widget...)
* syntax for "computed" blocks (toc, index, page list...)
* nowiki and monospace should be totally distinct !
* syntax for native (x)html, including (java)scripts (I propose most simply to double <> tags to <<>>)