[ruby-core:114272] [Ruby master Bug#19782] Ruby operators precedence inconsistency

Issue #19782 has been updated by hurricup (Alexandr Evstigneev).


sawa (Tsuyoshi Sawada) wrote in #note-1:
> In general, precedence comes into play when an expression is ambiguous. An expression is ambiguous when there is more than one (grammatical) parse. `(a && b) = c` is not a grammatical parse of `a && b = c`; only `a && (b = c)` is. Hence, this expression is not ambiguous, and precedence is irrelevant here.

I'm sorry, I don't understand. What do you mean by 'expression is ambiguous'? According to the definition (from wikipedia):
> In mathematics and computer programming, the order of operations (or operator precedence) is a collection of rules that reflect conventions about which procedures to perform first in order to evaluate a given mathematical expression.

According to rdoc I referred, assignment has lower precedence than HP logical ops, meaning that logical ops are done before assignments, which is not true. Would be nice to have a consistent precedence table with all 'but's. 



----------------------------------------
Bug #19782: Ruby operators precedence inconsistency
https://bugs.ruby-lang.org/issues/19782#change-103963

* Author: hurricup (Alexandr Evstigneev)
* Status: Rejected
* Priority: Normal
* Backport: 3.0: UNKNOWN, 3.1: UNKNOWN, 3.2: UNKNOWN
----------------------------------------
Unfortunately I could not find a good documentation regarding ruby operators precedence and associativity, but according to https://ruby-doc.org/3.2.2/syntax/precedence_rdoc.html
`&&` has higher precedence than assignment.
Meaning that
`a && b = c` would be treated as `(a && b) = c` which makes a little sense, but still.
But ruby 3.2.2 shows that it works as `a && (b = c)` (if I read it right):

```
def moo(a,b,c)
  if a && b = c

  end
end

puts RubyVM::InstructionSequence.of(method :moo).disasm
```

Gives me
```
== disasm: #<ISeq:moo@/home/hurricup/Projects/untitled/test.rb:1 (1,0)-(5,3)> (catch: false)
local table (size: 3, argc: 3 [opts: 0, rest: -1, post: 0, block: -1, kw: -1@-1, kwrest: -1])
[ 3] a@0<Arg>   [ 2] b@1<Arg>   [ 1] c@2<Arg>
0000 getlocal_WC_0                          a@0                       (   2)[LiCa]
0002 branchunless                           13
0004 getlocal_WC_0                          c@2
0006 dup
0007 setlocal_WC_0                          b@1
0009 branchunless                           13
0011 putnil
0012 leave                                                            (   5)[Re]
0013 putnil                                                           (   2)
0014 leave                                                            (   5)[Re]
```

For example, perl has well documentation and same rules regarding these two ops: https://perldoc.perl.org/perlop#Operator-Precedence-and-Associativity
And if you try:
```
use v5.38;

my($var1, $var2, $var3) = (1,2,3);

$var1 && $var2 = $var3;

say $var1, $var2, $var3;
```

You will get expected:
```
Can't modify logical and (&&) in scalar assignment at /home/hurricup/Projects/untitled/test.pl line 5, near "$var3;"
Execution of /home/hurricup/Projects/untitled/test.pl aborted due to compilation errors.
```


Could you please clarify this?
Also would be really nice to have documentation on how precedence work, including calls without parens, like `some.thing expr` which precedence is consumed by `expr` here?





-- 
https://bugs.ruby-lang.org/
 ______________________________________________
 ruby-core mailing list -- [e-mail]
 To unsubscribe send an email to [e-mail]
 ruby-core info -- https://ml.ruby-lang.org/mailman3/postorius/lists/ruby-core.ml.ruby-lang.org/