[ruby-dev:43272] [Ruby 1.9 - Bug #4443] [Open] odd evaluation order in a multiple assignment

[ruby-dev:43272] [Ruby 1.9 - Bug #4443] [Open] odd evaluation order in a multiple assignment

[Yusuke Endoh]

Issue #4443 has been reported by Yusuke Endoh.

----------------------------------------
Bug #4443: odd evaluation order in a multiple assignment
http://redmine.ruby-lang.org/issues/4443

Author: Yusuke Endoh
Status: Open
Priority: Normal
Assignee: Yukihiro Matsumoto
Category: 
Target version: 2.0
ruby -v: ruby 1.9.2p0 (2010-08-18 revision 29036) [i686-linux]


遠藤です。core に投げてしまったようなので登録し直し。

Ruby は左から右に評価が進むと信じていたのですが、多重代入で裏切られました。

  def foo
    p :foo
    []
  end
  def bar
    p :bar
  end

  x, foo[0] = bar, 0

bar より foo が左にあるので、:foo 、:bar の順に出力されることを期待するのですが、なんと :bar 、:foo になります。

具体的に何が困るかというと、例えば

  obj, obj.foo = obj.foo, obj

には swap を期待するわけですが、そうなりません。こういうコードは実際に、木の回転などを実装するときにしばしば書きたくなります。この挙動に気がついたのも splay tree を実装していたときでした。こんなの:

  t.left, t.left.right, t = t.left.right, t, t.left

1.9 系列で修正すべきとまでは思いませんが、2.0 で直る可能性はあるでしょうか。

IRC で話したら「それで普通」みたいな反応もありましたが、

  foo[0] = bar

はちゃんと :foo 、:bar の順に出ます。

-- 
Yusuke Endoh <mame@tsg•ne.jp>


-- 
http://redmine.ruby-lang.org

[ruby-dev:43724] [Ruby 1.9 - Bug #4443] odd evaluation order in a multiple assignment

[Koichi Sasada]

Issue #4443 has been updated by Koichi Sasada.


まつもとさん，こちらいかがでしょうか．
直せと言われたら私なのかなぁ．
----------------------------------------
Bug #4443: odd evaluation order in a multiple assignment
http://redmine.ruby-lang.org/issues/4443

Author: Yusuke Endoh
Status: Assigned
Priority: Normal
Assignee: Yukihiro Matsumoto
Category: 
Target version: 2.0
ruby -v: ruby 1.9.2p0 (2010-08-18 revision 29036) [i686-linux]


=begin
遠藤です。core に投げてしまったようなので登録し直し。

Ruby は左から右に評価が進むと信じていたのですが、多重代入で裏切られました。

  def foo
    p :foo
    []
  end
  def bar
    p :bar
  end

  x, foo[0] = bar, 0

bar より foo が左にあるので、:foo 、:bar の順に出力されることを期待するのですが、なんと :bar 、:foo になります。

具体的に何が困るかというと、例えば

  obj, obj.foo = obj.foo, obj

には swap を期待するわけですが、そうなりません。こういうコードは実際に、木の回転などを実装するときにしばしば書きたくなります。この挙動に気がついたのも splay tree を実装していたときでした。こんなの:

  t.left, t.left.right, t = t.left.right, t, t.left

1.9 系列で修正すべきとまでは思いませんが、2.0 で直る可能性はあるでしょうか。

IRC で話したら「それで普通」みたいな反応もありましたが、

  foo[0] = bar

はちゃんと :foo 、:bar の順に出ます。

-- 
Yusuke Endoh <mame@tsg•ne.jp>
=end



-- 
http://redmine.ruby-lang.org

[ruby-dev:43727] [Ruby 1.9 - Bug #4443] odd evaluation order in a multiple assignment

[Yusuke Endoh]

Issue #4443 has been updated by Yusuke Endoh.


http://redmine.ruby-lang.org/issues/4440
に matz の返事があります。

> 優先順位は高くありませんが、直すべきだと思います。
>
> とはいうものの、1.8のころからこうだったのですし、直すのが難しいのも確
> かなのですが。

確か redmine の更新直後で、インターフェイスの違いにハマってチケット登録に失敗してしまったのでした。

-- 
Yusuke Endoh <mame@tsg•ne.jp>
----------------------------------------
Bug #4443: odd evaluation order in a multiple assignment
http://redmine.ruby-lang.org/issues/4443

Author: Yusuke Endoh
Status: Assigned
Priority: Normal
Assignee: Yukihiro Matsumoto
Category: 
Target version: 2.0
ruby -v: ruby 1.9.2p0 (2010-08-18 revision 29036) [i686-linux]


=begin
遠藤です。core に投げてしまったようなので登録し直し。

Ruby は左から右に評価が進むと信じていたのですが、多重代入で裏切られました。

  def foo
    p :foo
    []
  end
  def bar
    p :bar
  end

  x, foo[0] = bar, 0

bar より foo が左にあるので、:foo 、:bar の順に出力されることを期待するのですが、なんと :bar 、:foo になります。

具体的に何が困るかというと、例えば

  obj, obj.foo = obj.foo, obj

には swap を期待するわけですが、そうなりません。こういうコードは実際に、木の回転などを実装するときにしばしば書きたくなります。この挙動に気がついたのも splay tree を実装していたときでした。こんなの:

  t.left, t.left.right, t = t.left.right, t, t.left

1.9 系列で修正すべきとまでは思いませんが、2.0 で直る可能性はあるでしょうか。

IRC で話したら「それで普通」みたいな反応もありましたが、

  foo[0] = bar

はちゃんと :foo 、:bar の順に出ます。

-- 
Yusuke Endoh <mame@tsg•ne.jp>
=end



-- 
http://redmine.ruby-lang.org

[ruby-dev:43747] Re: [Ruby 1.9 - Bug #4443] odd evaluation order in a multiple assignment

[Yukihiro Matsumoto]

まつもと ゆきひろです

In message "Re: [ruby-dev:43724] [Ruby 1.9 - Bug #4443] odd evaluation order in a multiple assignment"
    on Sat, 11 Jun 2011 15:49:30 +0900, Koichi Sasada <redmine@ruby-lang.org> writes:

|まつもとさん，こちらいかがでしょうか．
|直せと言われたら私なのかなぁ．

すでに遠藤さんが指摘してくださいましたが、直せるものなら直し
たいと思ってます。

[ruby-dev:45502] [ruby-trunk - Bug #4443] odd evaluation order in a multiple assignment

[matz (Yukihiro Matsumoto)]

Issue #4443 has been updated by matz (Yukihiro Matsumoto).


Cから受け継いだ代入の評価順が「おかしい」のが原因である(本来は a → ｂ と表記すべきか)ことを考えると、
むしろ foo[0] = bar が :bar, :fooと動作するようにすべきでしょうか。

いや、単なる思いつきなのですが。

ちなみに今調べたら mruby は foo[0] = bar が :bar, :fooと動作しますね。

Matz.

----------------------------------------
Bug #4443: odd evaluation order in a multiple assignment
https://bugs.ruby-lang.org/issues/4443#change-25794

Author: mame (Yusuke Endoh)
Status: Assigned
Priority: Normal
Assignee: matz (Yukihiro Matsumoto)
Category: 
Target version: 
ruby -v: -


=begin
遠藤です。core に投げてしまったようなので登録し直し。

Ruby は左から右に評価が進むと信じていたのですが、多重代入で裏切られました。

  def foo
    p :foo
    []
  end
  def bar
    p :bar
  end

  x, foo[0] = bar, 0

bar より foo が左にあるので、:foo 、:bar の順に出力されることを期待するのですが、なんと :bar 、:foo になります。

具体的に何が困るかというと、例えば

  obj, obj.foo = obj.foo, obj

には swap を期待するわけですが、そうなりません。こういうコードは実際に、木の回転などを実装するときにしばしば書きたくなります。この挙動に気がついたのも splay tree を実装していたときでした。こんなの:

  t.left, t.left.right, t = t.left.right, t, t.left

1.9 系列で修正すべきとまでは思いませんが、2.0 で直る可能性はあるでしょうか。

IRC で話したら「それで普通」みたいな反応もありましたが、

  foo[0] = bar

はちゃんと :foo 、:bar の順に出ます。

-- 
Yusuke Endoh <mame@tsg•ne.jp>
=end



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

[ruby-dev:45503] [ruby-trunk - Bug #4443] odd evaluation order in a multiple assignment

[mame (Yusuke Endoh)]

Issue #4443 has been updated by mame (Yusuke Endoh).


まあ、それはそれでいいかなと思います。
ちなみに ISO とかの標準的にはどうなってるんでしょう？

-- 
Yusuke Endoh <mame@tsg•ne.jp>
----------------------------------------
Bug #4443: odd evaluation order in a multiple assignment
https://bugs.ruby-lang.org/issues/4443#change-25802

Author: mame (Yusuke Endoh)
Status: Assigned
Priority: Normal
Assignee: matz (Yukihiro Matsumoto)
Category: 
Target version: 
ruby -v: -


=begin
遠藤です。core に投げてしまったようなので登録し直し。

Ruby は左から右に評価が進むと信じていたのですが、多重代入で裏切られました。

  def foo
    p :foo
    []
  end
  def bar
    p :bar
  end

  x, foo[0] = bar, 0

bar より foo が左にあるので、:foo 、:bar の順に出力されることを期待するのですが、なんと :bar 、:foo になります。

具体的に何が困るかというと、例えば

  obj, obj.foo = obj.foo, obj

には swap を期待するわけですが、そうなりません。こういうコードは実際に、木の回転などを実装するときにしばしば書きたくなります。この挙動に気がついたのも splay tree を実装していたときでした。こんなの:

  t.left, t.left.right, t = t.left.right, t, t.left

1.9 系列で修正すべきとまでは思いませんが、2.0 で直る可能性はあるでしょうか。

IRC で話したら「それで普通」みたいな反応もありましたが、

  foo[0] = bar

はちゃんと :foo 、:bar の順に出ます。

-- 
Yusuke Endoh <mame@tsg•ne.jp>
=end



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

[ruby-dev:45586] [ruby-trunk - Bug #4443] odd evaluation order in a multiple assignment

[matz (Yukihiro Matsumoto)]

Issue #4443 has been updated by matz (Yukihiro Matsumoto).


手元にあるJIS x3017のドラフトを見ると現状の評価順(多重代入の場合には右辺が先)が記述してありますね(11.4.2.4)。
どうしたもんだか。
----------------------------------------
Bug #4443: odd evaluation order in a multiple assignment
https://bugs.ruby-lang.org/issues/4443#change-26244

Author: mame (Yusuke Endoh)
Status: Assigned
Priority: Normal
Assignee: matz (Yukihiro Matsumoto)
Category: 
Target version: 
ruby -v: -


=begin
遠藤です。core に投げてしまったようなので登録し直し。

Ruby は左から右に評価が進むと信じていたのですが、多重代入で裏切られました。

  def foo
    p :foo
    []
  end
  def bar
    p :bar
  end

  x, foo[0] = bar, 0

bar より foo が左にあるので、:foo 、:bar の順に出力されることを期待するのですが、なんと :bar 、:foo になります。

具体的に何が困るかというと、例えば

  obj, obj.foo = obj.foo, obj

には swap を期待するわけですが、そうなりません。こういうコードは実際に、木の回転などを実装するときにしばしば書きたくなります。この挙動に気がついたのも splay tree を実装していたときでした。こんなの:

  t.left, t.left.right, t = t.left.right, t, t.left

1.9 系列で修正すべきとまでは思いませんが、2.0 で直る可能性はあるでしょうか。

IRC で話したら「それで普通」みたいな反応もありましたが、

  foo[0] = bar

はちゃんと :foo 、:bar の順に出ます。

-- 
Yusuke Endoh <mame@tsg•ne.jp>
=end



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

[ruby-dev:45952] [ruby-trunk - Bug #4443] odd evaluation order in a multiple assignment

[ko1 (Koichi Sasada)]

Issue #4443 has been updated by ko1 (Koichi Sasada).

Assignee changed from matz (Yukihiro Matsumoto) to ko1 (Koichi Sasada)


----------------------------------------
Bug #4443: odd evaluation order in a multiple assignment
https://bugs.ruby-lang.org/issues/4443#change-28032

Author: mame (Yusuke Endoh)
Status: Assigned
Priority: Normal
Assignee: ko1 (Koichi Sasada)
Category: 
Target version: 
ruby -v: -


=begin
遠藤です。core に投げてしまったようなので登録し直し。

Ruby は左から右に評価が進むと信じていたのですが、多重代入で裏切られました。

  def foo
    p :foo
    []
  end
  def bar
    p :bar
  end

  x, foo[0] = bar, 0

bar より foo が左にあるので、:foo 、:bar の順に出力されることを期待するのですが、なんと :bar 、:foo になります。

具体的に何が困るかというと、例えば

  obj, obj.foo = obj.foo, obj

には swap を期待するわけですが、そうなりません。こういうコードは実際に、木の回転などを実装するときにしばしば書きたくなります。この挙動に気がついたのも splay tree を実装していたときでした。こんなの:

  t.left, t.left.right, t = t.left.right, t, t.left

1.9 系列で修正すべきとまでは思いませんが、2.0 で直る可能性はあるでしょうか。

IRC で話したら「それで普通」みたいな反応もありましたが、

  foo[0] = bar

はちゃんと :foo 、:bar の順に出ます。

-- 
Yusuke Endoh <mame@tsg•ne.jp>
=end



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

[ruby-dev:46272] [ruby-trunk - Bug #4443][Open] odd evaluation order in a multiple assignment

[nahi (Hiroshi Nakamura)]

Issue #4443 has been updated by nahi (Hiroshi Nakamura).

Status changed from Closed to Open

It looks to be closed by mistake.
----------------------------------------
Bug #4443: odd evaluation order in a multiple assignment
https://bugs.ruby-lang.org/issues/4443#change-31584

Author: mame (Yusuke Endoh)
Status: Open
Priority: Normal
Assignee: ko1 (Koichi Sasada)
Category: 
Target version: 
ruby -v: -


=begin
遠藤です。core に投げてしまったようなので登録し直し。

Ruby は左から右に評価が進むと信じていたのですが、多重代入で裏切られました。

  def foo
    p :foo
    []
  end
  def bar
    p :bar
  end

  x, foo[0] = bar, 0

bar より foo が左にあるので、:foo 、:bar の順に出力されることを期待するのですが、なんと :bar 、:foo になります。

具体的に何が困るかというと、例えば

  obj, obj.foo = obj.foo, obj

には swap を期待するわけですが、そうなりません。こういうコードは実際に、木の回転などを実装するときにしばしば書きたくなります。この挙動に気がついたのも splay tree を実装していたときでした。こんなの:

  t.left, t.left.right, t = t.left.right, t, t.left

1.9 系列で修正すべきとまでは思いませんが、2.0 で直る可能性はあるでしょうか。

IRC で話したら「それで普通」みたいな反応もありましたが、

  foo[0] = bar

はちゃんと :foo 、:bar の順に出ます。

-- 
Yusuke Endoh <mame@tsg•ne.jp>
=end



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

[ruby-dev:46315] [ruby-trunk - Bug #4443] odd evaluation order in a multiple assignment

[ko1 (Koichi Sasada)]

Issue #4443 has been updated by ko1 (Koichi Sasada).

Category set to core
Target version set to next minor

...これバグなんだっけ？　feature のような気もしますが．
2.0 には無理っぽいので，next minor にしておきます．
----------------------------------------
Bug #4443: odd evaluation order in a multiple assignment
https://bugs.ruby-lang.org/issues/4443#change-31953

Author: mame (Yusuke Endoh)
Status: Open
Priority: Normal
Assignee: ko1 (Koichi Sasada)
Category: core
Target version: next minor
ruby -v: -


=begin
遠藤です。core に投げてしまったようなので登録し直し。

Ruby は左から右に評価が進むと信じていたのですが、多重代入で裏切られました。

  def foo
    p :foo
    []
  end
  def bar
    p :bar
  end

  x, foo[0] = bar, 0

bar より foo が左にあるので、:foo 、:bar の順に出力されることを期待するのですが、なんと :bar 、:foo になります。

具体的に何が困るかというと、例えば

  obj, obj.foo = obj.foo, obj

には swap を期待するわけですが、そうなりません。こういうコードは実際に、木の回転などを実装するときにしばしば書きたくなります。この挙動に気がついたのも splay tree を実装していたときでした。こんなの:

  t.left, t.left.right, t = t.left.right, t, t.left

1.9 系列で修正すべきとまでは思いませんが、2.0 で直る可能性はあるでしょうか。

IRC で話したら「それで普通」みたいな反応もありましたが、

  foo[0] = bar

はちゃんと :foo 、:bar の順に出ます。

-- 
Yusuke Endoh <mame@tsg•ne.jp>
=end



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

[ruby-dev:49232] [Ruby trunk - Bug #4443] odd evaluation order in a multiple assignment

[ko1]

Issue #4443 has been updated by Koichi Sasada.

Description updated

----------------------------------------
Bug #4443: odd evaluation order in a multiple assignment
https://bugs.ruby-lang.org/issues/4443#change-53937

* Author: Yusuke Endoh
* Status: Open
* Priority: Normal
* Assignee: Koichi Sasada
* ruby -v: -
* Backport: 
----------------------------------------
遠藤です。core に投げてしまったようなので登録し直し。

Ruby は左から右に評価が進むと信じていたのですが、多重代入で裏切られました。

```ruby
  def foo
    p :foo
    []
  end
  def bar
    p :bar
  end

  x, foo[0] = bar, 0
```

bar より foo が左にあるので、:foo 、:bar の順に出力されることを期待するのですが、なんと :bar 、:foo になります。

具体的に何が困るかというと、例えば

```ruby
  obj, obj.foo = obj.foo, obj
```

には swap を期待するわけですが、そうなりません。こういうコードは実際に、木の回転などを実装するときにしばしば書きたくなります。この挙動に気がついたのも splay tree を実装していたときでした。こんなの:

```ruby
  t.left, t.left.right, t = t.left.right, t, t.left
```

1.9 系列で修正すべきとまでは思いませんが、2.0 で直る可能性はあるでしょうか。

IRC で話したら「それで普通」みたいな反応もありましたが、

```
  foo[0] = bar
```

はちゃんと :foo 、:bar の順に出ます。

-- 
Yusuke Endoh <mame@tsg•ne.jp>
=end




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

[ruby-dev:49970] [Ruby trunk Bug#4443] odd evaluation order in a multiple assignment

[ko1]

Issue #4443 has been updated by Koichi Sasada.

Description updated

今更ですが、考えます（いつだろう...）。

----------------------------------------
Bug #4443: odd evaluation order in a multiple assignment
https://bugs.ruby-lang.org/issues/4443#change-62767

* Author: Yusuke Endoh
* Status: Open
* Priority: Normal
* Assignee: Koichi Sasada
* Target version: 
* ruby -v: -
* Backport: 
----------------------------------------
遠藤です。core に投げてしまったようなので登録し直し。

Ruby は左から右に評価が進むと信じていたのですが、多重代入で裏切られました。

```ruby
  def foo
    p :foo
    []
  end
  def bar
    p :bar
  end

  x, foo[0] = bar, 0
```

bar より foo が左にあるので、:foo 、:bar の順に出力されることを期待するのですが、なんと :bar 、:foo になります。

具体的に何が困るかというと、例えば

```ruby
  obj, obj.foo = obj.foo, obj
```

には swap を期待するわけですが、そうなりません。こういうコードは実際に、木の回転などを実装するときにしばしば書きたくなります。この挙動に気がついたのも splay tree を実装していたときでした。こんなの:

```ruby
  t.left, t.left.right, t = t.left.right, t, t.left
```

1.9 系列で修正すべきとまでは思いませんが、2.0 で直る可能性はあるでしょうか。

IRC で話したら「それで普通」みたいな反応もありましたが、

```
  foo[0] = bar
```

はちゃんと :foo 、:bar の順に出ます。

-- 
Yusuke Endoh <mame@tsg•ne.jp>




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

[ruby-dev:50426] [Ruby trunk Bug#4443] odd evaluation order in a multiple assignment

[akr]

Issue #4443 has been updated by akr (Akira Tanaka).


関連すると思われるささださんの昔のメールを見つけました: ruby-dev:31579

```
1) 右辺が重複しないローカル変数の列だったら今まで通り
　（副作用はないので問題ない）
2) そうじゃなければ，色々コストをかけて順番通りに実行

ということにしたいと思います．多分，(1) がほとんどではないかと期待．
ネストした多重代入は (1) にはあてはまりませんが，まぁしょうがない．
```

----------------------------------------
Bug #4443: odd evaluation order in a multiple assignment
https://bugs.ruby-lang.org/issues/4443#change-69748

* Author: mame (Yusuke Endoh)
* Status: Assigned
* Priority: Normal
* Assignee: ko1 (Koichi Sasada)
* Target version: 
* ruby -v: -
* Backport: 
----------------------------------------
遠藤です。core に投げてしまったようなので登録し直し。

Ruby は左から右に評価が進むと信じていたのですが、多重代入で裏切られました。

```ruby
  def foo
    p :foo
    []
  end
  def bar
    p :bar
  end

  x, foo[0] = bar, 0
```

bar より foo が左にあるので、:foo 、:bar の順に出力されることを期待するのですが、なんと :bar 、:foo になります。

具体的に何が困るかというと、例えば

```ruby
  obj, obj.foo = obj.foo, obj
```

には swap を期待するわけですが、そうなりません。こういうコードは実際に、木の回転などを実装するときにしばしば書きたくなります。この挙動に気がついたのも splay tree を実装していたときでした。こんなの:

```ruby
  t.left, t.left.right, t = t.left.right, t, t.left
```

1.9 系列で修正すべきとまでは思いませんが、2.0 で直る可能性はあるでしょうか。

IRC で話したら「それで普通」みたいな反応もありましたが、

```
  foo[0] = bar
```

はちゃんと :foo 、:bar の順に出ます。

-- 
Yusuke Endoh <mame@tsg•ne.jp>




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