Hi,

[...]
> >>Also used for email addresses?
> > 
> > Yes. ((<URL:mailto:gotoken / notwork.org>)) is also legal URL. 
> 
> I mean something like: ((<c.hintze / gmx.net>)) :-)

That is not enough because Headline like "== c.hintze / gmx.net" is not
illegal. Even if Nobody wrote such RD maybe.

> >>> Tosh suggested to use "(x ... x)" instead of "((x ...x))". Tosh think 
> >>> "(x ... x)" is more simple and more naturally embeded in plain text.
> >>> But Mr.Goto is afraid that "(x ... x)" is so simple that it may cause
> >>> some trouble.
> >>
> >>I think you are right, but Goto also :-) The `((x..x))' syntax seems to
> >>be more error prone!
> 
> Arrrghhh! Forgot my dictionary. I meant something like "not so easy to
> mistakenly used". I mean *NOT* error prone!!! Sorry! Forgive me!
> Urrrgghhs! :-]
> 
> > 
> > Shall we elect? :-)
> 
> No! Not necessary! Simply use `((x...x))'! Do not need to chose ;-)))

?????
Sorry, I don't understand.
\cle think which is better? "((x ... x))" or "(x .. x)"?
(gotoken like "((x ... x))", and Tosh like "(x ... x)".)

> >>May I suggest another thing? If there is a text like 
> >>
> >>	`(( This is text ))' or `(( This is text))'
> >>
> >>you could treat that *not* as inline-element, and remove *one* leading
> >>whitespace! I.e. it would become `((This is text ))' or `((This is
> >>text))' respectively!
> > 
> > Hmm, What do you ame by this feature? But whitespece treating should
> > be decide. Japanese guys maybe not sensitive this problem :-)
> 
> I can think a situation, where I want to express just that: ((*no*)).
> Not meant inline but verbose.
> 
> If I would use the `(('((*no*))'))' construct, it would look a little
> bit, erhm clumsy?!?
> 
> Furthermore I assume that text set within `(('...'))' would be set into
> another font? I would like to be able to set it using the current font.
> 
> Perhaps we could also use it as: \((*no*))? Perhaps it would be enough
> that there is a `\' in front of the inline element to prevent it from
> taken into consideration as inline-element? It may be a better solution
> than the `ignore blanks' one.
> 
> What do you think?
> 
> [...]

uum, you will write such "((x ... x))" type brace as not InlineElement
frequently?
There is another suggestion. back-slash escaping like "((\x ... x))".

> > Well, we often use embedding document as `lines killer' in daily hack. 
> > But current RD does not deal with such a hackish comment, all embedding
> > document will be printed. Though it maybe right (pedantic) manner, 
> > I feel too rigit. For example
> > 
> > =begin ignore
> > Ahhhhhhh!! why doesn't callcc work as I intend?
> > 
> > p $ccccc
> > p $aaaaa
> > =end ignore
> 
> Ohhh! That makes sense, I think. I sometimes use that too!

Huum, so we need Comment-RD maybe.
But I think "###" is better than "ignore" for Comment-RD.
Ex.
=begin ###
.....
=end ###

What do you think?

> May I make another proposal? Do it as now, take all into consideration,
> but perhaps allow rd2html and family to do chose what to take into
> consideration.
> 
> Somthing with following syntax:
> 
> 	rd2xxx -use <kind>[,<kind>]... <file>
> 
> and
> 
> 	rd2xxx -usenot <kind>[,<kind>]... <file>
> 
> The first example would only take multiline comments into
> consideration, if they begin with any of `=begin <kind>'. All other
> comments would be ignored!
> 
> The second example would take all into consideration *except* all these
> ones, that begin with any of `=begin <kind>'.
> 
> For example:
> 
> 	rd2xxx -use rd MyScript.rb 
> 
> That would only takes multiline comments into consideration that begin
> with `=begin RD' or `=begin rd'.
> 
> 	rd2xxx -use rd,html MyScript.rb
> 
> would take only these into consideration that begins with 
> `=begin {rd|RD}' or `=begin {HTML|html}'.
> 
> Perhaps e.g. `rd2html' could set the `-use html' flag on any case, if
> another `-use' is used.
> 
> 	rd2xxx -usenot ...
> 
> Would works vice versa.
> 
> With this solution we also would have the following solved...
> 
> >>> Mr.Goto also suggested HTML-embeding like Perl. i.e. use following type of 
> >>> "=begin ... =end" to embed HTML (or Markup Language).
> >>>  =begin html
> >>>  <br>Figure 1.<br>
> >>>  =end html
> >>> It is suggested in [ruby-list:16162].
> >>
> >>Perhaps simply insert them into the corresponding result?
> > 
> > I think so. I just intended it like `#ifdef .. #end' without
> > `#else'. But I agree it causes to be too complicated and, probably,
> > makes difficult to read the document.
> 
> I don't think so. It would power up the tool, I think! I could write a
> large `.rd' document, that could be used to produce README, tutorial,
> reference and even an online helptext by putting it simply into
> different `=begin <kind>' sections! :-))))

I think, RD should be a format for man and not for formatter.
So man can read raw-RD (preformmated RD) easily. embeding HTML in RD
is on the assumption of existence of formmater script. So embeding
HTML ( or LaTeX or roff ) is not acceptable in RD.
I wish that RD will NOT become like POD.

For Example, if you use embeding-other-language in your RD document and
you want to support all of HTML, LaTeX and man, you have to write like 
this:

=begin html
Some HTML format text...
=end html
=begin latex
Some LaTeX format text...
=end latex
=begin man
Some man-roff format text...
=end man

Do you think it is enough simple?
I think,
when users of your script read your script and look such a document, 
they will think it is difficult even only to find Ruby script part 
in ".rb" script file. And a man who try to read raw-RD will take more
and more trouble.

I suggest altanative idea. we use "@input" instead of "=begin xxx" and
"=end xxx", like "@input filename". Document writer make "filename.html",
"filename.tex" and "filename.man". Formatter choose one of them with 
output format. For Example, rd2html choose "filename.html" and rd2latex
choose "filename.tex".
This feature is simple. So it will not make RD complicated.

Ex.
in RD file
=begin
= test
@input test
=end
---
in "test.html" file
<B>TEST</B>
---
in "test.latex" file
{\em TEST}
===
HTML format output
<HTML>
(...)
<BODY>
<H1>text</H1>
<B>TEST</B> <==
</BODY>
</HTML>
---
LaTeX format output
\documentclass{article}
(...)
\begin{document}
\section{test}
{\em TEST}      <==
\end{document}


> Don't forget, I could write the doc into a `.`rd' file, not necessarily
> into the script. Perhaps only a part of the doc would be contained into
> the script, neh? :-)

Yes. I know about this kind of use. I have heard that matz have wanted to 
write even his BOOK of Ruby with RD first. And I wrote Japanese document 
of RDtool into ".rd" file.

---
Tosh