Proposal for shorthand syntax¶

The goal of this RFC is to propose a re-done shorthand syntax for fluid after some real-world usage.

Current situation¶

Currently, we refer to "shorthand syntax" as another way to call a ViewHelper.

Here, there is a basic example for this:

{f:bla.blubb("unnamed argument" a="b" c="42" d="{object}")}

This is equivalent to the following:

<f:bla.blubb a="b" c="42" d="{object}">unnamed argument</f:bla.blubb>

• Every argument needs to be quoted
• The first argument is the data inside the tag body, in case it is unnamed.
• Nesting of ViewHelpers is arbitrarily possible:
  

  {f:outer(" first VH: {f:bla()} second VH: {f:blubb()}")}

  
  (also inside arguments of ViewHelpers, other VHs can be called)
• ViewHelpers can not be called inside arrays

Note: Right now, the shorthand syntax is functionally equivalent like the Tag-based ViewHelper syntax.

Problems with current syntax¶

In the most common use-case, we write things like

{f:bla(argument="{blubb}" argument2="{bla}")}

There, two things feel strange:

• The "{…}" syntax feels weird
• It feels strange that the argument needs to be quoted
• There is no comma between the arguments, which feels strange to programmers
• Named arguments in many languages are delimited by :, and not by =. The a="b" syntax feels strange.

Draft for new syntax¶

We remove the "Shorthand Syntax" as it has been described above, and instead extend the "Object Access" syntax.

The basic object access syntax looks like this:

{object} {object.bla.blubb}

Now, we start to post-process this value with a ViewHelper:

{object.bla->f:postProcess()}

This could also be chained

{object.bla->f:postProcess()->f:anotherPostProcess()}

Additionally, if the ViewHelper does NOT work on any object, the first part can be omitted:

{f:process()->f:postProcess()}

Arguments¶

Arguments look like this:

{f:bla.blubb(arg1: 'literal string', arg2: 42, arg3: object1.bla, arg4:{a1: "string"})}

• All arguments have a name
• The syntax is the same as in JSON arrays, just without the outer brackets
• All string arguments are NOT evaluated, but taken as literal strings.
• arg1 is a string (which will not be post-processed)
• arg2 is a number
• arg3 is an object accessor
• arg4 is an array

Comparison¶

The new syntax has the following limitations:

• There is no equivalent of the following: {f:process("bla")}, i.e. there is no {"bla"->f:process()} and I would not introduce it.
• Is is NOT possible anymore to use ViewHelpers as arguments in other shorthand ViewHelpers (but I think this is not a problem, as you could use the XML-based syntax where this works)
• It is currently NOT possible to call ViewHelpers in arrays (but this has not been possible before either)

Please discuss this with us in the TYPO3 5.0 General Mailing list on lists.typo3.org!