https://bugs.ruby-lang.org/
https://bugs.ruby-lang.org/favicon.ico?1709775478
2010-06-16T19:11:36Z
Ruby Issue Tracking System
Ruby master - Feature #3447: argument delegation
https://bugs.ruby-lang.org/issues/3447?journal_id=11705
2010-06-16T19:11:36Z
matz (Yukihiro Matsumoto)
matz@ruby.or.jp
<ul></ul><p>まつもと ゆきひろです</p>
<p>In message "Re: <a href="/issues/3447">[ruby-dev:41623]</a> [Feature:trunk] argument delegation"<br>
on Wed, 16 Jun 2010 18:57:40 +0900, Nobuyoshi Nakada <a href="mailto:nobu@ruby-lang.org" class="email">nobu@ruby-lang.org</a> writes:</p>
<blockquote>
<p><a href="http://www.rubyist.net/~matz/20100615.html#p01" class="external">http://www.rubyist.net/~matz/20100615.html#p01</a> を実装してみました。</p>
</blockquote>
<p>手が早い。</p>
<blockquote>
<p>foo(...)でブロックまでコミ、foo(..)はブロック抜きにしてあります。</p>
</blockquote>
<p>foo(..)は不要だと思います。</p>
Ruby master - Feature #3447: argument delegation
https://bugs.ruby-lang.org/issues/3447?journal_id=11707
2010-06-17T03:37:11Z
mame (Yusuke Endoh)
mame@ruby-lang.org
<ul></ul><p>遠藤です。</p>
<p>2010年6月16日18:57 Nobuyoshi Nakada <a href="mailto:nobu@ruby-lang.org" class="email">nobu@ruby-lang.org</a>:</p>
<blockquote>
<p><a href="http://www.rubyist.net/~matz/20100615.html#p01" class="external">http://www.rubyist.net/~matz/20100615.html#p01</a> を実装してみました。</p>
</blockquote>
<p>argument delegation は、</p>
<ul>
<li>ブロックを引き継がせたいだけ (引数は変えたい) ときに不便</li>
<li>引数の変数へうっかり代入して、間違った引数が渡る事件が多発しそう</li>
<li>
<code>define_method</code> でサポートできていない (将来的にされる予定はある?)</li>
</ul>
<p>ので、あんまり好きじゃないです。</p>
<p>ブロックを引き継がせるのが面倒くさいという動機はとてもよくわかるので、</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="n">foo</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="n">b</span><span class="p">,</span> <span class="n">c</span><span class="p">,</span> <span class="o">&</span><span class="p">)</span>
</code></pre>
<p>と書いたらこのコンテキストのブロックを渡す、というのはどうでしょうか。</p>
<hr>
<p>Yusuke Endoh <a href="mailto:mame@tsg.ne.jp" class="email">mame@tsg.ne.jp</a></p>
Ruby master - Feature #3447: argument delegation
https://bugs.ruby-lang.org/issues/3447?journal_id=11714
2010-06-17T06:31:29Z
matz (Yukihiro Matsumoto)
matz@ruby.or.jp
<ul></ul><p>まつもと ゆきひろです</p>
<p>In message "Re: <a href="https://blade.ruby-lang.org/ruby-dev/41625">[ruby-dev:41625]</a> Re: [Feature:trunk] argument delegation"<br>
on Thu, 17 Jun 2010 03:36:56 +0900, Yusuke ENDOH <a href="mailto:mame@tsg.ne.jp" class="email">mame@tsg.ne.jp</a> writes:</p>
<blockquote>
<p>argument delegation は、</p>
<ol>
<li>ブロックを引き継がせたいだけ (引数は変えたい) ときに不便</li>
<li>引数の変数へうっかり代入して、間違った引数が渡る事件が多発しそう</li>
<li>
<code>define_method</code> でサポートできていない (将来的にされる予定はある?)</li>
</ol>
<p>ので、あんまり好きじゃないです。</p>
</blockquote>
<ol>
<li>
<p>については、ブロックを引き継がせたい時には、明示的にブロッ<br>
クを引き渡せばよい(ひとつのことをしたいときに、ひとつのこ<br>
とをすればよい。冗長性はない)ので、手当ての必要があるか<br>
どうか疑問です。今回の動機は「ひとつのことをするのに、ふ<br>
たつのことを書かないといけない」という冗長性ですから。</p>
</li>
<li>
<p>これは<code>super</code>でもそうですよね。昔、<code>super</code>は引数の変数に代入<br>
してもそのまま渡る仕様だったのですが、実装上の問題であき<br>
らめました。</p>
</li>
<li>
<p>将来的には、<code>define_method</code>でもサポートされるべきだと思いま<br>
す。できてないのは実装上の制約だと思ってください。</p>
</li>
</ol>
<blockquote>
<p>ブロックを引き継がせるのが面倒くさいという動機はとてもよくわかるので、</p>
<p>foo(a, b, c, &)</p>
<p>と書いたらこのコンテキストのブロックを渡す、というのはどうでしょうか。</p>
</blockquote>
<p>繰り返しになりますが、これでは「ひとつのことをするのに、ふた<br>
つのことを書かないといけない」という冗長性が解決できてません。<br>
実質追加は2文字だから負担は軽くなりますが。</p>
<p>が、もともとの動機とは別として、「<code>&</code>」1文字でそのコンテキスト<br>
のブロックを渡すのは、面白いアイディアだと思います。この場合<br>
は、仮引数リストのブロック引数がなくても、ブロックを渡すこと<br>
になるんですかね。</p>
<pre><code> まつもと ゆきひろ /:|)
</code></pre>
Ruby master - Feature #3447: argument delegation
https://bugs.ruby-lang.org/issues/3447?journal_id=11715
2010-06-17T10:45:24Z
ko1 (Koichi Sasada)
<ul></ul><p> ささだです.</p>
<p>(2010/06/17 6:31), Yukihiro Matsumoto wrote::</p>
<blockquote>
<blockquote>
<p>argument delegation は、</p>
<ol>
<li>ブロックを引き継がせたいだけ (引数は変えたい) ときに不便</li>
<li>引数の変数へうっかり代入して、間違った引数が渡る事件が多発しそう</li>
<li>define_method でサポートできていない (将来的にされる予定はある?)</li>
</ol>
<p>ので、あんまり好きじゃないです。</p>
</blockquote>
<ol>
<li>
<p>については、ブロックを引き継がせたい時には、明示的にブロッ<br>
クを引き渡せばよい(ひとつのことをしたいときに、ひとつのこ<br>
とをすればよい。冗長性はない)ので、手当ての必要があるか<br>
どうか疑問です。今回の動機は「ひとつのことをするのに、ふ<br>
たつのことを書かないといけない」という冗長性ですから。</p>
</li>
<li>
<p>これは<code>super</code>でもそうですよね。昔、<code>super</code>は引数の変数に代入<br>
してもそのまま渡る仕様だったのですが、実装上の問題であき<br>
らめました。</p>
</li>
<li>
<p>将来的には、<code>define_method</code>でもサポートされるべきだと思いま<br>
す。できてないのは実装上の制約だと思ってください。</p>
</li>
</ol>
</blockquote>
<p> 「実装上の制約」はそのとおりで,言語デザインとしてあるべきではないと思<br>
います.</p>
<p>(実装が簡単かどうかは別の話ですけど)</p>
<p> それは置いといて,これ,そんなに使うんでしょうか.あまり使わない機能<br>
に,新しい記号を入れるのは抵抗があります.とくに,<code>foo(...)</code> とか,擬似<br>
コードでよく使うので,抵抗があります.文脈でわかるっちゃわかるんですが.</p>
<p>利用例:<br>
<a href="http://rurema.clear-code.com/query:%28...%29/" class="external">http://rurema.clear-code.com/query:%28...%29/</a></p>
<p> 遠藤さんの</p>
<blockquote>
<blockquote>
<p>ブロックを引き継がせるのが面倒くさいという動機はとてもよくわかるので、</p>
<pre><code class="ruby syntaxhl" data-language="ruby"> <span class="n">foo</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="n">b</span><span class="p">,</span> <span class="n">c</span><span class="p">,</span> <span class="o">&</span><span class="p">)</span>
</code></pre>
<p>と書いたらこのコンテキストのブロックを渡す、というのはどうでしょうか。</p>
</blockquote>
</blockquote>
<p>の話は,ああ,あったら使うかも,と思いました.</p>
<hr>
<p>// SASADA Koichi at atdot dot net</p>
Ruby master - Feature #3447: argument delegation
https://bugs.ruby-lang.org/issues/3447?journal_id=11716
2010-06-17T11:09:18Z
matz (Yukihiro Matsumoto)
matz@ruby.or.jp
<ul></ul><p>まつもと ゆきひろです</p>
<p>In message "Re: <a href="https://blade.ruby-lang.org/ruby-dev/41629">[ruby-dev:41629]</a> Re: [Feature:trunk] argument delegation"<br>
on Thu, 17 Jun 2010 10:45:11 +0900, SASADA Koichi <a href="mailto:ko1@atdot.net" class="email">ko1@atdot.net</a> writes:<br>
<a href="https://bugs.ruby-lang.org/issues/3447#" class="external">https://bugs.ruby-lang.org/issues/3447#</a></p>
<blockquote>
<p> それは置いといて,これ,そんなに使うんでしょうか.あまり使わない機能<br>
に,新しい記号を入れるのは抵抗があります.とくに,foo(...) とか,擬似<br>
コードでよく使うので,抵抗があります.文脈でわかるっちゃわかるんですが.</p>
<p>利用例:<br>
<a href="http://rurema.clear-code.com/query:%28...%29/" class="external">http://rurema.clear-code.com/query:%28...%29/</a></p>
</blockquote>
<p>そんなに頻繁に使うかと言うと、そこまでではないと思います。が、<br>
全然ないわけではありませんし、繰り返しになりますが、「やりた<br>
いことに対する冗長性」から考えると手当てをした方がよいと思い<br>
ます。</p>
<p>しかし、「<code>...</code>」にそこまでこだわっているわけではありませんので、<br>
他の文法でも構いません。ただし、RやLuaでは同じ目的に「<code>...</code>」が<br>
使われていますから、そんなに悪い案でもないだろうと思ってます。</p>
Ruby master - Feature #3447: argument delegation
https://bugs.ruby-lang.org/issues/3447?journal_id=11717
2010-06-17T12:05:37Z
akr (Akira Tanaka)
akr@fsij.org
<ul></ul><p>2010年6月17日6:31 Yukihiro Matsumoto <a href="mailto:matz@ruby-lang.org" class="email">matz@ruby-lang.org</a>:</p>
<blockquote>
<blockquote>
<ol>
<li>ブロックを引き継がせたいだけ (引数は変えたい) ときに不便</li>
</ol>
</blockquote>
</blockquote>
<blockquote>
<ol>
<li>については、ブロックを引き継がせたい時には、明示的にブロッ<br>
クを引き渡せばよい(ひとつのことをしたいときに、ひとつのこ<br>
とをすればよい。冗長性はない)ので、手当ての必要があるか<br>
どうか疑問です。今回の動機は「ひとつのことをするのに、ふ<br>
たつのことを書かないといけない」という冗長性ですから。</li>
</ol>
</blockquote>
<p>今回の話にはなぜか触れられていないんですが、<br>
この機能の背景のひとつにはキーワード引数があるように思えます。</p>
<p>キーワード引数を加えたときに、キーワード引数が<br>
普通の引数でもブロック引数でもないものとすると、<br>
すべての引数を引き渡すのに 3つそれぞれについて引き渡さないといけません。</p>
<p>それを避けるためにキーワード引数を普通の引数の一部にするということにしたら、<br>
反論が出まくって仕様がまとまらなかった、というのが私の認識です。<br>
<a href="http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-talk/162431" class="external">ruby-talk:162431</a></p>
<p>それならすべての引数を引き渡すための機能をつける、というアイデアを<br>
<a href="http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-talk/162561" class="external">ruby-talk:162561</a> や <a href="http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-dev/30892" class="external">ruby-dev:30892</a> に書いたことがありますが、<br>
その時点では反応を得られませんでした。</p>
<p>そういう流れで今回のを見ると、あり得る方向だと思うわけですが、<br>
2つ懸念があります。</p>
<p>今は普通の引数とブロック引数のふたつしかないので、<br>
ひとつを変えるなら、残りはひとつしかありません。<br>
したがって、残りすべてを引き渡すのはひとつ書けば済みます。</p>
<p>しかし、キーワード引数が入るとみっつになるので、<br>
ひとつを変えるなら、残りはふたつになります。<br>
残りすべてを引き渡すのにふたつ書く必要が出てきます。<br>
おそらくこれはうれしくないでしょう。</p>
<p>つまり、argument delegation はキーワード引数を入れるときに困る問題を解決する<br>
かもしれないと思ったら、実際のところはあまり解決していない、というわけです。</p>
<blockquote>
<blockquote>
<ol start="3">
<li>define_method でサポートできていない (将来的にされる予定はある?)</li>
</ol>
</blockquote>
</blockquote>
<blockquote>
<ol start="3">
<li>将来的には、define_methodでもサポートされるべきだと思いま<br>
す。できてないのは実装上の制約だと思ってください。</li>
</ol>
</blockquote>
<p>もうひとつは <code>define_method</code> や <code>lambda</code> との関連です。</p>
<p><code>...</code> という構文には名前が入っていないので、</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="k">def</span> <span class="nf">f</span><span class="p">(</span><span class="n">a</span><span class="p">)</span>
<span class="nb">lambda</span> <span class="p">{</span><span class="o">|</span><span class="n">b</span><span class="o">|</span>
<span class="n">g</span><span class="p">(</span><span class="o">...</span><span class="p">)</span>
<span class="p">}</span>
<span class="k">end</span>
</code></pre>
<p>としたときに <code>...</code> はどの引数を指すのか不明です。</p>
<p>仕様としてどちらかに固定することはできるでしょうが、<br>
プログラマが選べるような構文にはなっていません。</p>
<p>そのうち、選べるようにする構文が要求されるようになるんじゃないでしょうか。</p>
<hr>
<p>[田中 哲][たなか あきら][Tanaka Akira]</p>
Ruby master - Feature #3447: argument delegation
https://bugs.ruby-lang.org/issues/3447?journal_id=11720
2010-06-17T13:59:10Z
shugo (Shugo Maeda)
<ul></ul><p>前田です。</p>
<p>argument delegationについてはまだ態度を決めかねているのですが、<br>
<code>super(...)</code>が導入されたら、(警告を出すなどの移行ステップを経て)<br>
括弧なし<code>super</code>は<code>super()</code>と同じ意味にしてしまってはどうでしょうか。</p>
<p>2010年6月17日6:31 Yukihiro Matsumoto <a href="mailto:matz@ruby-lang.org" class="email">matz@ruby-lang.org</a>:</p>
<blockquote>
<ol start="2">
<li>これは<code>super</code>でもそうですよね。昔、<code>super</code>は引数の変数に代入<br>
してもそのまま渡る仕様だったのですが、実装上の問題であき<br>
らめました。</li>
</ol>
</blockquote>
<p><code>super</code>ではブロック引数への代入が反映されない動作になっていますが、<br>
argument delegationではどうなりますか?</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="k">def</span> <span class="nf">foo</span><span class="p">(</span><span class="o">&</span><span class="n">b</span><span class="p">)</span>
<span class="n">b</span> <span class="o">=</span> <span class="nb">lambda</span> <span class="p">{</span> <span class="nb">puts</span> <span class="s2">"lambda in foo"</span> <span class="p">}</span>
<span class="n">bar</span><span class="p">(</span><span class="o">...</span><span class="p">)</span>
<span class="k">end</span>
</code></pre>
<p>というケースの話ですが。</p>
<hr>
<p>Shugo Maeda</p>
Ruby master - Feature #3447: argument delegation
https://bugs.ruby-lang.org/issues/3447?journal_id=11721
2010-06-17T14:53:51Z
matz (Yukihiro Matsumoto)
matz@ruby.or.jp
<ul></ul><p>まつもと ゆきひろです</p>
<p>In message "Re: <a href="https://blade.ruby-lang.org/ruby-dev/41634">[ruby-dev:41634]</a> Re: [Feature:trunk] argument delegation"<br>
on Thu, 17 Jun 2010 13:58:53 +0900, Shugo Maeda <a href="mailto:shugo@ruby-lang.org" class="email">shugo@ruby-lang.org</a> writes:</p>
<blockquote>
<p>argument delegationについてはまだ態度を決めかねているのですが、<br>
<code>super(...)</code>が導入されたら、(警告を出すなどの移行ステップを経て)<br>
括弧なし<code>super</code>は<code>super()</code>と同じ意味にしてしまってはどうでしょうか。</p>
</blockquote>
<p>うーん、<code>super</code>が<code>super()</code>の意味であってうれしいのは、</p>
<ul>
<li>ルールが少なくなる</li>
<li>無引数<code>super</code>の呼び出しが十分に多い</li>
</ul>
<p>のいずれかだと思うのですが、前者は結局はRubyの設計では優先度<br>
が低い「一貫性」を高めるということなので、この際「うれしい」<br>
とは評価しません。</p>
<p>後者ですが、これが実際的にうれしいのは</p>
<ul>
<li>
<code>super</code>を含むメソッドが引数を1個以上受け取り</li>
<li>
<code>super</code>にはひとつも渡さない</li>
</ul>
<p>というケースだけで、<code>super</code>の使い道のうち多くを含む(と思われる)</p>
<ul>
<li>
<code>super</code>を含むメソッドが引数を1個以上受け取り</li>
<li>
<code>super</code>にそのまま渡す</li>
</ul>
<p>場合、これまで<code>super</code>だけですんだものを<code>super(...)</code>と書かねばなら<br>
ず、ちっともうれしくありません。</p>
<ul>
<li>
<code>super</code>を含むメソッドが引数を1個以上受け取り</li>
<li>
<code>super</code>には別の引数を渡す</li>
</ul>
<p>場合、argment delegationは役に立たないのは事実ですが、それは<br>
<code>super</code>を<code>super()</code>にすることとは無関係でしょう。</p>
<blockquote>
<p><code>super</code>ではブロック引数への代入が反映されない動作になっていますが、<br>
argument delegationではどうなりますか?</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="k">def</span> <span class="nf">foo</span><span class="p">(</span><span class="o">&</span><span class="n">b</span><span class="p">)</span>
<span class="n">b</span> <span class="o">=</span> <span class="nb">lambda</span> <span class="p">{</span> <span class="nb">puts</span> <span class="s2">"lambda in foo"</span> <span class="p">}</span>
<span class="n">bar</span><span class="p">(</span><span class="o">...</span><span class="p">)</span>
<span class="k">end</span>
</code></pre>
<p>というケースの話ですが。</p>
</blockquote>
<p>「<code>super</code>と同じ動作」というのが基本だと思います。本当は、通常<br>
引数も代入が反映されないようにしたいのですが、YARVの実装だと<br>
難しいと聞いたような気がします。</p>
<pre><code> まつもと ゆきひろ /:|)
</code></pre>
Ruby master - Feature #3447: argument delegation
https://bugs.ruby-lang.org/issues/3447?journal_id=11722
2010-06-17T15:03:54Z
ko1 (Koichi Sasada)
<ul></ul><p>(2010/06/17 14:53), Yukihiro Matsumoto wrote::</p>
<blockquote>
<p>「<code>super</code>と同じ動作」というのが基本だと思います。本当は、通常<br>
引数も代入が反映されないようにしたいのですが、YARVの実装だと<br>
難しいと聞いたような気がします。</p>
</blockquote>
<p> 実装じゃなくてパフォーマンスを理由にお願いしました.引数領域のコピー<br>
を,スタックフレーム積むごとに行うのは嫌です(嫌なのは俺だけかも).</p>
<h1>
<code>zsuper</code> があったときだけ,というのも <code>eval</code> があるから結局ダメ.</h1>
<p> 意味的にも,個人的には 1.9 の仕様が好きなのですが.</p>
<hr>
<p>// SASADA Koichi at atdot dot net</p>
Ruby master - Feature #3447: argument delegation
https://bugs.ruby-lang.org/issues/3447?journal_id=11723
2010-06-17T15:15:40Z
matz (Yukihiro Matsumoto)
matz@ruby.or.jp
<ul></ul><p>まつもと ゆきひろです</p>
<p>In message "Re: <a href="https://blade.ruby-lang.org/ruby-dev/41631">[ruby-dev:41631]</a> Re: [Feature:trunk] argument delegation"<br>
on Thu, 17 Jun 2010 12:05:22 +0900, Tanaka Akira <a href="mailto:akr@fsij.org" class="email">akr@fsij.org</a> writes:</p>
<blockquote>
<p>そういう流れで今回のを見ると、あり得る方向だと思うわけですが、<br>
2つ懸念があります。</p>
<p>今は普通の引数とブロック引数のふたつしかないので、<br>
ひとつを変えるなら、残りはひとつしかありません。<br>
したがって、残りすべてを引き渡すのはひとつ書けば済みます。</p>
<p>しかし、キーワード引数が入るとみっつになるので、<br>
ひとつを変えるなら、残りはふたつになります。<br>
残りすべてを引き渡すのにふたつ書く必要が出てきます。<br>
おそらくこれはうれしくないでしょう。</p>
</blockquote>
<p>「ひとつを変える」という意味がいまいち読み取れなかったのです<br>
が、これはたとえば、「通常の引数の前にひとつ別の引数を加える」<br>
とか、「通常引数は同じだが、渡すブロックだけ変える」とかそう<br>
いう意味なんでしょうか。</p>
<p>だとすると、おっしゃることは理解できます。ただし、いまのとこ<br>
ろキーワード引数は通常の引数の一部として扱おうと思っているの<br>
で、あまり問題にはならないかもしれません。</p>
<blockquote>
<p>もうひとつは <code>define_method</code> や <code>lambda</code> との関連です。</p>
<p><code>...</code> という構文には名前が入っていないので、</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="k">def</span> <span class="nf">f</span><span class="p">(</span><span class="n">a</span><span class="p">)</span>
<span class="nb">lambda</span> <span class="p">{</span><span class="o">|</span><span class="n">b</span><span class="o">|</span>
<span class="n">g</span><span class="p">(</span><span class="o">...</span><span class="p">)</span>
<span class="p">}</span>
<span class="k">end</span>
</code></pre>
<p>としたときに ... はどの引数を指すのか不明です。</p>
</blockquote>
<p>確かに。ただし、「一番内側の引数」とか「<code>lambda</code>は無視、メソッ<br>
ドの引数」でもどちらでもあまり問題ないような気もします。とい<br>
うのも、この記法は、できないことをできるようにするものではな<br>
くて、めんどくさいものをより楽に表現しようというものですから、<br>
仕様の複雑化を避けてある程度で「あきらめる」というのは十分あ<br>
りえる判断だと思います。</p>
<blockquote>
<p>仕様としてどちらかに固定することはできるでしょうが、<br>
プログラマが選べるような構文にはなっていません。</p>
<p>そのうち、選べるようにする構文が要求されるようになるんじゃないでしょうか。</p>
</blockquote>
<p>そのような仕様のひとつの案としては、「<code>...</code>」そのものを式として<br>
しまって、その値を<a href="http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-talk/162561" class="external">ruby-talk:162561</a> で示されたようなオブジェ<br>
クトにする方法がありますね。その場合には「<code>**</code>」と「<code>**obj</code>」の方<br>
が良いかもしれませんが。</p>
<p>つまり、</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="k">def</span> <span class="nf">f</span><span class="p">(</span><span class="n">a</span><span class="p">)</span>
<span class="n">c</span> <span class="o">=</span> <span class="o">**</span>
<span class="nb">lambda</span> <span class="p">{</span><span class="o">|</span><span class="n">b</span><span class="o">|</span>
<span class="n">g</span><span class="p">(</span><span class="o">**</span><span class="n">c</span><span class="p">)</span> <span class="c1"># aを渡す</span>
<span class="p">}</span>
<span class="k">end</span>
<span class="k">def</span> <span class="nf">f</span><span class="p">(</span><span class="n">a</span><span class="p">)</span>
<span class="nb">lambda</span> <span class="p">{</span><span class="o">|</span><span class="n">b</span><span class="o">|</span>
<span class="n">g</span><span class="p">(</span><span class="o">**</span><span class="p">)</span> <span class="c1"># bを渡す</span>
<span class="p">}</span>
<span class="k">end</span>
</code></pre>
<p>ということですね。ただ、over specな印象があります。</p>
<pre><code> まつもと ゆきひろ /:|)
</code></pre>
Ruby master - Feature #3447: argument delegation
https://bugs.ruby-lang.org/issues/3447?journal_id=11724
2010-06-17T15:17:32Z
matz (Yukihiro Matsumoto)
matz@ruby.or.jp
<ul></ul><p>まつもと ゆきひろです</p>
<p>In message "Re: <a href="https://blade.ruby-lang.org/ruby-dev/41636">[ruby-dev:41636]</a> Re: [Feature:trunk] argument delegation"<br>
on Thu, 17 Jun 2010 15:03:33 +0900, SASADA Koichi <a href="mailto:ko1@atdot.net" class="email">ko1@atdot.net</a> writes:</p>
<blockquote>
<p> 実装じゃなくてパフォーマンスを理由にお願いしました.引数領域のコピー<br>
を,スタックフレーム積むごとに行うのは嫌です(嫌なのは俺だけかも).</p>
</blockquote>
<p>そういえばそうだったような。</p>
<blockquote>
<p> 意味的にも,個人的には 1.9 の仕様が好きなのですが.</p>
</blockquote>
<p>特に今のではダメと思ってるわけではないのですが(引数を書き換<br>
えるやつが悪い)、ただし、ささだくんがどうして「1.9 の仕様が<br>
好き」なのか、その理由には関心があります。</p>
<pre><code> まつもと ゆきひろ /:|)
</code></pre>
Ruby master - Feature #3447: argument delegation
https://bugs.ruby-lang.org/issues/3447?journal_id=11727
2010-06-17T15:42:56Z
ko1 (Koichi Sasada)
<ul></ul><p> ささだです.</p>
<p>(2010/06/17 15:17), Yukihiro Matsumoto wrote::</p>
<blockquote>
<blockquote>
<p> 意味的にも,個人的には 1.9 の仕様が好きなのですが.</p>
</blockquote>
<p>特に今のではダメと思ってるわけではないのですが(引数を書き換<br>
えるやつが悪い)、ただし、ささだくんがどうして「1.9 の仕様が<br>
好き」なのか、その理由には関心があります。</p>
</blockquote>
<p> 書き換える自由があるので,そっちのほうがいいかなぁ,と.</p>
<hr>
<p>// SASADA Koichi at atdot dot net</p>
Ruby master - Feature #3447: argument delegation
https://bugs.ruby-lang.org/issues/3447?journal_id=11728
2010-06-17T17:05:22Z
shugo (Shugo Maeda)
<ul></ul><p>前田です。</p>
<p>2010年6月17日14:53 Yukihiro Matsumoto <a href="mailto:matz@ruby-lang.org" class="email">matz@ruby-lang.org</a>:</p>
<blockquote>
<blockquote>
<p>argument delegationについてはまだ態度を決めかねているのですが、<br>
<code>super(...)</code>が導入されたら、(警告を出すなどの移行ステップを経て)<br>
括弧なし<code>super</code>は<code>super()</code>と同じ意味にしてしまってはどうでしょうか。</p>
</blockquote>
<p>うーん、<code>super</code>が<code>super()</code>の意味であってうれしいのは、</p>
<ul>
<li>ルールが少なくなる</li>
<li>無引数<code>super</code>の呼び出しが十分に多い</li>
</ul>
<p>のいずれかだと思うのですが、前者は結局はRubyの設計では優先度<br>
が低い「一貫性」を高めるということなので、この際「うれしい」<br>
とは評価しません。</p>
</blockquote>
<p>強いていえば前者ですが、ルールが少なくなることそのものがうれしい<br>
のではなくて、通常のメソッド呼出しだと<code>()</code>を付けなくてもよいのに、<br>
<code>super</code>のときだけ引数がないのに<code>()</code>を付けないといけないのが(見た目<br>
的に)気持ち悪い、という理由です。</p>
<blockquote>
<p>後者ですが、これが実際的にうれしいのは</p>
<ul>
<li>
<code>super</code>を含むメソッドが引数を1個以上受け取り</li>
<li>
<code>super</code>にはひとつも渡さない</li>
</ul>
<p>というケースだけで、</p>
</blockquote>
<p>私の経験では、<code>initialize</code>をオーバーライドするときに<code>super()</code>と書かないと<br>
いけなくて気持ち悪いと感じることが結構ありました。<br>
ちなみに標準添付ライブラリにおける<code>super</code>/<code>super()</code>の利用箇所を調べたところ</p>
<p><code>super</code>: 391箇所<br>
<code>super()</code>: 292箇所</p>
<p>という結果でした。意外といい勝負じゃないでしょうか。</p>
<blockquote>
<p><code>super</code>の使い道のうち多くを含む(と思われる)</p>
<ul>
<li>
<code>super</code>を含むメソッドが引数を1個以上受け取り</li>
<li>
<code>super</code>にそのまま渡す</li>
</ul>
<p>場合、これまで<code>super</code>だけですんだものを<code>super(...)</code>と書かねばなら<br>
ず、ちっともうれしくありません。</p>
</blockquote>
<p>5文字の節約が重要になるほどよく使う機能でもないと思うので、<br>
短い記述で済むことよりも、他の機能との類推で<code>super</code>の挙動を<br>
推測できることの方が利点が大きいように思います。</p>
<p>ただ、互換性の問題もある(既存のスクリプトは機械的に置換できる<br>
んじゃないかと思いますが)ので、それほど強くは主張しません。</p>
<blockquote>
<blockquote>
<p><code>super</code>ではブロック引数への代入が反映されない動作になっていますが、<br>
argument delegationではどうなりますか?</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="k">def</span> <span class="nf">foo</span><span class="p">(</span><span class="o">&</span><span class="n">b</span><span class="p">)</span>
<span class="n">b</span> <span class="o">=</span> <span class="nb">lambda</span> <span class="p">{</span> <span class="nb">puts</span> <span class="s2">"lambda in foo"</span> <span class="p">}</span>
<span class="n">bar</span><span class="p">(</span><span class="o">...</span><span class="p">)</span>
<span class="k">end</span>
</code></pre>
<p>というケースの話ですが。</p>
</blockquote>
<p>「<code>super</code>と同じ動作」というのが基本だと思います。本当は、通常<br>
引数も代入が反映されないようにしたいのですが、YARVの実装だと<br>
難しいと聞いたような気がします。</p>
</blockquote>
<p>性能上の理由ということで了解しました。<br>
# 個人的には、引数に代入するのは悪いスタイルだと思ってるので、どっちでも<br>
# いいんですけど。</p>
<hr>
<p>Shugo Maeda</p>
Ruby master - Feature #3447: argument delegation
https://bugs.ruby-lang.org/issues/3447?journal_id=11731
2010-06-17T19:06:35Z
matz (Yukihiro Matsumoto)
matz@ruby.or.jp
<ul></ul><p>まつもと ゆきひろです</p>
<p>In message "Re: <a href="https://blade.ruby-lang.org/ruby-dev/41641">[ruby-dev:41641]</a> Re: [Feature:trunk] argument delegation"<br>
on Thu, 17 Jun 2010 17:05:10 +0900, Shugo Maeda <a href="mailto:shugo@ruby-lang.org" class="email">shugo@ruby-lang.org</a> writes:</p>
<blockquote>
<p>私の経験では、<code>initialize</code>をオーバーライドするときに<code>super()</code>と書かないと<br>
いけなくて気持ち悪いと感じることが結構ありました。<br>
ちなみに標準添付ライブラリにおける<code>super</code>/<code>super()</code>の利用箇所を調べたところ</p>
<p><code>super</code>: 391箇所<br>
<code>super()</code>: 292箇所</p>
<p>という結果でした。意外といい勝負じゃないでしょうか。</p>
</blockquote>
<p>うーん、私が <code>lib/**/*.rb</code> で数えたら <code>super()</code>、つまり明示的に無<br>
引数で呼び出した<code>super</code>は66箇所しか見つかりませんでした。うち2<br>
箇所はメソッドに引数がないので<code>super</code>でも同じことです。逆に暗黙<br>
に引数を引き渡す<code>super</code>は243箇所です。少々の数えもれがあっても<br>
おかしくないですが、あまりにも違うので、もしかして数え方が違<br>
う?</p>
<blockquote>
<p>5文字の節約が重要になるほどよく使う機能でもないと思うので、<br>
短い記述で済むことよりも、他の機能との類推で<code>super</code>の挙動を<br>
推測できることの方が利点が大きいように思います。</p>
</blockquote>
<p>私、けっこう(引数転送の) <code>super</code> 使うんだけどな。</p>
<pre><code> まつもと ゆきひろ /:|)
</code></pre>
Ruby master - Feature #3447: argument delegation
https://bugs.ruby-lang.org/issues/3447?journal_id=11733
2010-06-17T22:29:32Z
mame (Yusuke Endoh)
mame@ruby-lang.org
<ul></ul><p>遠藤です。</p>
<p>2010年6月17日6:31 Yukihiro Matsumoto <a href="mailto:matz@ruby-lang.org" class="email">matz@ruby-lang.org</a>:</p>
<blockquote>
<blockquote>
<ol>
<li>ブロックを引き継がせたいだけ (引数は変えたい) ときに不便</li>
</ol>
</blockquote>
</blockquote>
<blockquote>
<ol>
<li>(略) 今回の動機は「ひとつのことをするのに、ふ<br>
たつのことを書かないといけない」という冗長性ですから。</li>
</ol>
</blockquote>
<p>なるほど。「通常の引数とブロック引数をまとめて delegate したい」<br>
と感じたことがあまりなかったので、動機を勘違いしていました。</p>
<p><code>lib/</code> を粗っぽく探してみたら、24 箇所ほど見つかりました (メールの<br>
最後に貼りつけてあります) 。それなりに需要はあるのかな。</p>
<blockquote>
<p>が、もともとの動機とは別として、「<code>&</code>」1文字でそのコンテキスト<br>
のブロックを渡すのは、面白いアイディアだと思います。この場合<br>
は、仮引数リストのブロック引数がなくても、ブロックを渡すこと<br>
になるんですかね。</p>
</blockquote>
<p>通常の引数は関係なく、ブロック引数を引き継がせたい事例なら、上と<br>
同じような検索で 183 箇所 (上の 24 箇所を含む) も見つかったので、<br>
<code>&</code> の省略記法は是非欲しくなってきました。</p>
<pre><code>$ ruby check.rb
lib/drb/drb.rb
1079: def method_missing(msg_id, *a, &b)
1083: return obj.__send__(msg_id, *a, &b)
lib/test/unit/assertions.rb
22: def assert_raise(*args, &b)
23: assert_raises(*args, &b)
lib/rake.rb
743: def create_rule(*args, &block)
744: Rake.application.create_rule(*args, &block)
lib/rake.rb
844:def task(*args, &block)
845: Rake::Task.define_task(*args, &block)
lib/rake.rb
862:def file(*args, &block)
863: Rake::FileTask.define_task(*args, &block)
lib/rake.rb
868:def file_create(args, &block)
869: Rake::FileCreationTask.define_task(args, &block)
lib/rake.rb
892:def multitask(args, &block)
893: Rake::MultiTask.define_task(args, &block)
lib/rake.rb
918:def rule(*args, &block)
919: Rake::Task.create_rule(*args, &block)
lib/scanf.rb
607: def scanf(str,&b)
608: return block_scanf(str,&b) if b
lib/scanf.rb
687: def scanf(fstr,&b)
689: block_scanf(fstr,&b)
lib/scanf.rb
716: def scanf(fs,&b)
717: STDIN.scanf(fs,&b)
lib/rubygems/user_interaction.rb
62: def use_ui(new_ui, &block)
63: Gem::DefaultUserInteraction.use_ui(new_ui, &block)
lib/optparse.rb
832: def accept(*args, &blk) top.accept(*args, &blk) end
836: def self.accept(*args, &blk) top.accept(*args, &blk) end
lib/optparse.rb
1202: def on(*opts, &block)
1203: define(*opts, &block)
lib/optparse.rb
1216: def on_head(*opts, &block)
1217: define_head(*opts, &block)
lib/optparse.rb
1230: def on_tail(*opts, &block)
1231: define_tail(*opts, &block)
lib/optparse.rb
1425: def visit(id, *args, &block)
1427: el.send(id, *args, &block)
lib/csv.rb
2308:def CSV(*args, &block)
2309: CSV.instance(*args, &block)
lib/erb.rb
334: def percent_line(line, &block)
336: return @scan_line.call(line, &block)
lib/erb.rb
334: def percent_line(line, &block)
341: @scan_line.call(line, &block)
lib/matrix.rb
1457: def map2(v, &block) # :yield: e1, e2
1459: els = collect2(v, &block)
lib/set.rb
613: def initialize(*args, &block) # :nodoc:
615: initialize(*args, &block)
lib/delegate.rb
141: def method_missing(m, *args, &block)
144: target.respond_to?(m) ? target.__send__(m, *args, &block) :
super(m, *args, &block)
lib/open-uri.rb
27: def open(name, *rest, &block) # :doc:
35: open_uri_original_open(name, *rest, &block)
count: 24
</code></pre>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="err">$</span> <span class="n">cat</span> <span class="n">check</span><span class="p">.</span><span class="nf">rb</span>
<span class="n">count</span> <span class="o">=</span> <span class="mi">0</span>
<span class="no">Dir</span><span class="p">.</span><span class="nf">glob</span><span class="p">(</span><span class="s2">"lib/**/*.rb"</span><span class="p">).</span><span class="nf">each</span> <span class="k">do</span> <span class="o">|</span><span class="n">path</span><span class="o">|</span>
<span class="k">next</span> <span class="k">unless</span> <span class="no">File</span><span class="p">.</span><span class="nf">file?</span><span class="p">(</span><span class="n">path</span><span class="p">)</span>
<span class="nb">open</span><span class="p">(</span><span class="n">path</span><span class="p">)</span> <span class="k">do</span> <span class="o">|</span><span class="n">file</span><span class="o">|</span>
<span class="k">while</span> <span class="n">line</span> <span class="o">=</span> <span class="n">file</span><span class="p">.</span><span class="nf">gets</span>
<span class="k">if</span> <span class="n">line</span> <span class="o">=~</span> <span class="sr">/^(\s*)def\s+[\d\w]+(\(.*,.*&.*\))/</span> <span class="c1"># 両方引き継がせる事例</span>
<span class="c1">#if line =~ /^(\s*)def\s+[\d\w]+\(.*(&.*\))/ # ブロック引数を引き継がせる事例</span>
<span class="n">sig</span> <span class="o">=</span> <span class="n">line</span>
<span class="n">lineno</span> <span class="o">=</span> <span class="n">file</span><span class="p">.</span><span class="nf">lineno</span>
<span class="n">re1</span> <span class="o">=</span> <span class="sr">/^\s{</span><span class="si">#{</span> <span class="vg">$1</span><span class="p">.</span><span class="nf">size</span> <span class="si">}</span><span class="sr">}end/</span>
<span class="n">re2</span> <span class="o">=</span> <span class="no">Regexp</span><span class="p">.</span><span class="nf">new</span><span class="p">(</span><span class="no">Regexp</span><span class="p">.</span><span class="nf">quote</span><span class="p">(</span><span class="vg">$2</span><span class="p">))</span>
<span class="k">while</span> <span class="n">line</span> <span class="o">=</span> <span class="n">file</span><span class="p">.</span><span class="nf">gets</span>
<span class="k">break</span> <span class="k">if</span> <span class="n">re1</span> <span class="o">=~</span> <span class="n">line</span>
<span class="k">if</span> <span class="n">re2</span> <span class="o">=~</span> <span class="n">line</span>
<span class="nb">puts</span> <span class="n">path</span>
<span class="nb">puts</span> <span class="s2">"</span><span class="si">#{</span> <span class="n">lineno</span> <span class="si">}</span><span class="s2">:</span><span class="si">#{</span> <span class="n">sig</span> <span class="si">}</span><span class="s2">"</span>
<span class="nb">puts</span> <span class="s2">"</span><span class="si">#{</span> <span class="n">file</span><span class="p">.</span><span class="nf">lineno</span> <span class="si">}</span><span class="s2">:</span><span class="si">#{</span> <span class="n">line</span> <span class="si">}</span><span class="s2">"</span>
<span class="nb">puts</span>
<span class="n">count</span> <span class="o">+=</span> <span class="mi">1</span>
<span class="k">end</span>
<span class="k">end</span>
<span class="k">end</span>
<span class="k">end</span>
<span class="k">end</span>
<span class="k">end</span>
<span class="nb">puts</span> <span class="s2">"count: </span><span class="si">#{</span> <span class="n">count</span> <span class="si">}</span><span class="s2">"</span>
</code></pre>
<hr>
<p>Yusuke Endoh <a href="mailto:mame@tsg.ne.jp" class="email">mame@tsg.ne.jp</a></p>
Ruby master - Feature #3447: argument delegation
https://bugs.ruby-lang.org/issues/3447?journal_id=11745
2010-06-18T05:43:59Z
matz (Yukihiro Matsumoto)
matz@ruby.or.jp
<ul></ul><p>まつもと ゆきひろです</p>
<p>In message "Re: <a href="https://blade.ruby-lang.org/ruby-dev/41644">[ruby-dev:41644]</a> Re: [Feature:trunk] argument delegation"<br>
on Thu, 17 Jun 2010 22:29:19 +0900, Yusuke ENDOH <a href="mailto:mame@tsg.ne.jp" class="email">mame@tsg.ne.jp</a> writes:</p>
<blockquote>
<p>通常の引数は関係なく、ブロック引数を引き継がせたい事例なら、上と<br>
同じような検索で 183 箇所 (上の 24 箇所を含む) も見つかったので、<br>
<code>&</code> の省略記法は是非欲しくなってきました。</p>
</blockquote>
<p>これは良いアイディアだと思います。もしかすると元のアイディア<br>
よりも。</p>
Ruby master - Feature #3447: argument delegation
https://bugs.ruby-lang.org/issues/3447?journal_id=11746
2010-06-18T08:34:48Z
shugo (Shugo Maeda)
<ul></ul><p>前田です。</p>
<p>2010年6月17日19:06 Yukihiro Matsumoto <a href="mailto:matz@ruby-lang.org" class="email">matz@ruby-lang.org</a>:</p>
<blockquote>
<blockquote>
<p>私の経験では、<code>initialize</code>をオーバーライドするときに<code>super()</code>と書かないと<br>
いけなくて気持ち悪いと感じることが結構ありました。<br>
ちなみに標準添付ライブラリにおける<code>super</code>/<code>super()</code>の利用箇所を調べたところ</p>
<p><code>super</code>: 391箇所<br>
<code>super()</code>: 292箇所</p>
<p>という結果でした。意外といい勝負じゃないでしょうか。</p>
</blockquote>
<p>うーん、私が <code>lib/**/*.rb</code> で数えたら <code>super()</code>、つまり明示的に無<br>
引数で呼び出した<code>super</code>は66箇所しか見つかりませんでした。うち2<br>
箇所はメソッドに引数がないので<code>super</code>でも同じことです。逆に暗黙<br>
に引数を引き渡す<code>super</code>は243箇所です。少々の数えもれがあっても<br>
おかしくないですが、あまりにも違うので、もしかして数え方が違<br>
う?</p>
</blockquote>
<p><code>~/src/ruby/**/*.rb</code>でやってました。<br>
で、多いのはTkみたいでした…。</p>
<blockquote>
<blockquote>
<p>5文字の節約が重要になるほどよく使う機能でもないと思うので、<br>
短い記述で済むことよりも、他の機能との類推で<code>super</code>の挙動を<br>
推測できることの方が利点が大きいように思います。</p>
</blockquote>
<p>私、けっこう(引数転送の) <code>super</code> 使うんだけどな。</p>
</blockquote>
<p>まあ、自分も結構使ってるかもしれませんが、うれしかったことは<br>
すぐに忘れて、不満に思ったことだけ覚えているということかも<br>
しれません。</p>
<hr>
<p>Shugo Maeda</p>
Ruby master - Feature #3447: argument delegation
https://bugs.ruby-lang.org/issues/3447?journal_id=12974
2010-08-25T00:30:42Z
mame (Yusuke Endoh)
mame@ruby-lang.org
<ul></ul><p>遠藤です。</p>
<p>2010年6月17日6:31 Yukihiro Matsumoto <a href="mailto:matz@ruby-lang.org" class="email">matz@ruby-lang.org</a>:</p>
<blockquote>
<p>が、もともとの動機とは別として、「<code>&</code>」1文字でそのコンテキスト<br>
のブロックを渡すのは、面白いアイディアだと思います。この場合<br>
は、仮引数リストのブロック引数がなくても、ブロックを渡すこと<br>
になるんですかね。</p>
</blockquote>
<p>パッチを書いてみました。思ったより小さく書けました。</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="k">def</span> <span class="nf">foo</span>
<span class="k">yield</span>
<span class="k">end</span>
<span class="k">def</span> <span class="nf">bar</span>
<span class="n">foo</span><span class="p">(</span><span class="o">&</span><span class="p">)</span>
<span class="k">end</span>
<span class="n">bar</span> <span class="p">{</span> <span class="nb">p</span> <span class="mi">1</span> <span class="p">}</span> <span class="c1">#=> 1</span>
</code></pre>
<p>カッコを省略した場合、</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="n">foo</span> <span class="o">&</span>
<span class="n">bar</span>
</code></pre>
<p>というのが <code>foo & bar</code> なのか <code>foo(&); bar</code> なのか曖昧という問題が<br>
ありました。が、互換性重視で <code>foo & bar</code> と解釈するようになってい<br>
ます。というか書いてみたらそうなった。conflict は出ません。</p>
<pre><code class="diff syntaxhl" data-language="diff"><span class="gh">diff --git a/compile.c b/compile.c
index 2fd804c..3f8c331 100644
</span><span class="gd">--- a/compile.c
</span><span class="gi">+++ b/compile.c
</span><span class="p">@@ -2863,8 +2863,13 @@</span> setup_args(rb_iseq_t *iseq, LINK_ANCHOR *args,
<span class="p">NODE *argn, unsigned long *flag)
</span> INIT_ANCHOR(arg_block);
INIT_ANCHOR(args_splat);
if (argn && nd_type(argn) == NODE_BLOCK_PASS) {
<span class="gd">- COMPILE(arg_block, "block", argn->nd_body);
- *flag |= VM_CALL_ARGS_BLOCKARG_BIT;
</span><span class="gi">+ if ((VALUE)argn->nd_body != (VALUE)-1) {
+ COMPILE(arg_block, "block", argn->nd_body);
+ *flag |= VM_CALL_ARGS_BLOCKARG_BIT;
+ }
+ else {
+ *flag |= VM_CALL_ARGS_BLOCKTRGH_BIT;
+ }
</span> argn = argn->nd_head;
}
<span class="err">
</span><span class="gh">diff --git a/node.c b/node.c
index 65bc541..85574b4 100644
</span><span class="gd">--- a/node.c
</span><span class="gi">+++ b/node.c
</span><span class="p">@@ -621,7 +621,12 @@</span> dump_node(VALUE buf, VALUE indent, int comment, NODE *node)
ANN("example: foo(x, &blk)");
F_NODE(nd_head, "other arguments");
LAST_NODE;
<span class="gd">- F_NODE(nd_body, "block argument");
</span><span class="gi">+ if ((VALUE)node->nd_body != (VALUE)-1) {
+ F_NODE(nd_body, "block argument");
+ }
+ else {
+ F_MSG(nd_body, "block argument", "-1 (anonymous)");
+ }
</span> break;
<span class="err">
</span> case NODE_DEFN:
<span class="gh">diff --git a/parse.y b/parse.y
index e085088..b0b946b 100644
</span><span class="gd">--- a/parse.y
</span><span class="gi">+++ b/parse.y
</span><span class="p">@@ -2459,6 +2459,14 @@</span> block_arg : tAMPER arg_value
$$ = $2;
%*/
}
<span class="gi">+ | tAMPER
+ {
+ /*%%%*/
+ $$ = NEW_BLOCK_PASS(-1);
+ /*%
+ $$ = dispatch0(anonymous_block_arg);
+ %*/
+ }
</span> ;
<span class="err">
</span> opt_block_arg : ',' block_arg
<span class="gh">diff --git a/vm_core.h b/vm_core.h
index 7676b2f..f0fa3a3 100644
</span><span class="gd">--- a/vm_core.h
</span><span class="gi">+++ b/vm_core.h
</span><span class="p">@@ -544,6 +544,7 @@</span> typedef struct {
#define VM_CALL_TAILRECURSION_BIT (0x01 << 6)
#define VM_CALL_SUPER_BIT (0x01 << 7)
#define VM_CALL_OPT_SEND_BIT (0x01 << 8)
<span class="gi">+#define VM_CALL_ARGS_BLOCKTRGH_BIT (0x01 << 9)
</span><span class="err">
</span> #define VM_SPECIAL_OBJECT_VMCORE 0x01
#define VM_SPECIAL_OBJECT_CBASE 0x02
<span class="gh">diff --git a/vm_insnhelper.c b/vm_insnhelper.c
index 985a2fb..2a127d7 100644
</span><span class="gd">--- a/vm_insnhelper.c
</span><span class="gi">+++ b/vm_insnhelper.c
</span><span class="p">@@ -261,6 +261,10 @@</span> caller_setup_args(const rb_thread_t *th,
<span class="p">rb_control_frame_t *cfp, VALUE flag,
</span> *block = blockptr;
}
}
<span class="gi">+ else if (flag & VM_CALL_ARGS_BLOCKTRGH_BIT) {
+ rb_control_frame_t *reg_cfp = cfp;
+ *block = GET_BLOCK_PTR();
+ }
</span> else if (blockiseq) {
blockptr = RUBY_VM_GET_BLOCK_PTR_IN_CFP(cfp);
blockptr->iseq = blockiseq;
</code></pre>
<hr>
<p>Yusuke Endoh <a href="mailto:mame@tsg.ne.jp" class="email">mame@tsg.ne.jp</a></p>
Ruby master - Feature #3447: argument delegation
https://bugs.ruby-lang.org/issues/3447?journal_id=12975
2010-08-25T03:23:20Z
ko1 (Koichi Sasada)
<ul></ul><p> ささだです.</p>
<p> あまりに暑くて目が覚めました.</p>
<p>(2010/08/25 0:30), Yusuke ENDOH wrote:</p>
<blockquote>
<pre><code class="diff syntaxhl" data-language="diff"><span class="gd">--- a/vm_core.h
</span><span class="gi">+++ b/vm_core.h
</span><span class="p">@@ -544,6 +544,7 @@</span> typedef struct {
#define VM_CALL_TAILRECURSION_BIT (0x01 << 6)
#define VM_CALL_SUPER_BIT (0x01 << 7)
#define VM_CALL_OPT_SEND_BIT (0x01 << 8)
<span class="gi">+#define VM_CALL_ARGS_BLOCKTRGH_BIT (0x01 << 9)
</span><span class="err">
</span> #define VM_SPECIAL_OBJECT_VMCORE 0x01
#define VM_SPECIAL_OBJECT_CBASE 0x02
<span class="gh">diff --git a/vm_insnhelper.c b/vm_insnhelper.c
index 985a2fb..2a127d7 100644
</span><span class="gd">--- a/vm_insnhelper.c
</span><span class="gi">+++ b/vm_insnhelper.c
</span><span class="p">@@ -261,6 +261,10 @@</span> caller_setup_args(const rb_thread_t *th,
<span class="p">rb_control_frame_t *cfp, VALUE flag,
</span> *block = blockptr;
}
}
<span class="gi">+ else if (flag & VM_CALL_ARGS_BLOCKTRGH_BIT) {
+ rb_control_frame_t *reg_cfp = cfp;
+ *block = GET_BLOCK_PTR();
+ }
</span> else if (blockiseq) {
blockptr = RUBY_VM_GET_BLOCK_PTR_IN_CFP(cfp);
blockptr->iseq = blockiseq;
<span class="err">
</span></code></pre>
</blockquote>
<p> できれば,<code>VM_CALL_ARGS_BLOCKTRGH_BIT</code> を増やすんじゃなく<br>
て,<code>VM_CALL_ARGS_BLOCKARG_BIT</code> だけど,blockiseq かなんかの値を特殊にし<br>
ておくとか,そういう実装にしてもらえるといいんじゃないかと思います.</p>
<p>(命令オペランドのバリエーションが減った方が色々うれしい)</p>
<p>--<br>
// SASADA Koichi at atdot dot net</p>
Ruby master - Feature #3447: argument delegation
https://bugs.ruby-lang.org/issues/3447?journal_id=12977
2010-08-25T21:07:28Z
mame (Yusuke Endoh)
mame@ruby-lang.org
<ul></ul><p>遠藤です。</p>
<p>2010年8月25日3:23 SASADA Koichi <a href="mailto:ko1@atdot.net" class="email">ko1@atdot.net</a>:</p>
<blockquote>
<p> できれば,<code>VM_CALL_ARGS_BLOCKTRGH_BIT</code> を増やすんじゃなく<br>
て,<code>VM_CALL_ARGS_BLOCKARG_BIT</code> だけど,<code>blockiseq</code> かなんかの値を特殊にし<br>
ておくとか,そういう実装にしてもらえるといいんじゃないかと思います.</p>
<p>(命令オペランドのバリエーションが減った方が色々うれしい)</p>
</blockquote>
<p>コメントありがとうございます。でも、見かけ上バリエーションを増やさない<br>
ところで、<code>VM_CALL_ARGS_BLOCKTRGH_BIT</code> に結構異なる 2 つの意味を突っ込む<br>
ことになる (スタックに <code>Proc</code> を載せる・載せないの違いがあるので、細々条<br>
件判定が必要になる) ので、大して嬉しくないと思います。メンテナンス性も<br>
下がりますので、元のパッチの方がいいと思います。</p>
<p>一応 <code>blockiseq</code> に <code>-1</code> が入ってたら <code>BLOCKTRGH</code> 扱いにするパッチも書いてみ<br>
ましたが、かなり本質的でないコードでいっぱいになりました。<br>
# 今 trunk が壊れてるようなので、test-all はできてません。</p>
<pre><code class="diff syntaxhl" data-language="diff"><span class="gh">diff --git a/compile.c b/compile.c
index 2fd804c..1c04640 100644
</span><span class="gd">--- a/compile.c
</span><span class="gi">+++ b/compile.c
</span><span class="p">@@ -1411,11 +1411,18 @@</span> iseq_set_sequence(rb_iseq_t *iseq, LINK_ANCHOR *anchor)
case TS_ISEQ: /* iseq */
{
VALUE v = operands[j];
<span class="gd">- rb_iseq_t *block = 0;
</span><span class="gi">+ VALUE block = 0;
</span> if (v) {
<span class="gd">- GetISeqPtr(v, block);
</span><span class="gi">+ if (v == Qundef) {
+ block = (VALUE)-1;
+ }
+ else {
+ rb_iseq_t *blk;
+ GetISeqPtr(v, blk);
+ block = (VALUE)blk;
+ }
</span> }
<span class="gd">- generated_iseq[pos + 1 + j] = (VALUE)block;
</span><span class="gi">+ generated_iseq[pos + 1 + j] = block;
</span> break;
}
case TS_VALUE: /* VALUE */
<span class="p">@@ -2853,7 +2860,7 @@</span> add_ensure_iseq(LINK_ANCHOR *ret, rb_iseq_t *iseq, int is_return)
}
<span class="err">
</span> static VALUE
<span class="gd">-setup_args(rb_iseq_t *iseq, LINK_ANCHOR *args, NODE *argn, unsigned long *flag)
</span><span class="gi">+setup_args(rb_iseq_t *iseq, LINK_ANCHOR *args, NODE *argn, VALUE *blockiseq, unsigned long *flag)
</span> {
VALUE argc = INT2FIX(0);
int nsplat = 0;
<span class="p">@@ -2863,7 +2870,13 @@</span> setup_args(rb_iseq_t *iseq, LINK_ANCHOR *args, NODE *argn, unsigned long *flag)
INIT_ANCHOR(arg_block);
INIT_ANCHOR(args_splat);
if (argn && nd_type(argn) == NODE_BLOCK_PASS) {
<span class="gd">- COMPILE(arg_block, "block", argn->nd_body);
</span><span class="gi">+ if ((VALUE)argn->nd_body != (VALUE)-1) {
+ COMPILE(arg_block, "block", argn->nd_body);
+ }
+ else {
+ arg_block = 0;
+ if (blockiseq) *blockiseq = Qundef;
+ }
</span> *flag |= VM_CALL_ARGS_BLOCKARG_BIT;
argn = argn->nd_head;
}
<span class="p">@@ -2932,7 +2945,7 @@</span> setup_args(rb_iseq_t *iseq, LINK_ANCHOR *args, NODE *argn, unsigned long *flag)
ADD_SEQ(args, args_splat);
}
<span class="err">
</span><span class="gd">- if (*flag & VM_CALL_ARGS_BLOCKARG_BIT) {
</span><span class="gi">+ if ((*flag & VM_CALL_ARGS_BLOCKARG_BIT) && arg_block) {
</span> ADD_SEQ(args, arg_block);
}
return argc;
<span class="p">@@ -3776,7 +3789,7 @@</span> iseq_compile_each(rb_iseq_t *iseq, LINK_ANCHOR *ret, NODE * node, int poped)
boff = 1;
default:
INIT_ANCHOR(args);
<span class="gd">- argc = setup_args(iseq, args, node->nd_args->nd_head, &flag);
</span><span class="gi">+ argc = setup_args(iseq, args, node->nd_args->nd_head, 0, &flag);
</span> ADD_SEQ(ret, args);
}
ADD_INSN1(ret, nd_line(node), dupn, FIXNUM_INC(argc, 1 + boff));
<span class="p">@@ -4083,7 +4096,7 @@</span> iseq_compile_each(rb_iseq_t *iseq, LINK_ANCHOR *ret, NODE * node, int poped)
<span class="err">
</span> /* args */
if (nd_type(node) != NODE_VCALL) {
<span class="gd">- argc = setup_args(iseq, args, node->nd_args, &flag);
</span><span class="gi">+ argc = setup_args(iseq, args, node->nd_args, &parent_block, &flag);
</span> }
else {
argc = INT2FIX(0);
<span class="p">@@ -4121,7 +4134,7 @@</span> iseq_compile_each(rb_iseq_t *iseq, LINK_ANCHOR *ret, NODE * node, int poped)
INIT_ANCHOR(args);
iseq->compile_data->current_block = Qfalse;
if (nd_type(node) == NODE_SUPER) {
<span class="gd">- argc = setup_args(iseq, args, node->nd_args, &flag);
</span><span class="gi">+ argc = setup_args(iseq, args, node->nd_args, &parent_block, &flag);
</span> }
else {
/* NODE_ZSUPER */
<span class="p">@@ -4294,7 +4307,7 @@</span> iseq_compile_each(rb_iseq_t *iseq, LINK_ANCHOR *ret, NODE * node, int poped)
}
<span class="err">
</span> if (node->nd_head) {
<span class="gd">- argc = setup_args(iseq, args, node->nd_head, &flag);
</span><span class="gi">+ argc = setup_args(iseq, args, node->nd_head, 0, &flag);
</span> }
else {
argc = INT2FIX(0);
<span class="p">@@ -4906,7 +4919,7 @@</span> iseq_compile_each(rb_iseq_t *iseq, LINK_ANCHOR *ret, NODE * node, int poped)
<span class="err">
</span> INIT_ANCHOR(recv);
INIT_ANCHOR(args);
<span class="gd">- argc = setup_args(iseq, args, node->nd_args, &flag);
</span><span class="gi">+ argc = setup_args(iseq, args, node->nd_args, 0, &flag);
</span><span class="err">
</span> if (node->nd_recv == (NODE *) 1) {
flag |= VM_CALL_FCALL_BIT;
<span class="gh">diff --git a/insns.def b/insns.def
index fcd97ae..10b99be 100644
</span><span class="gd">--- a/insns.def
</span><span class="gi">+++ b/insns.def
</span><span class="p">@@ -989,7 +989,7 @@</span> DEFINE_INSN
send
(ID op_id, rb_num_t op_argc, ISEQ blockiseq, rb_num_t op_flag, IC ic)
(...)
<span class="gd">-(VALUE val) // inc += - (int)(op_argc + ((op_flag & VM_CALL_ARGS_BLOCKARG_BIT) ? 1 : 0));
</span><span class="gi">+(VALUE val) // inc += - (int)(op_argc + (((op_flag & VM_CALL_ARGS_BLOCKARG_BIT) && (VALUE)blockiseq != (VALUE)-1) ? 1 : 0));
</span> {
const rb_method_entry_t *me;
VALUE recv, klass;
<span class="p">@@ -1017,7 +1017,7 @@</span> DEFINE_INSN
invokesuper
(rb_num_t op_argc, ISEQ blockiseq, rb_num_t op_flag)
(...)
<span class="gd">-(VALUE val) // inc += - (int)(op_argc + ((op_flag & VM_CALL_ARGS_BLOCKARG_BIT) ? 1 : 0));
</span><span class="gi">+(VALUE val) // inc += - (int)(op_argc + (((op_flag & VM_CALL_ARGS_BLOCKARG_BIT) && (VALUE)blockiseq != (VALUE)-1) ? 1 : 0));
</span> {
rb_block_t *blockptr = !(op_flag & VM_CALL_ARGS_BLOCKARG_BIT) ? GET_BLOCK_PTR() : 0;
int num = caller_setup_args(th, GET_CFP(), op_flag,
<span class="gh">diff --git a/node.c b/node.c
index 65bc541..85574b4 100644
</span><span class="gd">--- a/node.c
</span><span class="gi">+++ b/node.c
</span><span class="p">@@ -621,7 +621,12 @@</span> dump_node(VALUE buf, VALUE indent, int comment, NODE *node)
ANN("example: foo(x, &blk)");
F_NODE(nd_head, "other arguments");
LAST_NODE;
<span class="gd">- F_NODE(nd_body, "block argument");
</span><span class="gi">+ if ((VALUE)node->nd_body != (VALUE)-1) {
+ F_NODE(nd_body, "block argument");
+ }
+ else {
+ F_MSG(nd_body, "block argument", "-1 (anonymous)");
+ }
</span> break;
<span class="err">
</span> case NODE_DEFN:
<span class="gh">diff --git a/parse.y b/parse.y
index e085088..b0b946b 100644
</span><span class="gd">--- a/parse.y
</span><span class="gi">+++ b/parse.y
</span><span class="p">@@ -2459,6 +2459,14 @@</span> block_arg : tAMPER arg_value
$$ = $2;
%*/
}
<span class="gi">+ | tAMPER
+ {
+ /*%%%*/
+ $$ = NEW_BLOCK_PASS(-1);
+ /*%
+ $$ = dispatch0(anonymous_block_arg);
+ %*/
+ }
</span> ;
<span class="err">
</span> opt_block_arg : ',' block_arg
<span class="gh">diff --git a/tool/instruction.rb b/tool/instruction.rb
index 4fd2127..4ce219f 100755
</span><span class="gd">--- a/tool/instruction.rb
</span><span class="gi">+++ b/tool/instruction.rb
</span><span class="p">@@ -66,13 +66,12 @@</span> class RubyVM
ret = "int inc = 0;\n"
<span class="err">
</span> @opes.each_with_index{|(t, v), i|
<span class="gd">- if t == 'rb_num_t' && ((re = /\b#{v}\b/n) =~ @sp_inc ||
- @defopes.any?{|t, val| re =~ val})
</span><span class="gi">+ if ((re = /\b#{v}\b/n) =~ @sp_inc || @defopes.any?{|t, val| re =~ val})
</span> ret << " int #{v} = FIX2INT(opes[#{i}]);\n"
end
}
@defopes.each_with_index{|((t, var), val), i|
<span class="gd">- if t == 'rb_num_t' && val != '*' && /\b#{var}\b/ =~ @sp_inc
</span><span class="gi">+ if val != '*' && /\b#{var}\b/ =~ @sp_inc
</span> ret << " #{t} #{var} = #{val};\n"
end
}
<span class="gh">diff --git a/vm_insnhelper.c b/vm_insnhelper.c
index 985a2fb..f6418b7 100644
</span><span class="gd">--- a/vm_insnhelper.c
</span><span class="gi">+++ b/vm_insnhelper.c
</span><span class="p">@@ -240,25 +240,31 @@</span> caller_setup_args(const rb_thread_t *th, rb_control_frame_t *cfp, VALUE flag,
<span class="err">
</span> if (block) {
if (flag & VM_CALL_ARGS_BLOCKARG_BIT) {
<span class="gd">- rb_proc_t *po;
- VALUE proc;
-
- proc = *(--cfp->sp);
-
- if (proc != Qnil) {
- if (!rb_obj_is_proc(proc)) {
- VALUE b = rb_check_convert_type(proc, T_DATA, "Proc", "to_proc");
- if (NIL_P(b) || !rb_obj_is_proc(b)) {
- rb_raise(rb_eTypeError,
- "wrong argument type %s (expected Proc)",
- rb_obj_classname(proc));
</span><span class="gi">+ if ((VALUE)blockiseq != (VALUE)-1) {
+ rb_proc_t *po;
+ VALUE proc;
+
+ proc = *(--cfp->sp);
+
+ if (proc != Qnil) {
+ if (!rb_obj_is_proc(proc)) {
+ VALUE b = rb_check_convert_type(proc, T_DATA, "Proc", "to_proc");
+ if (NIL_P(b) || !rb_obj_is_proc(b)) {
+ rb_raise(rb_eTypeError,
+ "wrong argument type %s (expected Proc)",
+ rb_obj_classname(proc));
+ }
+ proc = b;
</span> }
<span class="gd">- proc = b;
</span><span class="gi">+ GetProcPtr(proc, po);
+ blockptr = &po->block;
+ RUBY_VM_GET_BLOCK_PTR_IN_CFP(cfp)->proc = proc;
+ *block = blockptr;
</span> }
<span class="gd">- GetProcPtr(proc, po);
- blockptr = &po->block;
- RUBY_VM_GET_BLOCK_PTR_IN_CFP(cfp)->proc = proc;
- *block = blockptr;
</span><span class="gi">+ }
+ else {
+ rb_control_frame_t *reg_cfp = cfp;
+ *block = GET_BLOCK_PTR();
</span> }
}
else if (blockiseq) {
</code></pre>
<hr>
<p>Yusuke Endoh <a href="mailto:mame@tsg.ne.jp" class="email">mame@tsg.ne.jp</a></p>
Ruby master - Feature #3447: argument delegation
https://bugs.ruby-lang.org/issues/3447?journal_id=12993
2010-08-26T23:28:08Z
yugui (Yuki Sonoda)
yugui@yugui.jp
<ul></ul><p>Yuguiです</p>
<p>2010/6/17 Yukihiro Matsumoto <a href="mailto:matz@ruby-lang.org" class="email">matz@ruby-lang.org</a>:</p>
<blockquote>
<p>が、もともとの動機とは別として、「<code>&</code>」1文字でそのコンテキスト<br>
のブロックを渡すのは、面白いアイディアだと思います。この場合<br>
は、仮引数リストのブロック引数がなくても、ブロックを渡すこと<br>
になるんですかね。</p>
</blockquote>
<p>深い呼び出し階層でブロックを受け取るために、上位のメソッドが延々とブロックを引き渡し続けるっていうケースは実際にプログラムしていてよく出会います。ですから、このとき下位呼び出しの実引数に<code>&block</code>を足して、仮引数にも忘れずに<code>&block</code>を足してというのは面倒で、このアイディアは便利そうです。</p>
<p>しかし、あまりにも短すぎる。<code>&</code>1文字は見落としそうです。</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="n">foo</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="n">b</span><span class="p">,</span> <span class="o">&</span><span class="k">yield</span><span class="p">)</span>
</code></pre>
<p>なんてのは駄目でしょうか。<code>yield</code> と <code>block.call</code>の類似性からの類推です。</p>
<hr>
<p>Yuki Sonoda (Yugui)<br>
<a href="mailto:yugui@yugui.jp" class="email">yugui@yugui.jp</a><br>
<a href="http://yugui.jp" class="external">http://yugui.jp</a></p>
Ruby master - Feature #3447: argument delegation
https://bugs.ruby-lang.org/issues/3447?journal_id=13126
2010-09-02T03:06:36Z
mame (Yusuke Endoh)
mame@ruby-lang.org
<ul></ul><p>遠藤です。</p>
<p>2010年8月26日23:28 Yugui <a href="mailto:yugui@yugui.jp" class="email">yugui@yugui.jp</a>:</p>
<blockquote>
<p>しかし、あまりにも短すぎる。<code>&</code>1文字は見落としそうです。</p>
</blockquote>
<p>いやあ、考えすぎでしょう。<br>
<code>func(foo + bar, baz * qux, i)</code> で <code>i</code> を見落とすとかないですよ。<br>
<code>&</code> は <code>i</code> より目立つし。</p>
<blockquote>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="n">foo</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="n">b</span><span class="p">,</span> <span class="o">&</span><span class="k">yield</span><span class="p">)</span>
</code></pre>
<p>なんてのは駄目でしょうか。<code>yield</code> と <code>block.call</code>の類似性からの類推です。</p>
</blockquote>
<p>それは互換性に問題があります。</p>
<hr>
<p>Yusuke Endoh <a href="mailto:mame@tsg.ne.jp" class="email">mame@tsg.ne.jp</a></p>
Ruby master - Feature #3447: argument delegation
https://bugs.ruby-lang.org/issues/3447?journal_id=24725
2012-03-18T17:19:44Z
shyouhei (Shyouhei Urabe)
shyouhei@ruby-lang.org
<ul><li><strong>Description</strong> updated (<a title="View differences" href="/journals/24725/diff?detail_id=18026">diff</a>)</li><li><strong>Status</strong> changed from <i>Open</i> to <i>Feedback</i></li></ul><ul>
<li>このスレッドの現状をどなたか教えていただけませんか。</li>
<li>この記法のユースケースをどなたか教えていただけませんか。</li>
</ul>
Ruby master - Feature #3447: argument delegation
https://bugs.ruby-lang.org/issues/3447?journal_id=26800
2012-05-24T23:54:08Z
nobu (Nobuyoshi Nakada)
nobu@ruby-lang.org
<ul><li><strong>Description</strong> updated (<a title="View differences" href="/journals/26800/diff?detail_id=19817">diff</a>)</li></ul>
Ruby master - Feature #3447: argument delegation
https://bugs.ruby-lang.org/issues/3447?journal_id=33305
2012-11-20T22:54:20Z
mame (Yusuke Endoh)
mame@ruby-lang.org
<ul><li><strong>Status</strong> changed from <i>Feedback</i> to <i>Assigned</i></li><li><strong>Assignee</strong> set to <i>matz (Yukihiro Matsumoto)</i></li><li><strong>Target version</strong> set to <i>2.6</i></li></ul><p>shyouhei (Shyouhei Urabe) wrote:</p>
<blockquote>
<ul>
<li>このスレッドの現状をどなたか教えていただけませんか。</li>
</ul>
</blockquote>
<p>matz の最終的な go ahead 待ちだと思いますが、2.0.0 の feature deadline は過ぎたので next minor に。</p>
<blockquote>
<ul>
<li>この記法のユースケースをどなたか教えていただけませんか。</li>
</ul>
</blockquote>
<p>「この記法」は matz の元提案の話?それとも <code>&</code> の話?<br>
後者だとしたら、</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="k">def</span> <span class="nf">foo</span><span class="p">;</span> <span class="o">...</span> <span class="k">yield</span> <span class="o">...</span> <span class="k">end</span>
<span class="n">foo</span> <span class="p">{</span> <span class="o">...</span> <span class="p">}</span>
</code></pre>
<p>と書いてたんだけど、リファクタリングで <code>foo</code> の中身を <code>bar</code> にくくり出すことになった、というとき、</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="k">def</span> <span class="nf">bar</span><span class="p">;</span> <span class="o">...</span> <span class="k">yield</span> <span class="o">...</span> <span class="k">end</span>
<span class="k">def</span> <span class="nf">foo</span><span class="p">(</span><span class="o">&</span><span class="n">blk</span><span class="p">);</span> <span class="o">...</span> <span class="n">bar</span><span class="p">(</span><span class="o">&</span><span class="n">blk</span><span class="p">)</span> <span class="o">...</span> <span class="k">end</span>
<span class="n">foo</span> <span class="p">{</span> <span class="o">...</span> <span class="p">}</span>
</code></pre>
<p>とすると思いますが、<code>blk</code> という一時変数を定義したくない and/or ブロックが <code>Proc</code> 化するので重くなるのが嫌、とかですかね。</p>
<hr>
<p>Yusuke Endoh <a href="mailto:mame@tsg.ne.jp" class="email">mame@tsg.ne.jp</a></p>
Ruby master - Feature #3447: argument delegation
https://bugs.ruby-lang.org/issues/3447?journal_id=45152
2014-02-14T10:10:42Z
nobu (Nobuyoshi Nakada)
nobu@ruby-lang.org
<ul><li><strong>Description</strong> updated (<a title="View differences" href="/journals/45152/diff?detail_id=32602">diff</a>)</li></ul>
Ruby master - Feature #3447: argument delegation
https://bugs.ruby-lang.org/issues/3447?journal_id=53076
2015-06-22T07:44:07Z
matz (Yukihiro Matsumoto)
matz@ruby.or.jp
<ul><li><strong>Related to</strong> <i><a class="issue tracker-2 status-5 priority-4 priority-default closed" href="/issues/11256">Feature #11256</a>: anonymous block forwarding</i> added</li></ul>
Ruby master - Feature #3447: argument delegation
https://bugs.ruby-lang.org/issues/3447?journal_id=68652
2017-12-25T18:14:58Z
naruse (Yui NARUSE)
naruse@airemix.jp
<ul><li><strong>Target version</strong> deleted (<del><i>2.6</i></del>)</li></ul>
Ruby master - Feature #3447: argument delegation
https://bugs.ruby-lang.org/issues/3447?journal_id=94094
2021-10-08T22:04:48Z
jeremyevans0 (Jeremy Evans)
merch-redmine@jeremyevans.net
<ul><li><strong>Status</strong> changed from <i>Assigned</i> to <i>Closed</i></li></ul>