emacs-orgmode
[Top][All Lists]
Advanced

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

Re: [Orgmode] Re: Release 6.17


From: Rick Moynihan
Subject: Re: [Orgmode] Re: Release 6.17
Date: Mon, 05 Jan 2009 12:26:24 +0000
User-agent: Thunderbird 2.0.0.18 (Macintosh/20081105)

Carsten Dominik wrote:
On Jan 4, 2009, at 3:33 PM, Steven E. Harris wrote:

Carsten Dominik <address@hidden> writes:

Code references use special labels embedded directly into the source
code.  Such labels look like "((name))" and must be unique within a
document.
How does the parser know that, say, "((def))" is not a valid expression
in the surrounding Lisp forms? Is it important that it be separated by
space, or be the last token on the line?

Trying to concoct a motivating example, consider a structure represented
as nested lists:

,----
| '(a
|   ((b c) d)
|   (((e) f))    ((def))
|   g)
`----

Without knowing what the enclosing `quote' form means, how do know that
"((def))" is not part of it?

Hi Steven,

good question, and the answer is that is does not know,
cannot know, because this is a feature that is supposed
to work for any kind of example, an the parser cannot
know all possible syntaxes :-)

This idea is to make this work in a heuristic way, by using something
that is unlikely enough to occur in real code.

You are right that what I am using might be too
dangerous for emacs lisp or other lisp dialects, and
it could also show up in other languages like C.

What would be safer?

  <<name>>    like the other Org-mode targets?  That would make sense.
              Does anyone know a language where this would be used
              in real life?  It would make it harder to write about
              Org-mode, though.

Or do we need another option, so that, if needed, we could switch do
a different syntax?

Is a good work around not to simply supply the marker inside an inline comment, e.g.

,----
| '(a
|   ((b c) d)
|   (((e) f))   ;; ((def))
|   g)
`----

The advantage to this approach is that you can keep your code executable, which is really nice if you're writing documentation and want to be able to make sure the code always runs and is never broken. This solution seems to be more sensible than supporting different link markers etc... though the <<def>> does seem more consistent.

It might even be possible to link the ((def)) to the comment that describes it, so the links between code and comments are bidirectional.

Just some food for thought! :-)

R.





reply via email to

[Prev in Thread] Current Thread [Next in Thread]