At sign (@) on right side of assignment - Revision history

SteveS at 16:55, 7 April 2026

2026-04-07T16:55:30Z

← Older revision		Revision as of 16:55, 7 April 2026
Line 64:		Line 64:
	<td><p class="code">%foo = %namedArrlis(@)</p>		<td><p class="code">%foo = %namedArrlis(@)</p>
	</td></tr>		</td></tr>

			<tr><td>Obtain a subset of an <var>ArrayList</var> of items whose score value is greater than or equal to 25:
			<td><p class="code">%this:_items = @:subsetNew(ge(score, 25))</p>

	<tr><td>Get next item in linked list of objects:</td>		<tr><td>Get next item in linked list of objects:</td>
Line 80:		Line 83:
	</table>		</table>

	=="@" may refer to variable, array/screen/image item, or ~~property~~==		=="@" may refer to variable, array/screen/image item, property, or ArrayList of objects ==

	When the <code>@</code> phrase is in the right hand side of an assignment,		When the <code>@</code> phrase is in the right hand side of an assignment,
Line 122:		Line 125:
	'<code>"]</code>').		'<code>"]</code>').
	</ul>		</ul>
	Those operations are performed once, ~~resuling~~ in an <var>XmlNode</var>. The		Those operations are performed once, resulting in an <var>XmlNode</var>. The
	<var>Value</var> property of that node is replaced with		<var>Value</var> property of that node is replaced with
	the string which is the concatenation the value of <code>%prefix</code> with the		the string which is the concatenation the value of <code>%prefix</code> with the

Dme at 20:46, 10 September 2013

2013-09-10T20:46:09Z

← Older revision		Revision as of 20:46, 10 September 2013
Line 148:		Line 148:
	is an example:		is an example:
	<p class="code">local function (string):getStateCode string len 2		<p class="code">local function (string):getStateCode string len 2
	%bal float		%bal is float
	%secretAccount is longstring common		%secretAccount is longstring common
	for 1 record where AcctNum = %this		for 1 record where AcctNum = %this
Line 161:		Line 161:
	end function		end function
	...		...
	%balancesByState namedArraylist of float auto new		%balancesByState is namedArraylist of float auto new
	%balancesByState:useDefault = true		%balancesByState:useDefault = true
	fr where ...		fr where ...

Dme: /* Left-hand side sub-expressions evaluate once, prior to right-hand side */

2013-09-10T20:44:08Z

Left-hand side sub-expressions evaluate once, prior to right-hand side

← Older revision		Revision as of 20:44, 10 September 2013
Line 110:		Line 110:
	<dl>		<dl>
	<dt>In the first assignment above:		<dt>In the first assignment above:
	<dd>The value 17 is added to the ~~Array~~ element		<dd>The value 17 is added to the array element
	(or <var>Arraylist</var> item) located at position <code>10+%y</code>.		(or <var>Arraylist</var> item) located at position <code>10+%y</code>.
	The expression <code>10+%y</code> is only evaluated once.		The expression <code>10+%y</code> is only evaluated once.

Dme: /* Left-hand side sub-expressions evaluate once, prior to right-hand side */

2013-09-10T20:43:40Z

Left-hand side sub-expressions evaluate once, prior to right-hand side

← Older revision		Revision as of 20:43, 10 September 2013
Line 104:		Line 104:
	Consider the following two example assignment statements:		Consider the following two example assignment statements:
	<p class="code">%x(10+%y) = @ + 17		<p class="code">%x(10+%y) = @ + 17

	%nLis(%i):~~SelectSingleNode~~('customer[@id="' ~~With~~ %cusId ~~With~~ '"]'):~~Value~~ = -		%nLis(%i):selectSingleNode('customer[@id="' with %cusId with '"]'):value = -
	%prefix ~~With~~ @ ~~With~~ %suffix		%prefix with @ with %suffix
	</p>		</p>
	<dl>		<dl>
	<dt>In the first assignment above:		<dt>In the first assignment above:
	<dd>The value 17 is added to the ~~array~~ element		<dd>The value 17 is added to the Array element
	(or <var>Arraylist</var> item) located at position <code>10+%y</code>.		(or <var>Arraylist</var> item) located at position <code>10+%y</code>.
	The expression <code>10+%y</code> is only evaluated once.		The expression <code>10+%y</code> is only evaluated once.
Line 149:		Line 149:
	<p class="code">local function (string):getStateCode string len 2		<p class="code">local function (string):getStateCode string len 2
	%bal float		%bal float
	%secretAccount ~~Longstring Common~~		%secretAccount is longstring common
	for 1 record where AcctNum = %this		for 1 record where AcctNum = %this
	for 1 record where AcctNum = %secretAccount		for 1 record where AcctNum = %secretAccount
	%bal = Balance + 100		%bal = Balance + 100
	change Balance To %bal		change Balance to %bal
	end for		end for
	%bal = Balance - 100		%bal = Balance - 100
	change Balance To %bal		change Balance to %bal
	return StateCode		return StateCode
	end for		end for
Line 169:		Line 169:
	end for		end for
	</p>		</p>

	=="@" is not a "self-delimiting" phrase except before or after a colon==		=="@" is not a "self-delimiting" phrase except before or after a colon==

Dme: /* "@" is not a "self-delimiting" phrase except before or after a colon */

2011-06-29T16:42:26Z

"@" is not a "self-delimiting" phrase except before or after a colon

← Older revision		Revision as of 16:42, 29 June 2011
Line 202:		Line 202:
	colon) self-delimiting;		colon) self-delimiting;
	for example, the following assigns to <code>%c</code>		for example, the following assigns to <code>%c</code>
	the concatenation of the string ~~value~~ variables <code>%c</code>		the concatenation of the string values of variables <code>%c</code>
	and <code>%b</code>:		and <code>%b</code>:
	<p class=code>%c=@ with %b</p>		<p class=code>%c=@ with %b</p>
Line 219:		Line 219:
	The above statement, in effect, removes the first 9 bytes of		The above statement, in effect, removes the first 9 bytes of
	the variable <code>%c</code>.		the variable <code>%c</code>.

	=="@" and the SetText statement==		=="@" and the SetText statement==

JAL2 at 15:10, 29 June 2011

2011-06-29T15:10:22Z

Show changes

Dme: Created page with " {{Template: New feature in 7.9 mods}} Some programming languages have operators which allow the right-hand side of an ..."

2011-05-23T14:01:22Z

Created page with " {{Template: New feature in 7.9 mods}} Some programming languages have operators which allow the right-hand side of an ..."

New page

{{Template: New feature in 7.9 mods}}
Some programming languages have operators
which allow the right-hand side of an assignment statement to reference
the left-hand side. In C, for example, <code>i += 2</code> is equivalent to <code>i = i + 2</code>.

A feature introduced in version 7.9 of the <var class="product">Sirius Mods</var>
allows a much more generalized approach to doing this.
In the right-hand side expression of an assignment statement,
the "at" sign (<code>@</code>) character refers to the left-hand side of the assignment.
For example:
%x = 4
%x = @:toPower(@)
print %x

This fragment produces <code>256</code>, that is, the same result that would
be obtained by substituting '<code>%x</code>', the left
side of the assignment, for '<code>@</code>' in '<code>%x = @:ToPower(@)</code>'.
This is the value of <code>%x</code> raised to that same power.

The <code>@</code> character is used in an expression on the right side of an
assignment statement wherever a "value" phrase may occur, e.g., a variable,
literal, method expression, $function, or sub-expression. The <code>@</code>
portion of the expression is called the "<code>@</code> phrase".

==Examples==

Some examples of the <code>@</code> phrase are:
<table>
<tr><td>Add 2 to a <var>Float</var> variable:
%x = @ + 2
</td></tr>

<tr><td>Raise a <var>Float</var> variable to its own power:
%x = @:toPower(@)
</td></tr>

<tr><td>Code with long variable names can become much more readable:
%numberOfCustomerInteractions = @ + 1
%totalTimeUsedForTransaction = @ + %time

<nowiki>* As opposed to:</nowiki>

%numberOfCustomerInteractions = %numberOfCustomerInteractions + 1
%totalTimeUsedForTransaction = %totalTimeUsedForTransaction + %time

</td></tr>

<tr><td>Concatenate to string:
%foo = @ with '.suffix'
</td></tr>

<tr><td>Concatenate to lowercased string:
%foo = 'prefix.' with @:toLower
</td></tr>

<tr><td>Get number plus next prime number:
%foo = @ + @:nextPrime
</td></tr>

<tr><td>Map variable using <var>NamedArraylist</var>:
%foo = %namedArrlis(@)
</td></tr>

<tr><td>Get next item in linked list of objects:
class list
public
variable next object list
...
end class
%item object list
...
%item = @:next

</td></tr>

</table>

=="@" may refer to variable, array/screen/image item, or property==

When the <code>@</code> phrase is in the right hand side of an assignment,
the left side of the assignment is something which could be used as an
expression. In terms of the operation (or semantics) of the <code>@</code>
phrase, there are two cases for the left side of the assignment:
<dl>
<dt>a variable, array item, screen item, or image item
<dd>In this case, when the <code>@</code> phrase is used on the right side,
it simply refers to the value of the left side.
<dt>a property
<dd>In this case, as the right side of the assignment is evaluated,
each instance of the <code>@</code> phrase will invoke
the "get" method of the property is invoked to obtain its value - and to
perform any other actions done by the "get" method
(note that the property may not be a write-only property).
</dl>

===Left-hand side sub-expressions evaluate once, prior to right-hand side===

If the left side of an assignment statement contains sub-expressions, these
are only evaluated once, prior to evaluating any of the right-hand side.
Consider the following two example assignment statements:
%x(10+%y) = @ + 17

%nLis(%i):SelectSingleNode('customer[@id="' With %cusId With '"]'):Value = -
%prefix With @ With %suffix

<dl>
<dt>In the first assignment above:
<dd>The value 17 is added to the array element
(or <var>Arraylist</var> item) located at position <code>10+%y</code>.
The expression <code>10+%y</code> is only evaluated once.
<dt>In the second assignment above:
<dd>
<ul>
<li>Item <code>%i</code> is obtained from the <var>XmlNodelist</var> <code>%nLis</code>.
<li>The resulting <var>XmlNode</var> is used as the context node to select
the first <var>XmlDoc</var> node matching the XPath expression which is the
concatenation of '<code>customer[@id="</code>' with the value of <code>%cusId</code> with
'<code>"]</code>'.
</ul>
Those operations are performed once, resuling in an <var>XmlNode</var>. The
<var>Value</var> property of that node is replaced with
the string which is the concatenation the value of <code>%prefix</code> with the
former value of <var>Value</var> property with the value of <code>%suffix</code>.
</dl>

The above examples which use "@", where the left-hand
sub-expressions are evaluated only once, is more efficient than
the equivalent
statements where the left-hand side is literally substituted for each
instance of <code>@</code> on the right-hand side,
and so those sub-expressions are evaluated multiple times.

However, in cases in which sub-expressions in the
left-hand side invoke some functions or properties
which have side-effects, it is important to note that since the sub-expressions
are only evaluated once, the result of such an assignment can be different from
a
statement in which the left-hand side is literally substituted for each
instance of <code>@</code> on the right-hand side. Also, there may be sub-expressions
on the right-hand side which have side-effects, which could change the result of
the sub-expressions of the left-hand side, were it substituted for <code>@</code>
phrases.

Programming practices which produce such side-effects are best avoided, but here
is an example:
local function (string):getStateCode string len 2
%bal float
%secretAccount Longstring Common
for 1 record where AcctNum = %this
for 1 record where AcctNum = %secretAccount
%bal = Balance + 100
change Balance To %bal
end for
%bal = Balance - 100
change Balance To %bal
return StateCode
end for
end function
...
%balancesByState namedArraylist of float auto new
%balancesByState:useDefault = true
fr where ...
* Notice that getStateCode is only evaluated once, so a dollar
* is only stolen once for each account processed:
%balancesByState(AcctNum:getStateCode) = @ + Balance
end for


=="@" is not a "self-delimiting" phrase except before/after colon==

In a <var class="product">User Language</var> expression, some characters
or character sequences
are "self-delimiting", that is, they may be adjacent to other "words"
in the expression without intervening whitespace. For example:
%x=%x*%y+%x/(%z-1)
In the expression on the right side of the above statement, no whitespace
is required around any of the following characters:
*
+
/
(
-
)

Other characters, for example a comma, or character sequences,
for example <code><=</code>, also do not require surrounding
whitespace when used in an expression.
However, for non-self-delimiting phrases, either a self-delimiting
character or character sequence or
whitespace is required to separate words in an expression.
For example, the following assigns to <code>%c</code>
the concatenation of the string values of variables <code>%a</code>
and <code>%b</code>:
%c=%a with %b
The following, however, is a syntax error, because the concatenation
operator (<code>with</code>) is not self-delimiting:
%c=%a with%b
Similarly, the <code>@</code> phrase is not (except when preceding a
colon) self-delimiting;
for example, the following assigns to <code>%c</code>
the concatenation of the string values variables <code>%c</code>
and <code>%b</code>:
%c=@ with %b
Each of the following, however, is a syntax error, because neither
<code>with</code> nor <code>@</code> is self-delimiting:
%c=@with %b
%c=%b with@


==="@" may appear immediately before and/or after colon===

The colon character (<code>:</code>) behaves, in most contexts, as
if it were a self-delimiting character, hence, no whitespace is
required between <code>:</code> and <code>@</code>. For example:
%c = @:substring(10)
The above statement, in effect, removes the first 9 bytes of
the variable <code>%c</code>.

=="@" and the SetText statement==

In the <var>[[Targeted Text statements|SetText]]</var> statement,
the <code>@</code> character can occur in the
right hand side, and, just as with the ordinary assignment statement,
<code>@</code> refers to the value of the left hand side of
the statement.
For example:
%s = 'Hello, world!'
SetText %s = {@} and its reverse {%s:Reverse}
Print %s

The result of the above fragment is
<code class="output">Hello, world! and its reverse !dlrow ,olleH</code>.

==Authorizing products==

The <code>@</code> phrase is available to any customer who owns any of the following products:
* ''Fast/Unload User Language Interface''
*'' Janus SOAP''
* ''Janus Sockets''
* ''Janus Web Server''
* ''Sirius Functions''

The '''Html''' block is also available if the Limited Janus Web Server capability is available.

[[Category:User Language syntax enhancements]]