Improvements to Operators guide (#8512)

Author: eksperimental

lib/elixir/pages/Operators.md

@@ -14,14 +14,15 @@ Operator
 `*` `/`                                                                                  | Left to right
 `+` `-`                                                                                  | Left to right
 `++` `--` `..` `<>`                                                                      | Right to left
+`^^^`                                                                                    | Left to right
 `in` `not in`                                                                            | Left to right
-`\|>` `<<<` `>>>` `~>>` `<<~` `~>` `<~` `<~>` `<\|>`                                     | Left to right
+`\|>` `<<<` `>>>` `<<~` `~>>` `<~` `~>` `<~>` `<\|>`                                     | Left to right
 `<` `>` `<=` `>=`                                                                        | Left to right
 `==` `!=` `=~` `===` `!==`                                                               | Left to right
 `&&` `&&&` `and`                                                                         | Left to right
 `\|\|` `\|\|\|` `or`                                                                     | Left to right
-`&`                                                                                      | Unary
 `=`                                                                                      | Right to left
+`&`                                                                                      | Unary
 `=>` (valid syntax only inside `%{}`)                                                    | Right to left
 `\|`                                                                                     | Right to left
 `::`                                                                                     | Right to left
@@ -36,12 +37,12 @@ Elixir provides the following built-in comparison operators:
   * [`===`](`Kernel.===/2`) - strict equality
   * [`!=`](`Kernel.!=/2`) - inequality
   * [`!==`](`Kernel.!==/2`) - strict inequality
-  * [`>`](`Kernel.>/2`) - greater than
   * [`<`](`Kernel.</2`) - less than
-  * [`>=`](`Kernel.>=/2`) - greater than or equal
+  * [`>`](`Kernel.>/2`) - greater than
   * [`<=`](`Kernel.<=/2`) - less than or equal
+  * [`>=`](`Kernel.>=/2`) - greater than or equal
 
-The only difference between [`==`](`Kernel.==/2`) and [`===`](`Kernel.===/2`) is that [`===`](`Kernel.===/2`) is stricter when it comes to comparing integers and floats:
+The only difference between [`==`](`Kernel.==/2`) and [`===`](`Kernel.===/2`) is that [`===`](`Kernel.===/2`) is strict when it comes to comparing integers and floats:
 
 ```elixir
 iex> 1 == 1.0
@@ -67,12 +68,12 @@ The reason we can compare different data types is pragmatism. Sorting algorithms
 number < atom < reference < function < port < pid < tuple < map < list < bitstring
 ```
 
-When comparing two numbers of different types (a number is either an integer or a float), a conversion to the type with greater precision will always occur, unless the comparison operator used is either `===` or `!==`. A float will be considered more precise than an integer, unless the float is greater/less than +/-9007199254740992.0, at which point all the significant figures of the float are to the left of the decimal point. This behavior exists so that the comparison of large numbers remains transitive.
+When comparing two numbers of different types (a number being either an integer or a float), a conversion to the type with greater precision will always occur, unless the comparison operator used is either [`===`](`===/2`) or [`!==`](`!==/2`). A float will be considered more precise than an integer, unless the float is greater/less than +/-9007199254740992.0 respectively, at which point all the significant figures of the float are to the left of the decimal point. This behavior exists so that the comparison of large numbers remains transitive.
 
 The collection types are compared using the following rules:
 
-* Tuples are compared by size then element by element.
-* Maps are compared by size then by keys in ascending term order then by values in key order. In the specific case of maps' key ordering, integers are always considered to be less than floats.
+* Tuples are compared by size, then element by element.
+* Maps are compared by size, then by keys in ascending term order, then by values in key order. In the specific case of maps' key ordering, integers are always considered to be less than floats.
 * Lists are compared element by element.
 * Bitstrings are compared byte by byte, incomplete bytes are compared bit by bit.
 
@@ -111,10 +112,10 @@ The following is a table of all the operators that Elixir is capable of parsing,
   * `&&&`
   * `<<<`
   * `>>>`
-  * `~>>`
   * `<<~`
-  * `~>`
+  * `~>>`
   * `<~`
+  * `~>`
   * `<~>`
   * `<|>`
   * `^^^`

lib/elixir/src/elixir_parser.yrl

@@ -49,6 +49,7 @@ Rootsymbol grammar.
 Expect 3.
 
 %% Changes in ops and precedence should be reflected on lib/elixir/lib/code/identifier.ex
+%% and lib/elixir/pages/Operators.md
 %% Note though the operator => in practice has lower precedence than all others,
 %% its entry in the table is only to support the %{user | foo => bar} syntax.
 Left       5 do.
@@ -65,7 +66,7 @@ Left     130 or_op_eol.       %% ||, |||, or
 Left     140 and_op_eol.      %% &&, &&&, and
 Left     150 comp_op_eol.     %% ==, !=, =~, ===, !==
 Left     160 rel_op_eol.      %% <, >, <=, >=
-Left     170 arrow_op_eol.    %% |>, <<<, >>>, ~>>, <<~, ~>, <~, <~>, <|>
+Left     170 arrow_op_eol.    %% |>, <<<, >>>, <<~, ~>>, <~, ~>, <~>, <|>
 Left     180 in_op_eol.       %% in, not in
 Left     190 three_op_eol.    %% ^^^
 Right    200 two_op_eol.      %% ++, --, .., <>