Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

docs: Clarify associativity of operators. #9170

Merged
merged 8 commits into from
Apr 6, 2024
Merged

docs: Clarify associativity of operators. #9170

Changes from 3 commits
Commits
Show all changes
8 commits
Select commit Hold shift + click to select a range
4639dfd
docs: Clarify associativity of operators.
elenakrittik Apr 1, 2024
dfe197b
misc: Add missing (?) comma.
elenakrittik Apr 1, 2024
4da643f
docs: Move associativity note to the top of the section.
elenakrittik Apr 1, 2024
82a8fe2
Add associativity table column.
elenakrittik Apr 4, 2024
8948e3f
Add missed associativity for `await`.
elenakrittik Apr 4, 2024
5d1fe64
Remove the table
elenakrittik Apr 4, 2024
63ddb01
Remove the table
elenakrittik Apr 4, 2024
897bff3
Remove the table
elenakrittik Apr 4, 2024
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
12 changes: 4 additions & 8 deletions tutorials/scripting/gdscript/gdscript_basics.rst
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -224,7 +224,9 @@ in case you want to take a look under the hood.
Operators
~~~~~~~~~

The following is the list of supported operators and their precedence.
The following is the list of supported operators and their precedence. All operators are `left-associative <https://en.wikipedia.org/wiki/Operator_associativity>`_,
Copy link
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Suggested change
The following is the list of supported operators and their precedence. All operators are `left-associative <https://en.wikipedia.org/wiki/Operator_associativity>`_,
The following is the list of supported operators and their precedence. All binary operators are `left-associative <https://en.wikipedia.org/wiki/Operator_associativity>`_,

Binary operators use a table (get_rule()), which does not provide the ability to specify associativity. Unary and ternary operators call parse_precedence() in place, so we need to check their associativity. It looks like the ternary operator is right-associative:

func test():
    1 if 2 else 3 if 4 else 5
    1 if 2 else (3 if 4 else 5)
    (1 if 2 else 3) if 4 else 5
Class <unnamed> :
|   Function test(  ) :
|   |   (1) IF (2) ELSE ((3) IF (4) ELSE (5))
|   |   (1) IF (2) ELSE ((3) IF (4) ELSE (5))
|   |   ((1) IF (2) ELSE (3)) IF (4) ELSE (5)

Copy link
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Found the sources:

Was able to confirm your observation about ternary operator, but i got really confused when i tried to determine associativity of unary operators. First of all, there is no code (or at least i think so) explicitly handling associativity, only precedence. But even then, it doesn't look like precedence is considered for unary operators because both -1 + 1 (lower precedence than unary -) and -1 ** 1 (higher precedence than -) are parsed the same ((-1) + 1 and (-1) ** 1 accordingly), so i'm not sure what exactly precedence does in this case. And in general, i struggle to understand what "associativity" even means in case of unary operators, because parsing them the way it's done right now is the only way that makes sense to me (-1 + 1 == -(1 + 1)? this would be unreasonable; neither it's possible to chain unary ops like binary ops). I'm absolutely lost on the theoretical part here 🤷

But anyway, back from crying into others' jackets. I tested all unary operators with two cases (<unary op> <expr> <binary op with higher precedence> <expr> and the same with lower precedence binary op) and in all cases it results in (<unary op> <expr>) <binary op> (<expr>), so from what i know this means all unary ops are left-associative as well?

Copy link
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

TLDR: I think we can just write that all binary operators in GDScript are left-associative, the ternary operator is right-associative, and leave out the unary operators.

Indeed, in the case of unary operations, the definition of associativity is not obvious. I see two approaches: 1. the binding strength between operators and operands, 2. the order of code execution.

Different operators have different binding strengths. If there are operators with equal precedence to the left and right of the operand, then the order is determined using associativity. The following options are possible:

Left Right
(... infix operand) infix ... ... infix (operand infix ...)
(... infix operand) postfix ... infix (operand postfix)
(prefix operand) infix ... prefix (operand infix ...)
(prefix operand) postfix prefix (operand postfix)

Some similar operators are grouped, have the same precedence and associativity: + and -, * and /. But unary operators are too different, so have different precedence. GDScript does not have prefix/postfix increment/decrement operators (++ and --), they would be a good example to illustrate. So we simply don't have a case where associativity is important for different unary operators.

And the same unary operator cannot appear on both the left and right (unlike infix binary operators): prefix operators are always located on the left, and postfix operators on the right. 1 + 2 + 3 is valid, but ~x~ is invalid.

If we consider associativity not as the binding strength, but as the order of code execution, then there are several nuances:

  1. Prefix operators can be considered right-associative (--x is -(-x)), and postfix operators left-associative (a[x][y] is (a[x])[y]).
  2. The ternary operator and the AND and OR operators do not always evaluate all of their operands (short-circuit). However, this does not affect the order.
  3. In some languages, the order of expression execution is not always guaranteed. The compiler can make optimizations such as move common subexpressions.

Finally, in some cases, operators can be non-associative, such as chain comparisons in Python.

including the ``**`` operator. This means that ``2 ** 2 ** 3`` is equal to ``(2 ** 2) ** 3``. Use parentheses to explicitly specify precedence you need, for
example ``2 ** (2 ** 3)``.

+---------------------------------------+-----------------------------------------------------------------------------+
| **Operator** | **Description** |
Expand All @@ -251,10 +253,6 @@ The following is the list of supported operators and their precedence.
| | |
| | Multiplies ``x`` by itself ``y`` times, similar to calling |
| | :ref:`pow() <class_@GlobalScope_method_pow>` function. |
| | |
| | **Note:** In GDScript, the ``**`` operator is |
| | `left-associative <https://en.wikipedia.org/wiki/Operator_associativity>`_. |
| | See a detailed note after the table. |
+---------------------------------------+-----------------------------------------------------------------------------+
| ``~x`` | Bitwise NOT |
+---------------------------------------+-----------------------------------------------------------------------------+
Expand Down Expand Up @@ -330,9 +328,7 @@ The following is the list of supported operators and their precedence.
3. For negative values, the ``%`` operator and ``fmod()`` use `truncation <https://en.wikipedia.org/wiki/Truncation>`_ instead of rounding towards negative infinity.
This means that the remainder has a sign. If you need the remainder in a mathematical sense, use the :ref:`posmod() <class_@GlobalScope_method_posmod>` and
:ref:`fposmod() <class_@GlobalScope_method_fposmod>` functions instead.
4. The ``**`` operator is `left-associative <https://en.wikipedia.org/wiki/Operator_associativity>`_. This means that ``2 ** 2 ** 3`` is equal to ``(2 ** 2) ** 3``.
Use parentheses to explicitly specify precedence you need, for example ``2 ** (2 ** 3)``.
5. The ``==`` and ``!=`` operators sometimes allow you to compare values of different types (for example, ``1 == 1.0`` is true), but in other cases it can cause
4. The ``==`` and ``!=`` operators sometimes allow you to compare values of different types (for example, ``1 == 1.0`` is true), but in other cases it can cause
a runtime error. If you're not sure about the types of the operands, you can safely use the :ref:`is_same() <class_@GlobalScope_method_is_same>` function
(but note that it is more strict about types and references). To compare floats, use the :ref:`is_equal_approx() <class_@GlobalScope_method_is_equal_approx>`
and :ref:`is_zero_approx() <class_@GlobalScope_method_is_zero_approx>` functions instead.
Expand Down