Ideal tag syntax; what's your take on it?

Ignore backward compatibility for a moment. What would *you* prefer?
Or if you have no idea, what aspects of the current syntax bothers you
the most in every day work?


A bit of mussing from me (if you care)... The most modern form of
FreeMarker syntax is like this:

  [#assign x = 1]
  [#if something]...[/#if]
  [@myDirective]...[/@myDirective]
  [@myOtherDirective /]

Despite that the documentation doesn't push thins syntax at all, it
has become very popular. That tells something.

My personal(?) problem with the current situation is that while FTL
(FreeMarker Template Language) has lost a lot from its SGML-ishness
(HTML-isness) during its history, it kept some of the not-so-good
things from it. So I'm afraid we have ended up with a mix that's too
far from the ideal. Let's see:

How FTL is not SGML:

- For starters, the attribute syntax was never like in SGML or XML.
  This is the cause of the most frequent mistake, where people try to
  write <@foo x="${x}" /> instead of <@foo x=x />

- 2.3 introduced those odd prefixes, "#" and "@" (instead of using
  XML-ish name-space prefixes). I don't mind this in itself, not at
  all. It's just not SGML-ish.

- And now it doesn't even use <...>, but [...].

How FTL is still similar to SGML:

- You have to add a "/" to each empty-directive tag ([@foo /]), but
  you don't have to add anything if nested content follows
  ([@foo]...). Isn't that anti-intuitive and often inconvenient?
  Nothing but SGML has this strange upside-down logic (I think).

  Also, to complicate things... there are those who are more equal
  than others. For a built-in directive you can write something like
  [#assign x = 1] instead of [#assign x = 1 /], since FreeMarker knows
  if they can have nested content or not.

- You don't have to put comma between named arguments. In SGML you
  have to quote non-trivial attribute values, so it isn't an issue
  there, but I don't think any sane modern *programming* language
  would do this with named arguments. [@foo x = a + 1 y = b + 1] is
  just horrible. Luckily, you can write [@foo x = a + 1, y = b + 1] in
  FTL, but you don't have to. (As a side note, we also have
  ambiguities because of this: <@foo x = a! y = 2> will be parsed as
  <@foo x = a!(y == 2)>. Yeah, part of this is that FTL allows "="
  instead of "==". That was a mistake too...)

-- 
Best regards,
 Daniel Dekany


------------------------------------------------------------------------------
EditLive Enterprise is the world's most technically advanced content
authoring tool. Experience the power of Track Changes, Inline Image
Editing and ensure content is compliant with Accessibility Checking.
http://p.sf.net/sfu/ephox-dev2dev