Using Macro Shorthand

For the most frequently-used macros and their parameters, some shorthand alternatives to the long form versions are available. These are particularly useful where space is tight in table cells. The shorthand demonstrated here will shorten your report templates and RMscript files. If you have ideas for more shorthand, please let us know via the Feedback button.

Shortening Macro Parameters

=>

The => symbol is converted to: storeAsHidden=

It is important NOT to have a space after this symbol.

For example, the following are equivalent:

[String: value=Zack, storeAsHidden=Name]

[String: value=Zack, =>Name]

You can use this in combination with other shorthand, so the following would be equivalent:

[Calculate: value={A}+{B}, storeAsHidden=C]

[=:{A}+{B}, =>C]

(You would need to define values A and B.)

Shortening Macros

Text substitution is performed very early in processing. This means that Report Macro Results will behave as if you had used the longhand version.

[:]

[String: value=AAA]can be shortened to:[:AAA]

For example, the following are equivalent:

[String: value=`{Person1} likes {Person2}`, storeAs=X]

[:`{Person1} likes {Person2}`, storeAs=X]

[=:]

The Calculate macro: [Calculate: value=BBB]can be shortened to:[=:BBB]

For example, the following are equivalent:

[Calculate: value=`{MyValue1}+{MyValue2}`, storeAs=Y]

[=:`{MyValue1}+{MyValue2}`, storeAs=Y]

[+:] and [-:]

The [Inc:] (increment) macro can also be shortened. For example, once you have set a value, for example, [:4,=>Z], then the following are equivalent and give an answer of 5:

[Inc: storeAsHidden=Z]

[+:,=>Z]

To decrement a variable, in longhand, you would use:
[Inc: by=-1, storeAsHidden=Z]

The equivalent shorthand is:

[-:,=>Z]

To increment a variable by more than one, in longhand, you would use:
[Inc: by=2, storeAsHidden=Z]

The equivalent shorthand is:

[+:2,=>Z]

[?:], [!?:], [!:], and [/?:]

The [If:], [ElseIf:], [Else:] and [EndIf:] macros can be replaced with [?:], [!?:], [!:], and [/?:] respectively, so:

[If: condition={A}>{B}]

Woo

[ElseIf: condition={B}>{C}]

Yay

[Else:]

Houpla

[EndIf:]

...can be shortened to:

[?:{A}>{B}]Woo[!?:{B}>{C}]Yay[!:]Houpla[/?:]

[.:]

The [Calculate:value=`jPath(t, 'property')`] can be replaced with [.:t.property], so:

[Calculate:value=`jPath(t, 'status.value')`]

...can be shortened to:

[.:t.status.value]

It can be used to directly address a JObject's properties as in these examples:

[=:`jObject('v', null, 'w', 'Some text', 'y', jObject('z', 1))`, =>zz]
[.:zz.y.z, storeAs=A]

[=:`jObject('v', null, 'w', 'Some text', 'status', jObject('value', 1))`, =>zzz]
[.:zzz.status.value, storeAs=B]

[f:]

The [Function.Call:name=function name] can be replaced with [f:function name], so:

[Function.Call:name=My Function]

...can be shortened to:

[f:MyFunction]

List assignment Shorthand

Frequently in report templates, results are assigned to lists, and then split back out into named variables. For example:

[String: value=1;2;3;4;5, storeAsHidden=AllValues]

[List.Item: value={AllValues}, index=0, storeAsHidden=A]

[List.Item: value={AllValues}, index=1, storeAsHidden=B]

[List.Item: value={AllValues}, index=2, storeAsHidden=C]

[List.Item: value={AllValues}, index=3, storeAsHidden=D]

[List.Item: value={AllValues}, index=4, storeAsHidden=E]

With the list assignment shorthand, you can assign output to multiple variables.

[String: value=1;2;3;4;5, storeAsHidden=A;B;C;D;E]

Combined with other shorthand, this becomes:

Using the [String:] macro shorthand:

[:1;2;3;4;5,=>A;B;C;D;E]

or, using the [Calculate:] macro shorthand

[=:`list(2-1, 2+0, 3, 4, 5)`, =>A;B;C;D;E]

Note that the number of values and the number of variable names must match. If only one variable name is provided, the results are not split out (as before) so list assignment will continue to work as expected.

Pre/post increment/decrement

It is possible to change variable values before or after a macro is processed. You can pre-increment, post-increment, pre-decrement and post-decrement variables in shorthand as this example shows:

// Store 5 in each of A, B, C and D

[:5;5;5;5,=>A;B;C;D]

// Pre-incrementing adds one BEFORE processing the macro. So, A starts off as 5, then ReportMagic adds 1, meaning the macro outputs 6 and A contains 6 after the macro has run:

[:{++A}]

// Post-incrementing adds one AFTER processing the macro. Here, the macro is run and outputs 5 but then increments B by 1 so B contains 6 after processing:

[:{B++}]

// Pre-decrementing will minus 1 BEFORE processing the macro. This example, outputs 4 and C will contain 4 after processing:

[:{--C}]

// Post-incrementing will minus 1 AFTER processing the macro. This example, outputs 5 and D will contain 4 after processing:

[:{D--}]

Using Macro Shorthand

Shortening Macro Parameters

=>

Shortening Macros

[:]

List assignment Shorthand

Pre/post increment/decrement

Search