https://redmine.ruby-lang.org/
https://redmine.ruby-lang.org/favicon.ico?1711330511
2012-05-24T16:59:57Z
Ruby Issue Tracking System
Ruby master - Feature #6483: parametric map
https://redmine.ruby-lang.org/issues/6483?journal_id=26791
2012-05-24T16:59:57Z
prijutme4ty (Ilya Vorontsov)
prijutme4ty@gmail.com
<ul></ul><p>Also I propose similar approach for <code>tap</code> method.</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="k">class</span> <span class="nc">Object</span>
<span class="k">def</span> <span class="nf">ptap</span><span class="p">(</span><span class="o">*</span><span class="n">args</span><span class="p">,</span><span class="o">&</span><span class="n">block</span><span class="p">)</span>
<span class="n">tap</span> <span class="o">&</span><span class="n">block</span><span class="p">.</span><span class="nf">curry_except_self</span><span class="p">(</span><span class="o">*</span><span class="n">args</span><span class="p">)</span>
<span class="k">end</span>
<span class="k">end</span>
</code></pre>
<p>So instead of</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="n">lines</span> <span class="o">=</span> <span class="no">File</span><span class="p">.</span><span class="nf">read</span><span class="p">(</span><span class="s1">'filename.txt'</span><span class="p">);</span>
<span class="n">lines</span><span class="p">.</span><span class="nf">delete</span><span class="p">(</span><span class="s1">''</span><span class="p">)</span>
</code></pre>
<p>or</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="n">lines</span> <span class="o">=</span> <span class="no">File</span><span class="p">.</span><span class="nf">read</span><span class="p">(</span><span class="s1">'filename.txt'</span><span class="p">).</span><span class="nf">tap</span><span class="p">{</span><span class="o">|</span><span class="n">x</span><span class="o">|</span><span class="n">x</span><span class="p">.</span><span class="nf">delete</span> <span class="s1">''</span><span class="p">}</span>
</code></pre>
<p>I can use</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="n">lines</span> <span class="o">=</span> <span class="no">File</span><span class="p">.</span><span class="nf">read</span><span class="p">(</span><span class="s1">'filename.txt'</span><span class="p">).</span><span class="nf">ptap</span><span class="p">(</span><span class="s1">''</span><span class="p">,</span> <span class="o">&</span><span class="ss">:delete</span><span class="p">)</span>
</code></pre>
Ruby master - Feature #6483: parametric map
https://redmine.ruby-lang.org/issues/6483?journal_id=26792
2012-05-24T17:13:50Z
nobu (Nobuyoshi Nakada)
nobu@ruby-lang.org
<ul></ul><p>I proposed a different approach, symbol with arguments syntax.</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="p">(</span><span class="mi">1</span><span class="o">..</span><span class="mi">5</span><span class="p">).</span><span class="nf">map</span><span class="p">(</span><span class="o">&</span><span class="ss">:to_s</span><span class="p">(</span><span class="mi">2</span><span class="p">))</span> <span class="c1">#=> ['1', '10', '11', '100', '101']</span>
</code></pre>
<p>And another proposed <code>Symbol#call</code> in the same thread, instead.</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="p">(</span><span class="mi">1</span><span class="o">..</span><span class="mi">5</span><span class="p">).</span><span class="nf">map</span><span class="p">(</span><span class="o">&</span><span class="ss">:to_s</span><span class="o">.</span><span class="p">(</span><span class="mi">2</span><span class="p">))</span> <span class="c1">#=> ['1', '10', '11', '100', '101']</span>
</code></pre>
Ruby master - Feature #6483: parametric map
https://redmine.ruby-lang.org/issues/6483?journal_id=26793
2012-05-24T18:21:58Z
prijutme4ty (Ilya Vorontsov)
prijutme4ty@gmail.com
<ul></ul><p>nobu (Nobuyoshi Nakada) wrote:</p>
<blockquote>
<p>I proposed a different approach, symbol with arguments syntax.</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="p">(</span><span class="mi">1</span><span class="o">..</span><span class="mi">5</span><span class="p">).</span><span class="nf">map</span><span class="p">(</span><span class="o">&</span><span class="ss">:to_s</span><span class="p">(</span><span class="mi">2</span><span class="p">))</span> <span class="c1">#=> ['1', '10', '11', '100', '101']</span>
</code></pre>
<p>And another proposed <code>Symbol#call</code> in the same thread, instead.</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="p">(</span><span class="mi">1</span><span class="o">..</span><span class="mi">5</span><span class="p">).</span><span class="nf">map</span><span class="p">(</span><span class="o">&</span><span class="ss">:to_s</span><span class="o">.</span><span class="p">(</span><span class="mi">2</span><span class="p">))</span> <span class="c1">#=> ['1', '10', '11', '100', '101']</span>
</code></pre>
</blockquote>
<p>Really cool syntax! I didn't even thought that about such a way. Second version I wrote like that:</p>
<pre><code class="RUBY syntaxhl" data-language="RUBY"><span class="k">class</span> <span class="nc">Symbol</span>
<span class="k">def</span> <span class="nf">call</span><span class="p">(</span><span class="o">*</span><span class="n">args</span><span class="p">)</span>
<span class="n">obj</span><span class="o">=</span><span class="no">Object</span><span class="p">.</span><span class="nf">new</span><span class="p">.</span><span class="nf">instance_exec</span><span class="p">(</span><span class="nb">self</span><span class="p">,</span><span class="n">args</span><span class="p">){</span><span class="o">|</span><span class="n">sym</span><span class="p">,</span><span class="n">params</span><span class="o">|</span> <span class="vi">@sym</span><span class="o">=</span><span class="n">sym</span><span class="p">;</span> <span class="vi">@args</span> <span class="o">=</span> <span class="n">params</span><span class="p">;</span> <span class="nb">self</span><span class="p">}</span>
<span class="n">obj</span><span class="p">.</span><span class="nf">define_singleton_method</span> <span class="ss">:to_proc</span> <span class="k">do</span>
<span class="vi">@sym</span><span class="p">.</span><span class="nf">to_proc</span><span class="p">.</span><span class="nf">curry_except_self</span><span class="p">(</span><span class="o">*</span><span class="vi">@args</span><span class="p">)</span>
<span class="k">end</span>
<span class="n">obj</span>
<span class="k">end</span>
<span class="k">end</span>
</code></pre>
<p>Unfortunately symbol isn't cloneable, so I used auxiliary object<br>
In such a way one shouldn't define both tap and map and pleorth of other methods!</p>
<p>But first approach you suggested cannot be implemented in ruby yet. Hope sometimes ruby'll supply such a syntax! I propose it shouldn't even have parentheses for args</p>
Ruby master - Feature #6483: parametric map
https://redmine.ruby-lang.org/issues/6483?journal_id=26794
2012-05-24T18:49:29Z
Eregon (Benoit Daloze)
<ul></ul><p>nobu (Nobuyoshi Nakada) wrote:</p>
<blockquote>
<p>I proposed a different approach, symbol with arguments syntax.</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="p">(</span><span class="mi">1</span><span class="o">..</span><span class="mi">5</span><span class="p">).</span><span class="nf">map</span><span class="p">(</span><span class="o">&</span><span class="ss">:to_s</span><span class="p">(</span><span class="mi">2</span><span class="p">))</span> <span class="c1">#=> ['1', '10', '11', '100', '101']</span>
</code></pre>
<p>And another proposed (({Symbol#call})) in the same thread, instead.</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="p">(</span><span class="mi">1</span><span class="o">..</span><span class="mi">5</span><span class="p">).</span><span class="nf">map</span><span class="p">(</span><span class="o">&</span><span class="ss">:to_s</span><span class="o">.</span><span class="p">(</span><span class="mi">2</span><span class="p">))</span> <span class="c1">#=> ['1', '10', '11', '100', '101']</span>
</code></pre>
</blockquote>
<p>For info, this is <a href="http://bugs.ruby-lang.org/issues/show/4146" class="external">http://bugs.ruby-lang.org/issues/show/4146</a> (I had a hard time finding it back).</p>
<p>Another syntax is proposed by Koichi (from what I can understand):</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="nb">p</span> <span class="sx">%w[12 45 32]</span><span class="p">.</span><span class="nf">map</span><span class="p">(</span><span class="o">&</span><span class="no">PM</span><span class="p">.</span><span class="nf">to_i</span><span class="p">(</span><span class="mi">9</span><span class="p">)).</span><span class="nf">map</span><span class="p">(</span><span class="o">&</span><span class="no">PM</span> <span class="o">*</span> <span class="mi">2</span><span class="p">)</span>
<span class="nb">p</span> <span class="sx">%w[abc def ghi]</span><span class="p">.</span><span class="nf">map</span><span class="p">(</span><span class="o">&</span><span class="no">PM</span><span class="p">[</span><span class="mi">1</span><span class="p">])</span>
</code></pre>
<p>Which might be simplified to:</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="nb">p</span> <span class="sx">%w[12 45 32]</span><span class="p">.</span><span class="nf">map</span><span class="p">(</span><span class="o">&</span><span class="p">.</span><span class="nf">to_i</span><span class="p">(</span><span class="mi">9</span><span class="p">)).</span><span class="nf">map</span><span class="p">(</span><span class="o">&</span> <span class="o">*</span> <span class="mi">2</span><span class="p">)</span>
<span class="nb">p</span> <span class="sx">%w[abc def ghi]</span><span class="p">.</span><span class="nf">map</span><span class="p">(</span><span class="o">&</span><span class="p">[</span><span class="mi">1</span><span class="p">])</span>
</code></pre>
<p>I really like that one.</p>
Ruby master - Feature #6483: parametric map
https://redmine.ruby-lang.org/issues/6483?journal_id=26796
2012-05-24T20:32:16Z
trans (Thomas Sawyer)
<ul></ul><pre><code class="ruby syntaxhl" data-language="ruby"><span class="nb">p</span> <span class="sx">%w[12 45 32]</span><span class="p">.</span><span class="nf">map</span><span class="p">(</span><span class="o">&</span><span class="p">.</span><span class="nf">to_i</span><span class="p">(</span><span class="mi">9</span><span class="p">)).</span><span class="nf">map</span><span class="p">(</span><span class="o">&</span> <span class="o">*</span> <span class="mi">2</span><span class="p">)</span>
</code></pre>
<p>That's pretty neat. I wonder about its implementation, so basically <code>&</code> becomes a special object that returns a proc when method is called on it?</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="k">class</span> <span class="nc">Ampersand</span> <span class="o"><</span> <span class="no">BasicObject</span>
<span class="k">def</span> <span class="nf">method_missing</span><span class="p">(</span><span class="n">s</span><span class="p">,</span> <span class="o">*</span><span class="n">a</span><span class="p">,</span> <span class="o">&</span><span class="n">b</span><span class="p">)</span>
<span class="o">::</span><span class="no">Proc</span><span class="p">.</span><span class="nf">new</span><span class="p">{</span> <span class="o">|</span><span class="n">x</span><span class="o">|</span> <span class="n">x</span><span class="p">.</span><span class="nf">public_send</span><span class="p">(</span><span class="n">s</span><span class="p">,</span> <span class="o">*</span><span class="n">a</span><span class="p">,</span> <span class="o">&</span><span class="n">b</span><span class="p">)</span> <span class="p">}</span>
<span class="k">end</span>
<span class="k">end</span>
<span class="o">&</span> <span class="o">=</span> <span class="no">Ampersand</span><span class="p">.</span><span class="nf">new</span>
</code></pre>
<p>This is also interesting in that it has an appearance similar to an anaphora (default block argument):</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="nb">p</span> <span class="sx">%w[12 45 32]</span><span class="p">.</span><span class="nf">map</span><span class="p">{</span><span class="n">it</span><span class="p">.</span><span class="nf">to_i</span><span class="p">(</span><span class="mi">9</span><span class="p">)}.</span><span class="nf">map</span><span class="p">{</span><span class="n">it</span> <span class="o">*</span> <span class="mi">2</span><span class="p">}</span>
</code></pre>
<p>But despite appearances they are very different in nature.</p>
Ruby master - Feature #6483: parametric map
https://redmine.ruby-lang.org/issues/6483?journal_id=26797
2012-05-24T20:34:49Z
trans (Thomas Sawyer)
<ul></ul><p>FYI <a href="https://github.com/raganwald/homoiconic/blob/master/2009-09-22/anaphora.md" class="external">https://github.com/raganwald/homoiconic/blob/master/2009-09-22/anaphora.md</a></p>
Ruby master - Feature #6483: parametric map
https://redmine.ruby-lang.org/issues/6483?journal_id=26804
2012-05-25T03:49:30Z
prijutme4ty (Ilya Vorontsov)
prijutme4ty@gmail.com
<ul></ul><p>Eregon (Benoit Daloze) wrote:</p>
<blockquote>
<p>Another syntax is proposed by Koichi (from what I can understand):</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="nb">p</span> <span class="sx">%w[12 45 32]</span><span class="p">.</span><span class="nf">map</span><span class="p">(</span><span class="o">&</span><span class="no">PM</span><span class="p">.</span><span class="nf">to_i</span><span class="p">(</span><span class="mi">9</span><span class="p">)).</span><span class="nf">map</span><span class="p">(</span><span class="o">&</span><span class="no">PM</span> <span class="o">*</span> <span class="mi">2</span><span class="p">)</span>
<span class="nb">p</span> <span class="sx">%w[abc def ghi]</span><span class="p">.</span><span class="nf">map</span><span class="p">(</span><span class="o">&</span><span class="no">PM</span><span class="p">[</span><span class="mi">1</span><span class="p">])</span>
</code></pre>
<p>Which might be simplified to:</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="nb">p</span> <span class="sx">%w[12 45 32]</span><span class="p">.</span><span class="nf">map</span><span class="p">(</span><span class="o">&</span><span class="p">.</span><span class="nf">to_i</span><span class="p">(</span><span class="mi">9</span><span class="p">)).</span><span class="nf">map</span><span class="p">(</span><span class="o">&</span> <span class="o">*</span> <span class="mi">2</span><span class="p">)</span>
<span class="nb">p</span> <span class="sx">%w[abc def ghi]</span><span class="p">.</span><span class="nf">map</span><span class="p">(</span><span class="o">&</span><span class="p">[</span><span class="mi">1</span><span class="p">])</span>
</code></pre>
<p>I really like that one.</p>
</blockquote>
<p>It's fine, but in version with PM it look like a hack. However if it'll be implemented in second version - I'd take my words back.</p>
Ruby master - Feature #6483: parametric map
https://redmine.ruby-lang.org/issues/6483?journal_id=26846
2012-05-27T00:50:45Z
mame (Yusuke Endoh)
mame@ruby-lang.org
<ul><li><strong>Status</strong> changed from <i>Open</i> to <i>Assigned</i></li><li><strong>Assignee</strong> set to <i>matz (Yukihiro Matsumoto)</i></li></ul><p>Assigning to matz.</p>
<p>Eregon (Benoit Daloze) wrote:</p>
<blockquote>
<p>For info, this is <a href="http://bugs.ruby-lang.org/issues/show/4146" class="external">http://bugs.ruby-lang.org/issues/show/4146</a> (I had a hard time finding it back).</p>
</blockquote>
<p>Thanks Benoit! I added it as a related ticket.</p>
<p>--<br>
Yusuke Endoh <a href="mailto:mame@tsg.ne.jp" class="email">mame@tsg.ne.jp</a></p>
Ruby master - Feature #6483: parametric map
https://redmine.ruby-lang.org/issues/6483?journal_id=26996
2012-06-04T00:49:02Z
prijutme4ty (Ilya Vorontsov)
prijutme4ty@gmail.com
<ul></ul><p>I've made a simple extension that allows one to use nested symbolic-procs like this:</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="p">[[</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">3</span><span class="p">],[</span><span class="mi">4</span><span class="p">,</span><span class="mi">5</span><span class="p">,</span><span class="mi">6</span><span class="p">]].</span><span class="nf">map</span><span class="p">(</span><span class="o">&</span><span class="ss">:map</span><span class="o">.</span><span class="p">(</span><span class="o">&</span><span class="ss">:to_s</span><span class="o">.</span><span class="p">(</span><span class="mi">2</span><span class="p">)))</span> <span class="c1"># => [['1','10','11'],['100','101','110']]</span>
</code></pre>
<p>Not to duplicate code - look at <a href="http://bugs.ruby-lang.org/issues/4146#change-26991" class="external">http://bugs.ruby-lang.org/issues/4146#change-26991</a></p>
Ruby master - Feature #6483: parametric map
https://redmine.ruby-lang.org/issues/6483?journal_id=27462
2012-06-26T09:54:50Z
nobu (Nobuyoshi Nakada)
nobu@ruby-lang.org
<ul></ul><p>In <code>golf_prelude.rb</code>:</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="k">class</span> <span class="nc">Symbol</span>
<span class="k">def</span> <span class="nf">call</span><span class="p">(</span><span class="o">*</span><span class="n">args</span><span class="p">,</span> <span class="o">&</span><span class="n">block</span><span class="p">)</span>
<span class="nb">proc</span> <span class="k">do</span> <span class="o">|</span><span class="n">recv</span><span class="o">|</span>
<span class="n">recv</span><span class="p">.</span><span class="nf">__send__</span><span class="p">(</span><span class="nb">self</span><span class="p">,</span> <span class="o">*</span><span class="n">args</span><span class="p">,</span> <span class="o">&</span><span class="n">block</span><span class="p">)</span>
<span class="k">end</span>
<span class="k">end</span>
<span class="k">end</span>
</code></pre>
<p>It might use <code>public_send</code>, indeed.</p>
Ruby master - Feature #6483: parametric map
https://redmine.ruby-lang.org/issues/6483?journal_id=27656
2012-07-01T19:12:18Z
prijutme4ty (Ilya Vorontsov)
prijutme4ty@gmail.com
<ul></ul><p>Thank you for much more elegant code. It works with all of my specs except one:</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="p">[</span><span class="s1">'abc'</span><span class="p">,</span><span class="s1">'cdef'</span><span class="p">,</span><span class="s1">'xy'</span><span class="p">,</span><span class="s1">'z'</span><span class="p">,</span><span class="s1">'wwww'</span><span class="p">].</span><span class="nf">select</span><span class="p">(</span><span class="o">&</span><span class="ss">:size</span><span class="o">.</span><span class="p">()</span> <span class="o">==</span> <span class="mi">4</span><span class="p">)</span> <span class="c1"># ==> ['cdef', 'wwww']</span>
</code></pre>
<p>It looks that one cannot make this work without proxy object.</p>
Ruby master - Feature #6483: parametric map
https://redmine.ruby-lang.org/issues/6483?journal_id=33315
2012-11-20T23:03:16Z
mame (Yusuke Endoh)
mame@ruby-lang.org
<ul><li><strong>Target version</strong> set to <i>2.6</i></li></ul>
Ruby master - Feature #6483: parametric map
https://redmine.ruby-lang.org/issues/6483?journal_id=33321
2012-11-20T23:12:58Z
matz (Yukihiro Matsumoto)
matz@ruby.or.jp
<ul><li><strong>Status</strong> changed from <i>Assigned</i> to <i>Rejected</i></li></ul><p>I reject the original idea of #pmap which might be read as 'parallel map' or 'parametric map' or something else.<br>
The idea of adding parameter to block with argument specified e.g. a.map(&:to_s.(2)) is interesting,<br>
but it must be proposed in separated issue.</p>
<p>Matz.</p>