[ruby-core:98338] [Ruby master Feature#15921] R-assign (rightward-assignment) operator

Issue #15921 has been updated by osyo (manga osyo).


hi.
I have summarized the expected behavior and the actual behavior with right assignment.

see: https://gist.github.com/osyo-manga/ef1db68fcb62a6fce7dace0f655c0b17

I think there is another issue of priority, apart from the fact that `=>` is defined as Hash.
This is a problem even if the => symbol changes.

```ruby
# Example ambiguous call example
# assume `=>` is another symbol(`>>>`)
func 42 >>> value      # value = func(42)  or  func(value = 42)

func a, b >>> value    # value = func(a, b)  or  func(a, value = b)

a || b >>> value       # a || (value = b)  or  value = (a ||b)

cond ? a : b >>> value # cond ? a : (value = b)  or  value = (cond ? a : b)

func cond ? a : b >>> value   # value = func(cond ? a : b)  or  func(value = cond ? a : b)
```

I think it is necessary to clarify priorities first.

For example,

* `other operator` `method call` > `=` = `right assignment` > `,` `||` `&&` `other syntax(if, while...)`

```ruby
# method call takes precedence
func 42 >>> value      # value = func(42)

# method call takes precedence
func a, b >>> result   # value func(a, b)

# right assignment takes precedence
a || b >>> value       # a || (value = b)

# ?: operator takes precedence
cond ? a : b >>> result   # value = (cond ? a : b)

# method call and ?: operator takes precedence
func cond ? a : b >>> value   # value = func(cond ? a : b)

# right assignment takes precedence
for i in [1, 2, 3] >>> value; end  # for i in value = [1, 2, 3]; end

# right assignment takes precedence
42 >>> value if cond   # value = 42 if cond
```

Thank you :)


----------------------------------------
Feature #15921: R-assign (rightward-assignment) operator
https://bugs.ruby-lang.org/issues/15921#change-85605

* Author: nobu (Nobuyoshi Nakada)
* Status: Closed
* Priority: Normal
* Assignee: matz (Yukihiro Matsumoto)
----------------------------------------
From https://bugs.ruby-lang.org/issues/15799#change-78465, proposal of the rightward-assignment operator by `=>`.

```
$ ./ruby -v -e '(1..).lazy.map {|x| x*2} => x' -e 'p x.first(10)'
ruby 2.7.0dev (2019-06-12T06:32:32Z feature/rassgn-assoc c928f06b79) [x86_64-darwin18]
last_commit=Rightward-assign by ASSOC
[2, 4, 6, 8, 10, 12, 14, 16, 18, 20]
```

https://github.com/nobu/ruby/tree/feature/rassgn-assoc



-- 
https://bugs.ruby-lang.org/

Unsubscribe: <mailto:[e-mail]?subject=unsubscribe>
<http://lists.ruby-lang.org/cgi-bin/mailman/options/ruby-core>