Recent changes to Operators

Operators modified by Bharath Gaddam

Bharath Gaddam — Sun, 16 Mar 2014 19:13:53 -0000

--- v30
+++ v31
@@ -5,11 +5,11 @@

 Below is a complete list of all operators and what they do.

-Operator | Type | Description | Orerridable | Sample | Result
+Operator | Type | Description | Overridable | Sample | Result
 ---------|------|-------------|-------------|--------|-------
-**[and](operators-and)** | Binary | Boolean AND operator | ✓ | true and false | false
-**[or](operators-or)** | Binary | Boolean OR operator | ✓ | true or false | true
-**[not](operators-not)** | Unary | Boolean NOT operator | ✓ | not false | true
+**[and](operators-and)** | Binary | Boolean AND operator | **✓** | true and false | false
+**[or](operators-or)** | Binary | Boolean OR operator | **✓** | true or false | true
+**[not](operators-not)** | Unary | Boolean NOT operator | **✓** | not false | true
 **[nand](operators-nand)** | Binary | Boolean NAND operator—shortcut for not (a or b) | | true nand false | true
 **[nor](operators-nor)** | Binary | Boolean NOR operator—shortcut for not (a and b) | | false nor true | false
 **[xor](operators-xor)** | Binary | Boolean XOR operator—shortcut for (a and not b) or (not a and b) | | false xor true | true
@@ -21,13 +21,13 @@
 **[bnor](operators-bnor)** | Binary | Bitwise NOR operator—shortcut for bnot (a band b)
 **[bxor](operators-bxor)** | Binary | Bitwise XOR operator—shortcut for (a band bnot b) bor (bnot a band b)
 **[bxnor](operators-bxnor)** | Binary | Bitwise XNOR operator—shortcut for bnot a band bnot b
-**[+](operators-addition)** | Binary | addition operator | ✓ | 3 + 5 | 8
-**[-](operators-minus)** | Binary | subtraction operator | ✓ | 3 - 5 | -2
-**[\*](operators-multiplication)** | Binary | multiplication operator | ✓ | 3 * 5 | 15
-**[/](operators-float-division)** | Binary | division operator | ✓ | 15 / 3 | 5
+**[+](operators-addition)** | Binary | addition operator | **✓** | 3 + 5 | 8
+**[-](operators-minus)** | Binary | subtraction operator |**✓** | 3 - 5 | -2
+**[\*](operators-multiplication)** | Binary | multiplication operator | **✓** | 3 * 5 | 15
+**[/](operators-float-division)** | Binary | division operator | **✓** | 15 / 3 | 5
 **[mod](operators-mod)** | Binary | modulus operator | | 5 mod 3 | 2
 **[div](operators-div)** | Binary | integer division operator | | 5 div 3 | 1
-**[^](operators-exponential)** | Binary | mathematical exponential operator | ✓ | 3 ^ 2 | 9
+**[^](operators-exponential)** | Binary | mathematical exponential operator | **✓** | 3 ^ 2 | 9
 **[&](operators-amp)** | Psuedo-unary | When this appears before the name of a procedure or property, returns a delegate instance to that procedure or property
 **[?](operators-can-be-null)** | Type modifier | Turns a primitive (not structs or enums) into one that can be null—Except for boolean, this may add at least one byte to the storage needed | | var ? int
 **[()](operators-paren)** | Inner-parameter | Parenthetical operator
@@ -44,15 +44,15 @@
 **[=](operators-equals)** | Binary | Assignment operator—copies the reference if this is a reference type—not valid for structs | | a = b
 **[=](operators-equals)** | Binary | Equality comparison operator—compares only the reference if this is a reference type—not valid for structs | | if a = b then
 **[](operators-inequality)** ( or ><) | Binary | Inequality comparison operator—compares only the reference if this is a reference type—not valid for structs | | if a  b then
-**[<=](operators-lt-equal)** (or =<) | Binary | Less than or equal comparison operator—Undefined by default for non-numeric types | ✓ | if a <= b then
-**[<](operators-lt)** | Binary | Less than comparison operator—Undefined by default for non-numeric types | ✓ | if a < b then
-**[>=](operators-gt-equal)** (or =>) | Binary | Greater than or equal comparison operator—Undefined by default for non-numeric types | ✓ | if a >= b then
-**[>](operators-gt)** | Binary | Greater than comparison operator—Undefined by default for non-numeric types | ✓ | if a > b then
+**[<=](operators-lt-equal)** (or =<) | Binary | Less than or equal comparison operator—Undefined by default for non-numeric types | **✓** | if a <= b then
+**[<](operators-lt)** | Binary | Less than comparison operator—Undefined by default for non-numeric types | **✓** | if a < b then
+**[>=](operators-gt-equal)** (or =>) | Binary | Greater than or equal comparison operator—Undefined by default for non-numeric types | **✓** | if a >= b then
+**[>](operators-gt)** | Binary | Greater than comparison operator—Undefined by default for non-numeric types | **✓** | if a > b then
 **[@](operators-at)** | Psuedo-binary | Base class selector | | base@ClassName
-**[++](operators-inc)** | Unary | Increment operator | ✓ | x ++
-**[++](operators-inc)** | Binary | Increment operator | ✓ | x ++ y
-**[--](operators-dec)** | Unary | Decrement operator | ✓ | x --
-**[--](operators-dec)** | Binary | Decrement operator | ✓ | x -- y
+**[++](operators-inc)** | Unary | Increment operator | **✓** | x ++
+**[++](operators-inc)** | Binary | Increment operator | **✓** | x ++ y
+**[--](operators-dec)** | Unary | Decrement operator | **✓** | x --
+**[--](operators-dec)** | Binary | Decrement operator | **✓** | x -- y

 Precedence
 ----------
@@ -65,13 +65,13 @@

 Chaining of comparison operators
 --------------------------------
-ASIL allows comparison operators to be chained as long as the resulting expression forms a range.  So 4 < a and a < 8 could be written as 4 < a < 8.  This is meant to be transparent to those overriding these operators.  Below are some samples of situations that can or can't be combined.
+ASIL allows comparison operators to be chained as long as the resulting expression forms a range.  So 4 < a and a < 8 could be written as 4 < a < 8.  This is meant to be transparent to those overriding these operators.  Below are some samples of situations that can or can’t be combined.

 ~~~~
 :::text
-a < b and b < c ' Not a range as there aren't any constants
-4 < b and c > 8 ' Not a range as the operators don't "point" in the same direction
-4 < b and b <= 8 ' Valid range as the operators agree so this could be "4 < b < 8"
+a < b and b < c ' Not a range as there aren’t any constants
+4 < b and c > 8 ' Not a range as the operators don’t “point” in the same direction
+4 < b and b <= 8 ' Valid range as the operators agree so this could be “4 < b < 8”
 ~~~~

 You can also chain equality operators as shown below.
@@ -83,13 +83,13 @@

 Multiple assignments in one statement
 -------------------------------------
-Something like a = b = c will attempt to set a and b to the value of c.  If you need to force "b = c" to be a comparison, use the syntax provided in the next section.
+Something like a = b = c will attempt to set a and b to the value of c.  If you need to force “b = c” to be a comparison, use the syntax provided in the next section.

 Forcing ASIL to interpret operators in a select manner
 ------------------------------------------------------
 If ASIL gives you the wrong operator, you can call it with something like *typename*.+ *parameterlist*.  The code below shows how to set a boolean to the result of a comparison.

-Note: The assignment operator can't be selected this way.  This is deliberate and prevents you from making assignments when you wanted a comparison.
+Note: The assignment operator can’t be selected this way.  This is deliberate and prevents you from making assignments when you wanted a comparison.

 ~~~~
 :::text
@@ -97,7 +97,7 @@
 var boolean b = int.= c%, d% ' correct
 ~~~~

-Some comparison operators can be referenced with either of two "names".  Those are listed in the table below.  The "*type*" part is a placeholder for the real type name.
+Some comparison operators can be referenced with either of two “names”.  Those are listed in the table below.  The “*type*” part is a placeholder for the real type name.

 Name 1 | Name 2
 -------|-------

Operators modified by Will Pittenger

Will Pittenger — Sun, 23 Feb 2014 12:14:22 -0000

--- v29
+++ v30
@@ -34,11 +34,11 @@
 **[||](operators-abs)** | Inner-parameter | Mathematical absolute value operator | | |-5| | 5
 **[\[\]](operators-brackets)** | Type modifier | Turns a type into an array of the type | | var int\[\] array = new int\[3\]
 **[\[\]](operators-brackets)** | Inner-parameter | Array indexer | | list\[5\]
-**[\[\]](operators-brackets)** | Inner-parameter | (when used with **[new](keyword-new)** allocates an array of size X | | new String\[5\]
+**[\[\]](operators-brackets)** | Inner-parameter | (When used with **[new](keyword-new)**) allocates an array of size X | | new String\[5\]
 **[{}](operators-braces)** | Type modifier | Turns a type into a set of that type | | var int{} v = new int{} 5, 3, 7, 9
-**[{}](operators-braces)** | Inner-parameter list | Used to write a set constant | | new int{} 3, 5, 6, 34
new int{SomeFixedSetInstance} 5, 3, 6, 34
+**[{}](operators-braces)** | Inner-parameter list | (When used with **[new](keyword-new)**) Used to write a set constant | | new int{} 3, 5, 6, 34
new int{SomeFixedSetInstance} 5, 3, 6, 34
 **[{}f](operators-bracesf)** | Type modifier | Turns a type into a fixed set | | var int{}f fixed = new int{}f 3, 5, 9, 34
-**[{}f](operators-bracesf)** | Inner-parameter list | Used to write a set constant that can't have other members—used to control what can be in normal sets | | new int{}f 3, 5, 6, 23
+**[{}f](operators-bracesf)** | Inner-parameter list | (When used with **[new](keyword-new)**) Used to write a set constant that can't have other members—used to control what can be in normal sets | | new int{}f 3, 5, 6, 23
 **[.](operators-member-access)** | Psuedo-binary | Used to access the members of a struct or class | | name.member
 **[,](operators-comma)** | Pseudo-binary | Used to delimit lists when no custom keyword has been specified
 **[=](operators-equals)** | Binary | Assignment operator—copies the reference if this is a reference type—not valid for structs | | a = b

Operators modified by Will Pittenger

Will Pittenger — Sun, 23 Feb 2014 12:12:23 -0000

--- v28
+++ v29
@@ -36,7 +36,7 @@
 **[\[\]](operators-brackets)** | Inner-parameter | Array indexer | | list\[5\]
 **[\[\]](operators-brackets)** | Inner-parameter | (when used with **[new](keyword-new)** allocates an array of size X | | new String\[5\]
 **[{}](operators-braces)** | Type modifier | Turns a type into a set of that type | | var int{} v = new int{} 5, 3, 7, 9
-**[{}](operators-braces)** | Inner-parameter list | Used to write a set constant | | new int{} 3, 5, 6, 34, new int{SomeFixedSetInstance} 5, 3, 6, 34
+**[{}](operators-braces)** | Inner-parameter list | Used to write a set constant | | new int{} 3, 5, 6, 34
new int{SomeFixedSetInstance} 5, 3, 6, 34
 **[{}f](operators-bracesf)** | Type modifier | Turns a type into a fixed set | | var int{}f fixed = new int{}f 3, 5, 9, 34
 **[{}f](operators-bracesf)** | Inner-parameter list | Used to write a set constant that can't have other members—used to control what can be in normal sets | | new int{}f 3, 5, 6, 23
 **[.](operators-member-access)** | Psuedo-binary | Used to access the members of a struct or class | | name.member

Operators modified by Will Pittenger

Will Pittenger — Sun, 23 Feb 2014 12:11:23 -0000

--- v27
+++ v28
@@ -35,7 +35,9 @@
 **[\[\]](operators-brackets)** | Type modifier | Turns a type into an array of the type | | var int\[\] array = new int\[3\]
 **[\[\]](operators-brackets)** | Inner-parameter | Array indexer | | list\[5\]
 **[\[\]](operators-brackets)** | Inner-parameter | (when used with **[new](keyword-new)** allocates an array of size X | | new String\[5\]
-**[{}](operators-braces)** | Inner-parameter list | Used to write a set constant | | new int{} 3, 5, 6, 34
+**[{}](operators-braces)** | Type modifier | Turns a type into a set of that type | | var int{} v = new int{} 5, 3, 7, 9
+**[{}](operators-braces)** | Inner-parameter list | Used to write a set constant | | new int{} 3, 5, 6, 34, new int{SomeFixedSetInstance} 5, 3, 6, 34
+**[{}f](operators-bracesf)** | Type modifier | Turns a type into a fixed set | | var int{}f fixed = new int{}f 3, 5, 9, 34
 **[{}f](operators-bracesf)** | Inner-parameter list | Used to write a set constant that can't have other members—used to control what can be in normal sets | | new int{}f 3, 5, 6, 23
 **[.](operators-member-access)** | Psuedo-binary | Used to access the members of a struct or class | | name.member
 **[,](operators-comma)** | Pseudo-binary | Used to delimit lists when no custom keyword has been specified

Operators modified by Will Pittenger

Will Pittenger — Sun, 23 Feb 2014 12:02:46 -0000

--- v26
+++ v27
@@ -35,8 +35,8 @@
 **[\[\]](operators-brackets)** | Type modifier | Turns a type into an array of the type | | var int\[\] array = new int\[3\]
 **[\[\]](operators-brackets)** | Inner-parameter | Array indexer | | list\[5\]
 **[\[\]](operators-brackets)** | Inner-parameter | (when used with **[new](keyword-new)** allocates an array of size X | | new String\[5\]
-**[{}](operators-braces)** | Inner-parameter list | Used to write a set constant | | {3, 5, 6, 34}
-**[o{}](operators-obraces)** | Inner-parameter list | Used to write a set constant that can't have other members—used to control what can be in normal sets | | o{3, 5, 6, 23}
+**[{}](operators-braces)** | Inner-parameter list | Used to write a set constant | | new int{} 3, 5, 6, 34
+**[{}f](operators-bracesf)** | Inner-parameter list | Used to write a set constant that can't have other members—used to control what can be in normal sets | | new int{}f 3, 5, 6, 23
 **[.](operators-member-access)** | Psuedo-binary | Used to access the members of a struct or class | | name.member
 **[,](operators-comma)** | Pseudo-binary | Used to delimit lists when no custom keyword has been specified
 **[=](operators-equals)** | Binary | Assignment operator—copies the reference if this is a reference type—not valid for structs | | a = b

Operators modified by Will Pittenger

Will Pittenger — Fri, 21 Feb 2014 10:59:16 -0000

--- v25
+++ v26
@@ -32,6 +32,7 @@
 **[?](operators-can-be-null)** | Type modifier | Turns a primitive (not structs or enums) into one that can be null—Except for boolean, this may add at least one byte to the storage needed | | var ? int
 **[()](operators-paren)** | Inner-parameter | Parenthetical operator
 **[||](operators-abs)** | Inner-parameter | Mathematical absolute value operator | | |-5| | 5
+**[\[\]](operators-brackets)** | Type modifier | Turns a type into an array of the type | | var int\[\] array = new int\[3\]
 **[\[\]](operators-brackets)** | Inner-parameter | Array indexer | | list\[5\]
 **[\[\]](operators-brackets)** | Inner-parameter | (when used with **[new](keyword-new)** allocates an array of size X | | new String\[5\]
 **[{}](operators-braces)** | Inner-parameter list | Used to write a set constant | | {3, 5, 6, 34}

Operators modified by Will Pittenger

Will Pittenger — Fri, 21 Feb 2014 10:05:36 -0000

--- v24
+++ v25
@@ -29,7 +29,7 @@
 **[div](operators-div)** | Binary | integer division operator | | 5 div 3 | 1
 **[^](operators-exponential)** | Binary | mathematical exponential operator | ✓ | 3 ^ 2 | 9
 **[&](operators-amp)** | Psuedo-unary | When this appears before the name of a procedure or property, returns a delegate instance to that procedure or property
-**[?](operators-can-be-null)** | Type modifier | Turns a primitive (not structs or enums) into one that can be null—Except for boolean, this will add at least one byte to the storage needed | | var ? int
+**[?](operators-can-be-null)** | Type modifier | Turns a primitive (not structs or enums) into one that can be null—Except for boolean, this may add at least one byte to the storage needed | | var ? int
 **[()](operators-paren)** | Inner-parameter | Parenthetical operator
 **[||](operators-abs)** | Inner-parameter | Mathematical absolute value operator | | |-5| | 5
 **[\[\]](operators-brackets)** | Inner-parameter | Array indexer | | list\[5\]

Operators modified by Will Pittenger

Will Pittenger — Fri, 21 Feb 2014 01:46:27 -0000

--- v23
+++ v24
@@ -45,7 +45,7 @@
 **[<](operators-lt)** | Binary | Less than comparison operator—Undefined by default for non-numeric types | ✓ | if a < b then
 **[>=](operators-gt-equal)** (or =>) | Binary | Greater than or equal comparison operator—Undefined by default for non-numeric types | ✓ | if a >= b then
 **[>](operators-gt)** | Binary | Greater than comparison operator—Undefined by default for non-numeric types | ✓ | if a > b then
-**[@](operators-at)** | Binary | Base class selector | | base@ClassName
+**[@](operators-at)** | Psuedo-binary | Base class selector | | base@ClassName
 **[++](operators-inc)** | Unary | Increment operator | ✓ | x ++
 **[++](operators-inc)** | Binary | Increment operator | ✓ | x ++ y
 **[--](operators-dec)** | Unary | Decrement operator | ✓ | x --

Operators modified by Will Pittenger

Will Pittenger — Fri, 21 Feb 2014 00:51:15 -0000

--- v22
+++ v23
@@ -5,51 +5,51 @@

 Below is a complete list of all operators and what they do.

-Operator | Description | Orerridable | Sample | Result
----------|-------------|-------------|--------|-------
-**[and](operators-and)** | Boolean AND operator | ✓ | true and false | false
-**[or](operators-or)** | Boolean OR operator | ✓ | true or false | true
-**[not](operators-not)** | Boolean NOT operator | ✓ | not false | true
-**[nand](operators-nand)** | Boolean NAND operator—shortcut for not (a or b) | | true nand false | true
-**[nor](operators-nor)** | Boolean NOR operator—shortcut for not (a and b) | | false nor true | false
-**[xor](operators-xor)** | Boolean XOR operator—shortcut for (a and not b) or (not a and b) | | false xor true | true
-**[xnor](operators-xnor)** | Boolean XNOR operator—shortcut for not a and not b | | false xnor true | false
-**[band](operators-band)** | Bitwise AND operator
-**[bor](operators-bor)** | Bitwise OR operator
-**[bnot](operators-bnot)** | Bitwise NOT operator
-**[bnand](operators-bnand)** | Bitwise NAND oeprator—shortcut for not(a bor b)
-**[bnor](operators-bnor)** | Bitwise NOR operator—shortcut for bnot (a band b)
-**[bxor](operators-bxor)** | Bitwise XOR operator—shortcut for (a band bnot b) bor (bnot a band b)
-**[bxnor](operators-bxnor)** | Bitwise XNOR operator—shortcut for bnot a band bnot b
-**[+](operators-addition)** | addition operator | ✓ | 3 + 5 | 8
-**[-](operators-minus)** | subtraction operator | ✓ | 3 - 5 | -2
-**[\*](operators-multiplication)** | multiplication operator | ✓ | 3 * 5 | 15
-**[/](operators-float-division)** | division operator | ✓ | 15 / 3 | 5
-**[mod](operators-mod)** | modulus operator | | 5 mod 3 | 2
-**[div](operators-div)** | integer division operator | | 5 div 3 | 1
-**[^](operators-exponential)** | mathematical exponential operator | ✓ | 3 ^ 2 | 9
-**[&](operators-amp)** | When this appears before the name of a procedure or property, returns a delegate instance to that procedure or property
-**[?](operators-can-be-null)** | Turns a primitive (not structs or enums) into one that can be null—Except for boolean, this will add at least one byte to the storage needed | | var ? int
-**[()](operators-paren)** | Parenthetical operator
-**[||](operators-abs)** | Mathematical absolute value operator | | |-5| | 5
-**[\[\]](operators-brackets)** | Array indexer | | list\[5\]
-**[\[\]](operators-brackets)** | (when used with **[new](keyword-new)** allocates an array of size X | | new String\[5\]
-**[{}](operators-braces)** | Used to write a set constant | | {3, 5, 6, 34}
-**[o{}](operators-obraces)** | Used to write a set constant that can't have other members—used to control what can be in normal sets | | o{3, 5, 6, 23}
-**[.](operators-member-access)** | Used to access the members of a struct or class | | name.member
-**[,](operators-comma)** | Used to delimit lists when no custom keyword has been specified
-**[=](operators-equals)** | Assignment operator—copies the reference if this is a reference type—not valid for structs | | a = b
-**[=](operators-equals)** | Equality comparison operator—compares only the reference if this is a reference type—not valid for structs | | if a = b then
-**[](operators-inequality)** ( or ><) | Inequality comparison operator—compares only the reference if this is a reference type—not valid for structs | | if a  b then
-**[<=](operators-lt-equal)** (or =<) | Less than or equal comparison operator—Undefined by default for non-numeric types | ✓ | if a <= b then
-**[<](operators-lt)** | Less than comparison operator—Undefined by default for non-numeric types | ✓ | if a < b then
-**[>=](operators-gt-equal)** (or =>) | Greater than or equal comparison operator—Undefined by default for non-numeric types | ✓ | if a >= b then
-**[>](operators-gt)** | Greater than comparison operator—Undefined by default for non-numeric types | ✓ | if a > b then
-**[@](operators-at)** | Base class selector | | base@ClassName
-**[++](operators-inc)** | Unary increment operator | ✓ | x ++
-**[++](operators-inc)** | Binary increment operator | ✓ | x ++ y
-**[--](operators-dec)** | Unary decrement operator | ✓ | x --
-**[--](operators-dec)** | Binary decrement operator | ✓ | x -- y
+Operator | Type | Description | Orerridable | Sample | Result
+---------|------|-------------|-------------|--------|-------
+**[and](operators-and)** | Binary | Boolean AND operator | ✓ | true and false | false
+**[or](operators-or)** | Binary | Boolean OR operator | ✓ | true or false | true
+**[not](operators-not)** | Unary | Boolean NOT operator | ✓ | not false | true
+**[nand](operators-nand)** | Binary | Boolean NAND operator—shortcut for not (a or b) | | true nand false | true
+**[nor](operators-nor)** | Binary | Boolean NOR operator—shortcut for not (a and b) | | false nor true | false
+**[xor](operators-xor)** | Binary | Boolean XOR operator—shortcut for (a and not b) or (not a and b) | | false xor true | true
+**[xnor](operators-xnor)** | Binary | Boolean XNOR operator—shortcut for not a and not b | | false xnor true | false
+**[band](operators-band)** | Binary | Bitwise AND operator
+**[bor](operators-bor)** | Binary | Bitwise OR operator
+**[bnot](operators-bnot)** | Unary | Bitwise NOT operator
+**[bnand](operators-bnand)** | Binary | Bitwise NAND oeprator—shortcut for not(a bor b)
+**[bnor](operators-bnor)** | Binary | Bitwise NOR operator—shortcut for bnot (a band b)
+**[bxor](operators-bxor)** | Binary | Bitwise XOR operator—shortcut for (a band bnot b) bor (bnot a band b)
+**[bxnor](operators-bxnor)** | Binary | Bitwise XNOR operator—shortcut for bnot a band bnot b
+**[+](operators-addition)** | Binary | addition operator | ✓ | 3 + 5 | 8
+**[-](operators-minus)** | Binary | subtraction operator | ✓ | 3 - 5 | -2
+**[\*](operators-multiplication)** | Binary | multiplication operator | ✓ | 3 * 5 | 15
+**[/](operators-float-division)** | Binary | division operator | ✓ | 15 / 3 | 5
+**[mod](operators-mod)** | Binary | modulus operator | | 5 mod 3 | 2
+**[div](operators-div)** | Binary | integer division operator | | 5 div 3 | 1
+**[^](operators-exponential)** | Binary | mathematical exponential operator | ✓ | 3 ^ 2 | 9
+**[&](operators-amp)** | Psuedo-unary | When this appears before the name of a procedure or property, returns a delegate instance to that procedure or property
+**[?](operators-can-be-null)** | Type modifier | Turns a primitive (not structs or enums) into one that can be null—Except for boolean, this will add at least one byte to the storage needed | | var ? int
+**[()](operators-paren)** | Inner-parameter | Parenthetical operator
+**[||](operators-abs)** | Inner-parameter | Mathematical absolute value operator | | |-5| | 5
+**[\[\]](operators-brackets)** | Inner-parameter | Array indexer | | list\[5\]
+**[\[\]](operators-brackets)** | Inner-parameter | (when used with **[new](keyword-new)** allocates an array of size X | | new String\[5\]
+**[{}](operators-braces)** | Inner-parameter list | Used to write a set constant | | {3, 5, 6, 34}
+**[o{}](operators-obraces)** | Inner-parameter list | Used to write a set constant that can't have other members—used to control what can be in normal sets | | o{3, 5, 6, 23}
+**[.](operators-member-access)** | Psuedo-binary | Used to access the members of a struct or class | | name.member
+**[,](operators-comma)** | Pseudo-binary | Used to delimit lists when no custom keyword has been specified
+**[=](operators-equals)** | Binary | Assignment operator—copies the reference if this is a reference type—not valid for structs | | a = b
+**[=](operators-equals)** | Binary | Equality comparison operator—compares only the reference if this is a reference type—not valid for structs | | if a = b then
+**[](operators-inequality)** ( or ><) | Binary | Inequality comparison operator—compares only the reference if this is a reference type—not valid for structs | | if a  b then
+**[<=](operators-lt-equal)** (or =<) | Binary | Less than or equal comparison operator—Undefined by default for non-numeric types | ✓ | if a <= b then
+**[<](operators-lt)** | Binary | Less than comparison operator—Undefined by default for non-numeric types | ✓ | if a < b then
+**[>=](operators-gt-equal)** (or =>) | Binary | Greater than or equal comparison operator—Undefined by default for non-numeric types | ✓ | if a >= b then
+**[>](operators-gt)** | Binary | Greater than comparison operator—Undefined by default for non-numeric types | ✓ | if a > b then
+**[@](operators-at)** | Binary | Base class selector | | base@ClassName
+**[++](operators-inc)** | Unary | Increment operator | ✓ | x ++
+**[++](operators-inc)** | Binary | Increment operator | ✓ | x ++ y
+**[--](operators-dec)** | Unary | Decrement operator | ✓ | x --
+**[--](operators-dec)** | Binary | Decrement operator | ✓ | x -- y

 Precedence
 ----------

Operators modified by Will Pittenger

Will Pittenger — Sun, 16 Feb 2014 10:35:10 -0000

--- v21
+++ v22
@@ -56,6 +56,7 @@
 This lists all operators in order of precedence, starting with the highest precedence operators:

 ~~~~
+:::text
 , o{} {} [] () and or xor xnor nand nor * / + - & = ++ --

 >< <= =< < >= => > band bor bxor bxnor bnand bnor not bnot @
 ~~~~

@@ -64,6 +65,7 @@
 ASIL allows comparison operators to be chained as long as the resulting expression forms a range.  So 4 < a and a < 8 could be written as 4 < a < 8.  This is meant to be transparent to those overriding these operators.  Below are some samples of situations that can or can't be combined.

 ~~~~
+:::text
 a < b and b < c ' Not a range as there aren't any constants
 4 < b and c > 8 ' Not a range as the operators don't "point" in the same direction
 4 < b and b <= 8 ' Valid range as the operators agree so this could be "4 < b < 8"
@@ -72,6 +74,7 @@
 You can also chain equality operators as shown below.

 ~~~~
+:::text
 (a = b = c) = (a = b and a = c) ' This will always be true
 ~~~~

@@ -86,6 +89,7 @@
 Note: The assignment operator can't be selected this way.  This is deliberate and prevents you from making assignments when you wanted a comparison.

 ~~~~
+:::text
 var boolean b = c% = d% ' wrong
 var boolean b = int.= c%, d% ' correct
 ~~~~