docs: create a table describing operator precedence and associativity

Author: josdejong

README.md

@@ -208,18 +208,20 @@ When using multiple operators, they will be evaluated according to their precede
 filter(.age >= 18 and .age <= 65)
 ```
 
-Note that some operators, like `and`, `or`, `+`, and `-`, support more than two values and are evaluated left-to-right (left associative), like `2 + 3 + 4` Others, like `^` and `==`, do not support more than two values. If needed, it is always possible to use parenthesis, like `(2 ^ 3) ^ 4`.
+Note that some operators, like `and`, `or`, `+`, and `-`, support more than two values and are evaluated left-to-right, like `2 + 3 + 4`. Others, like `^` and `==`, do not support more than two values. If needed, it is always possible to use parenthesis, like `(2 ^ 3) ^ 4`.
 
 The operators have the following precedence, from highest to lowest:
 
-- `|`
-- `^`
-- `*`, `/`, `%`
-- `+`, `-`
--  `>`, `>=`, `<`, `<=`, `in`, `not in`
-- `==`, `!=`
-- `and`
-- `or`
+| Precedence                  | Associativity | Operators                            |
+|-----------------------------|---------------|--------------------------------------|
+| 8: pipe                     | left-to-right | `\|`                                 |
+| 7: exponentiation           | n/a           | `^`                                  |
+| 6: multiplicative operators | left-to-right | `*`, `/`, `%`                        |
+| 5: additive operators       | left-to-right | `+`, `-`                             |
+| 4: relational operators     | n/a           | `>`, `>=`, `<`, `<=`, `in`, `not in` |
+| 3: equality operators       | n/a           | `==`, `!=`                           |
+| 2: and                      | left-to-right | `and`                                |
+| 1: or                       | left-to-right | `or`                                 |
 
 See section [Function reference](reference/functions.md) for a detailed overview of all available functions and operators.
 

reference/functions.md

@@ -1085,7 +1085,7 @@ jsonquery(data, 'filter(regex(.message, "like|awesome", "i"))')
 
 ## add (`+`)
 
-Add two or more values. The operator is left associative.
+Add two or more values. The operator evaluated left-to-right (left associative).
 
 ```text
 a + b
@@ -1111,7 +1111,7 @@ jsonquery(user, '(.firstName + " ") + .lastName')
 
 ## subtract (`-`)
 
-Subtract two or more values. The operator is left associative.
+Subtract two or more values. The operator evaluated left-to-right (left associative).
 
 ```text
 a - b
@@ -1130,7 +1130,7 @@ jsonquery(data, '.a - .b') // 4
 
 ## multiply (`*`)
 
-Multiply two or more values. The operator is left associative.
+Multiply two or more values. The operator evaluated left-to-right (left associative).
 
 ```text
 a * b
@@ -1149,7 +1149,7 @@ jsonquery(data, '.a * .b') // 12
 
 ## divide (`/`)
 
-Divide two or more values. The operator is left associative.
+Divide two or more values. The operator evaluated left-to-right (left associative).
 
 ```text
 a / b
@@ -1185,11 +1185,13 @@ jsonquery(data, '.a ^ .b') // 8
 
 ## mod (`%`)
 
-Calculate the remainder (the modulus) of `a` divided by `b`, like `a % b`. The modulus operator does not support more than two values, so if you need to calculate a chain of multiple modulus operators you'll have to use parenthesis, like `(a % b) % c`.
+Calculate the remainder (the modulus) of `a` divided by `b`, like `a % b`. Multiple values can be chained, in that case they are evaluated left-to-right (left associative).
 
 ```text
 a % b
+a % b % c % ...
 mod(a, b)
+mod(a, b, c, ...)
 ```
 
 Examples: