https://redmine.ruby-lang.org/https://redmine.ruby-lang.org/favicon.ico?17113305112016-02-28T21:43:13ZRuby Issue Tracking SystemRuby master - Feature #12125: Proposal: Shorthand operator for Object#methodhttps://redmine.ruby-lang.org/issues/12125?journal_id=571922016-02-28T21:43:13ZPapierkorb (Stefan Merettig)
<ul></ul><blockquote>
<p>The & operator lets one pass a #call-able object as block.</p>
</blockquote>
<p>I meant <code>#to_proc</code>-able objects, sorry for the confusion.</p> Ruby master - Feature #12125: Proposal: Shorthand operator for Object#methodhttps://redmine.ruby-lang.org/issues/12125?journal_id=571932016-02-29T00:37:03Zmatz (Yukihiro Matsumoto)matz@ruby.or.jp
<ul></ul><p>I like the idea of short hand notation for <code>Object#method()</code>, but I don't think <code>-></code> is a good idea.</p>
<p>Matz.</p> Ruby master - Feature #12125: Proposal: Shorthand operator for Object#methodhttps://redmine.ruby-lang.org/issues/12125?journal_id=572052016-02-29T12:58:28Zzverok (Victor Shepelev)zverok.offline@gmail.com
<ul></ul><p>For this kind of "conceptual" methods I sometimes define just one-letter shortcuts in core_ext.rb, like <code>.map(&File.m(:basename))</code>. I'm not sure, though, if any of existing/popular libraries will struggle from such kind of solution (or may be it would not play really well with local variables, which are frequently have one-letter names).</p> Ruby master - Feature #12125: Proposal: Shorthand operator for Object#methodhttps://redmine.ruby-lang.org/issues/12125?journal_id=572072016-02-29T14:14:02ZPapierkorb (Stefan Merettig)
<ul></ul><p>Yukihiro Matsumoto wrote:</p>
<blockquote>
<p>but I don't think <code>-></code> is a good idea.</p>
</blockquote>
<p>Other options I can think of are:</p>
<ul>
<li>Using <code>.></code>: <code>the_object.>a_method</code> While its look is nearer to a normal method call (Which I think is a plus), I fear that the period would be hard to see in some fonts. Another plus is that this would be a entirely new operator, so no (unintentional?) breaking changes in the parser.</li>
<li>Using <code><..></code>: <code>the_object<a_method></code> Inspired by the look of generics/templates in other programming languages. Should not clash with existing code and parsers and is well-readable in fonts I guess. Maybe it doesn't read as well anymore though, and the intention of <code><..></code> may not be that clear at first to someone who doesn't know the syntax (yet). No idea if that is a concern.</li>
<li>Using <code>&></code>: <code>the_object&>a_method</code> Also readable in any font I can think of. It's a spin on <code>&.</code>, reading like "and this"</li>
<li>Using <code>|></code>: <code>the_object|>a_method</code> I think the <em>Elixir</em> language has this operator too (albeit with other semantics?). Its read like "and pipe it through this", so maybe it reads a bit like a shell script too?</li>
</ul>
<p>Regards,<br>
Stefan</p> Ruby master - Feature #12125: Proposal: Shorthand operator for Object#methodhttps://redmine.ruby-lang.org/issues/12125?journal_id=572082016-02-29T14:29:48Zksss (Yuki Kurihara)co000ri@gmail.com
<ul></ul><p>How about this one?</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="k">class</span> <span class="nc">UnfoundMethod</span>
<span class="k">def</span> <span class="nf">initialize</span><span class="p">(</span><span class="n">receiver</span><span class="p">)</span>
<span class="vi">@receiver</span> <span class="o">=</span> <span class="n">receiver</span>
<span class="k">end</span>
<span class="k">def</span> <span class="nf">method_missing</span><span class="p">(</span><span class="nb">name</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="vi">@receiver</span><span class="p">.</span><span class="nf">method</span><span class="p">(</span><span class="nb">name</span><span class="p">)</span>
<span class="k">end</span>
<span class="k">end</span>
<span class="k">module</span> <span class="nn">UnfoundMethodAttacher</span>
<span class="k">def</span> <span class="nf">method</span><span class="p">(</span><span class="nb">name</span><span class="o">=</span><span class="kp">nil</span><span class="p">)</span>
<span class="k">if</span> <span class="nb">name</span>
<span class="k">super</span>
<span class="k">else</span>
<span class="no">UnfoundMethod</span><span class="p">.</span><span class="nf">new</span><span class="p">(</span><span class="nb">self</span><span class="p">)</span>
<span class="k">end</span>
<span class="k">end</span>
<span class="k">end</span>
<span class="no">Object</span><span class="p">.</span><span class="nf">prepend</span> <span class="no">UnfoundMethodAttacher</span>
<span class="no">File</span><span class="p">.</span><span class="nf">method</span> <span class="c1">#=> #<UnfoundMethod receiver=File></span>
<span class="no">File</span><span class="p">.</span><span class="nf">method</span><span class="p">.</span><span class="nf">basename</span> <span class="c1">#=> #<Method: File.basename></span>
<span class="no">Dir</span><span class="p">[</span><span class="s2">"*/*.c"</span><span class="p">].</span><span class="nf">map</span><span class="p">(</span><span class="o">&</span><span class="no">File</span><span class="p">.</span><span class="nf">method</span><span class="p">.</span><span class="nf">basename</span><span class="p">)</span> <span class="c1">#=> ["foo.c", "bar.c"]</span>
</code></pre> Ruby master - Feature #12125: Proposal: Shorthand operator for Object#methodhttps://redmine.ruby-lang.org/issues/12125?journal_id=572092016-02-29T16:40:57Zfunny_falcon (Yura Sokolov)funny.falcon@gmail.com
<ul></ul><p>Please don't do this!!! No need to make the language more complex just to solve such small issue!!!</p>
<p>If you want to do something pretty, then whole closure syntax should be simplified, not just call to '#method'.</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="no">Dir</span><span class="p">[</span><span class="s2">"*/*.c"</span><span class="p">].</span><span class="nf">map</span><span class="p">{</span><span class="no">File</span><span class="p">.</span><span class="nf">basename</span><span class="p">(</span><span class="n">_0</span><span class="p">)}</span> <span class="c1"># where `_0` is magic var</span>
</code></pre>
<p>Then bytecode compiler may optimize it to <code>.map(&File.method(:basename))</code></p>
<p>But it then allows to do more pretty things, for example:</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="c1"># dumps key=>value pairs</span>
<span class="n">myhash</span><span class="p">.</span><span class="nf">each</span><span class="p">{</span><span class="o">|</span><span class="n">k</span><span class="p">,</span><span class="n">v</span><span class="o">|</span> <span class="nb">puts</span> <span class="s2">"</span><span class="si">#{</span><span class="n">k</span><span class="si">}</span><span class="s2">=></span><span class="si">#{</span><span class="n">v</span><span class="si">}</span><span class="s2">"</span><span class="p">}</span>
<span class="c1"># do it in shorter way</span>
<span class="n">myhash</span><span class="p">.</span><span class="nf">each</span><span class="p">{</span><span class="nb">puts</span> <span class="s2">"</span><span class="si">#{</span><span class="n">_0</span><span class="si">}</span><span class="s2">=></span><span class="si">#{</span><span class="n">_1</span><span class="si">}</span><span class="s2">"</span><span class="p">}</span>
</code></pre> Ruby master - Feature #12125: Proposal: Shorthand operator for Object#methodhttps://redmine.ruby-lang.org/issues/12125?journal_id=572162016-02-29T20:40:19Zshevegen (Robert A. Heiler)shevegen@gmail.com
<ul></ul><p>I think the <code>&File->basename</code> looks confusing since we also have<br>
<code>-></code> standalone now.</p>
<p><code>object->method</code> reminds me a lot of php/perl and ruby uses the<br>
prettier <code>.</code> instead, <code>object.method</code>.</p>
<p>I also think that :</p>
<pre><code class="ruby syntaxhl" data-language="ruby"> <span class="p">.</span><span class="nf">map</span><span class="p">{</span><span class="no">File</span><span class="p">.</span><span class="nf">basename</span><span class="p">(</span><span class="n">_0</span><span class="p">)}</span> <span class="c1"># where `_0` is magic var</span>
</code></pre>
<p>Is not good either. I like <code>_</code> as a variable name a lot but on<br>
its own, not with extra. :)</p>
<p>Yuki Kurihara's proposal is somewhat better as he does not<br>
have to use special constructs/tokens.</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="no">Dir</span><span class="p">[</span><span class="s2">"*/*.c"</span><span class="p">].</span><span class="nf">map</span><span class="p">(</span><span class="o">&</span><span class="no">File</span><span class="p">.</span><span class="nf">method</span><span class="p">.</span><span class="nf">basename</span><span class="p">)</span>
</code></pre>
<p>I believe that crystal allows some parameter for <code>&</code>; and I think<br>
there have been earlier proposals in ruby too.</p>
<blockquote>
<p>But I think it makes sense: You have an object, and from that<br>
object you point at a method to get it as <code>Method</code>.</p>
</blockquote>
<p>I do not think that this argument is a good one because the <code>-></code><br>
is used in a dissimilar way, akin to <code>Proc.new</code> / <code>lambda</code>,<br>
whereas your syntax proposal would be more similar to php<br>
and perl syntax style, which I think will be confusing in<br>
addition to <code>-></code> already having another method. So this is<br>
not good in my opinion.</p> Ruby master - Feature #12125: Proposal: Shorthand operator for Object#methodhttps://redmine.ruby-lang.org/issues/12125?journal_id=572232016-03-01T02:23:44Znobu (Nobuyoshi Nakada)nobu@ruby-lang.org
<ul></ul><p>Stefan Merettig wrote:</p>
<blockquote>
<ul>
<li>Using <code>.></code>: <code>the_object.>a_method</code>
</li>
<li>Using <code><..></code>: <code>the_object<a_method></code>
</li>
</ul>
</blockquote>
<p>These two conflict with existing syntax and break compatibility.<br>
Note that <code>object.>(other)</code> is a valid method call.</p> Ruby master - Feature #12125: Proposal: Shorthand operator for Object#methodhttps://redmine.ruby-lang.org/issues/12125?journal_id=572242016-03-01T02:24:40Znobu (Nobuyoshi Nakada)nobu@ruby-lang.org
<ul><li><strong>Description</strong> updated (<a title="View differences" href="/journals/57224/diff?detail_id=40379">diff</a>)</li></ul> Ruby master - Feature #12125: Proposal: Shorthand operator for Object#methodhttps://redmine.ruby-lang.org/issues/12125?journal_id=574152016-03-14T01:42:55Zjwmittag (Jörg W Mittag)Ruby-Lang@JoergWMittag.De
<ul></ul><p>A proposal that has existed for years, if not decades, is to deprecate usage of the <code>::</code> double colon binary infix namespace operator for message sends, and instead re-use it for method references:</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="no">Dir</span><span class="p">[</span><span class="s2">"*/*.c"</span><span class="p">].</span><span class="nf">map</span><span class="p">(</span><span class="o">&</span><span class="no">File</span><span class="o">::</span><span class="n">basename</span><span class="p">)</span>
</code></pre>
<p>This is also the syntax chosen by Java for method references.</p>
<p>There is one big problem, though: ambiguity with constant references for methods which start with an uppercase letter. Maybe, it would be possible to require parentheses in that case?</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="sx">%w[1 2 3]</span><span class="p">.</span><span class="nf">map</span><span class="p">(</span><span class="o">&::</span><span class="no">Integer</span><span class="p">())</span>
</code></pre> Ruby master - Feature #12125: Proposal: Shorthand operator for Object#methodhttps://redmine.ruby-lang.org/issues/12125?journal_id=574162016-03-14T01:44:23Zjwmittag (Jörg W Mittag)Ruby-Lang@JoergWMittag.De
<ul></ul><p>It would be nice if we could find symmetric syntax for getting an <code>UnboundMethod</code> from a module.</p> Ruby master - Feature #12125: Proposal: Shorthand operator for Object#methodhttps://redmine.ruby-lang.org/issues/12125?journal_id=574192016-03-14T16:46:35Zmame (Yusuke Endoh)mame@ruby-lang.org
<ul><li><strong>File</strong> <a href="/attachments/5834">dot-symbol.patch</a> <a class="icon-only icon-download" title="Download" href="/attachments/download/5834/dot-symbol.patch">dot-symbol.patch</a> added</li></ul><p>+1 for this proposal. How about <code>recv.:fname</code>?</p>
<pre><code>$ ./miniruby -e 'p Dir["*/*.c"].map(&File.:basename)'
["hypot.c", "memcmp.c", "erf.c", ...]
</code></pre>
<p>Fortunately, it brings no conflict.</p>
<p>A patch is attached. (dot-symbol.patch)</p>
<p>--<br>
Yusuke Endoh <a href="mailto:mame@ruby-lang.org" class="email">mame@ruby-lang.org</a></p> Ruby master - Feature #12125: Proposal: Shorthand operator for Object#methodhttps://redmine.ruby-lang.org/issues/12125?journal_id=574362016-03-15T01:35:44Znobu (Nobuyoshi Nakada)nobu@ruby-lang.org
<ul></ul><p>Yusuke Endoh wrote:</p>
<blockquote>
<p>+1 for this proposal. How about <code>recv.:fname</code>?</p>
</blockquote>
<p><code>dot_or_colon</code> means that <code>File:::basename</code> also works?</p> Ruby master - Feature #12125: Proposal: Shorthand operator for Object#methodhttps://redmine.ruby-lang.org/issues/12125?journal_id=574432016-03-15T03:41:01Zmame (Yusuke Endoh)mame@ruby-lang.org
<ul></ul><p>Nobuyoshi Nakada wrote:</p>
<blockquote>
<p>Yusuke Endoh wrote:</p>
<blockquote>
<p>+1 for this proposal. How about <code>recv.:fname</code>?</p>
</blockquote>
<p><code>dot_or_colon</code> means that <code>File:::basename</code> also works?</p>
</blockquote>
<p>Yes it works. But I don't think it is important. Only <code>.:</code> is also okay to me.</p>
<p>--<br>
Yusuke Endoh <a href="mailto:mame@ruby-lang.org" class="email">mame@ruby-lang.org</a></p> Ruby master - Feature #12125: Proposal: Shorthand operator for Object#methodhttps://redmine.ruby-lang.org/issues/12125?journal_id=574722016-03-15T19:56:28ZPapierkorb (Stefan Merettig)
<ul></ul><p>Yusuke Endoh wrote:</p>
<blockquote>
<p>Nobuyoshi Nakada wrote:</p>
<blockquote>
<p>Yusuke Endoh wrote:</p>
<blockquote>
<p>+1 for this proposal. How about <code>recv.:fname</code>?</p>
</blockquote>
<p><code>dot_or_colon</code> means that <code>File:::basename</code> also works?</p>
</blockquote>
<p>Yes it works. But I don't think it is important. Only <code>.:</code> is also okay to me.</p>
</blockquote>
<p>The tetris-operator <code>.:</code> makes sense to me, but in respect to <code>:::</code> I don't think we should allow "alternative" operators to do the same thing.</p> Ruby master - Feature #12125: Proposal: Shorthand operator for Object#methodhttps://redmine.ruby-lang.org/issues/12125?journal_id=574732016-03-15T20:06:34Zfunny_falcon (Yura Sokolov)funny.falcon@gmail.com
<ul></ul><p>-1000</p>
<p>Please, don't!!!</p>
<p>I don't wonna Ruby to become Perl!!!</p>
<p>No more unnecessary syntax!!!</p>
<p>You all are not so weak! you are strong humans!!</p>
<p>You just can type a bit more characters!!!</p> Ruby master - Feature #12125: Proposal: Shorthand operator for Object#methodhttps://redmine.ruby-lang.org/issues/12125?journal_id=574882016-03-16T08:57:04Zhanachin (Seiei Miyagi)hanachin@gmail.com
<ul></ul><p>How about <code>File[.basename]</code> ?</p> Ruby master - Feature #12125: Proposal: Shorthand operator for Object#methodhttps://redmine.ruby-lang.org/issues/12125?journal_id=575172016-03-17T06:07:46Zshyouhei (Shyouhei Urabe)shyouhei@ruby-lang.org
<ul></ul><p>Just a status update: I heard from Matz in this month's developer meeting that however he wants this, all proposed syntax so far didn't charm him.</p> Ruby master - Feature #12125: Proposal: Shorthand operator for Object#methodhttps://redmine.ruby-lang.org/issues/12125?journal_id=575262016-03-17T07:48:00Znobu (Nobuyoshi Nakada)nobu@ruby-lang.org
<ul></ul><p>Seiei Miyagi wrote:</p>
<blockquote>
<p>How about <code>File[.basename]</code> ?</p>
</blockquote>
<p>It causes confusion if the receiver has <code>#[]</code> method.</p> Ruby master - Feature #12125: Proposal: Shorthand operator for Object#methodhttps://redmine.ruby-lang.org/issues/12125?journal_id=575592016-03-17T19:52:06ZVeryBewitching (RP C)
<ul></ul><p>Stefan Merettig wrote:</p>
<blockquote>
<p>Hello,</p>
<p>The <code>&</code> operator lets one pass a <code>#call</code>-able object as block.</p>
<p>Really useful feature, but at the moment, if you want to pass a <code>Method</code> this way the syntax is not really concise:</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="no">Dir</span><span class="p">[</span><span class="s2">"*/*.c"</span><span class="p">].</span><span class="nf">map</span><span class="p">(</span><span class="o">&</span><span class="no">File</span><span class="p">.</span><span class="nf">method</span><span class="p">(</span><span class="ss">:basename</span><span class="p">))</span>
</code></pre>
<p>More often than not, at least I end up writing this instead <code>.map{|a| File.basename a}</code> which isn't that great either.</p>
<p>Thus, I want to propose adding a short-hand operator to the ruby language, which simply calls <code>#method</code> on an <code>Object</code>.</p>
<p>It could look like this: <code>an_object->the_method</code> which is 100% equivalent to doing <code>an_object.method(:the_method)</code></p>
<p>I'm reusing the <code>-></code> operator which is already used for the stabby lambda. But I think it makes sense: You have an object,<br>
and from that object you point at a method to get it as <code>Method</code>.</p>
<p>With this, the example from above becomes: <code>Dir["*/*.c"].map(&File->basename)</code></p>
<p>I attached a proof of concept patch. When you apply this to trunk, you can try the example above yourself.<br>
Do note however that this PoC also breaks stabby lambda for the moment. I'll work on fixing that the following<br>
days.</p>
<p>Thank you for reading,<br>
Stefan.</p>
</blockquote>
<p>Dir["<em>/</em>.c"].map(File[&:basename])</p>
<p>From File, employ basename method. The referencing & should be applied to the method, not the class, as it is really the method you're concerned with. I'm not a language designer, but this is how I would <em>expect</em> this to work by looking at it.</p> Ruby master - Feature #12125: Proposal: Shorthand operator for Object#methodhttps://redmine.ruby-lang.org/issues/12125?journal_id=575602016-03-17T20:53:25ZVeryBewitching (RP C)
<ul></ul><p>Another thought: Dir["/.c"].map(File.&basename)</p> Ruby master - Feature #12125: Proposal: Shorthand operator for Object#methodhttps://redmine.ruby-lang.org/issues/12125?journal_id=669652017-09-28T12:07:44Zvassilevsky (Ilya Vassilevsky)vassilevsky@gmail.com
<ul></ul><p>Is it possible to use a single colon for this?</p>
<pre><code>object:name
File:basename
URI:parse
</code></pre>
<p>As far as I can see (not far, really, I don't even know C), it is currently not used for anything.</p> Ruby master - Feature #12125: Proposal: Shorthand operator for Object#methodhttps://redmine.ruby-lang.org/issues/12125?journal_id=669662017-09-28T13:23:45Znobu (Nobuyoshi Nakada)nobu@ruby-lang.org
<ul></ul><p>A colon does too many things already, a ternary operator, a symbol literal, and a keyword argument.</p> Ruby master - Feature #12125: Proposal: Shorthand operator for Object#methodhttps://redmine.ruby-lang.org/issues/12125?journal_id=669672017-09-28T13:32:16Znobu (Nobuyoshi Nakada)nobu@ruby-lang.org
<ul></ul><p><code>File[&:basename]</code> and <code>File.&basename</code> are valid syntax already.</p> Ruby master - Feature #12125: Proposal: Shorthand operator for Object#methodhttps://redmine.ruby-lang.org/issues/12125?journal_id=669842017-09-29T00:19:19Zk0kubun (Takashi Kokubun)takashikkbn@gmail.com
<ul><li><strong>Has duplicate</strong> <i><a class="issue tracker-2 status-5 priority-4 priority-default closed" href="/issues/13581">Feature #13581</a>: Syntax sugar for method reference</i> added</li></ul> Ruby master - Feature #12125: Proposal: Shorthand operator for Object#methodhttps://redmine.ruby-lang.org/issues/12125?journal_id=760222018-12-31T15:00:55Znobu (Nobuyoshi Nakada)nobu@ruby-lang.org
<ul><li><strong>Status</strong> changed from <i>Open</i> to <i>Closed</i></li></ul><p>Applied in changeset trunk|r66667.</p>
<hr>
<p>Method reference operator</p>
<p>Introduce the new operator for method reference, <code>.:</code>.<br>
[Feature <a class="issue tracker-2 status-1 priority-4 priority-default" title="Feature: Proposal: Shorthand operator for Object#method (Open)" href="https://redmine.ruby-lang.org/issues/12125">#12125</a>] [Feature <a class="issue tracker-2 status-5 priority-4 priority-default closed" title="Feature: Syntax sugar for method reference (Closed)" href="https://redmine.ruby-lang.org/issues/13581">#13581</a>]<br>
[EXPERIMENTAL]</p> Ruby master - Feature #12125: Proposal: Shorthand operator for Object#methodhttps://redmine.ruby-lang.org/issues/12125?journal_id=827352019-11-20T10:21:09Zznz (Kazuhiro NISHIYAMA)
<ul><li><strong>Related to</strong> <i><a class="issue tracker-2 status-5 priority-4 priority-default closed" href="/issues/16275">Feature #16275</a>: Revert `.:` syntax</i> added</li></ul> Ruby master - Feature #12125: Proposal: Shorthand operator for Object#methodhttps://redmine.ruby-lang.org/issues/12125?journal_id=910712021-03-24T23:58:08Zcvss (Kirill Vechera)cv-c@jetware.io
<ul></ul><p>Since the proposed feature was reverted in <a class="issue tracker-2 status-5 priority-4 priority-default closed" title="Feature: Revert `.:` syntax (Closed)" href="https://redmine.ruby-lang.org/issues/16275">#16275</a>, maybe this issue should be re-opened to continue discussion and "re-introduce with a big picture".</p>
<p>And I'd like add another perspective:</p>
<pre><code>upcased = somehash.each_pair.map{|key, value| [key.upcase, value.upcase]}.then(&Hash.:[])
</code></pre>
<p>instead of mixed chaining and parentheses</p>
<pre><code>upcased = Hash[somehash.each_pair.map{|key, value| [key.upcase, value.upcase]}]
</code></pre>
<p>or a bit ugly chaining with <code>#method</code></p>
<pre><code>upcased = somehash.each_pair.map{|key, value| [key.upcase, value.upcase]}.then(&Hash.method(:[]))
</code></pre> Ruby master - Feature #12125: Proposal: Shorthand operator for Object#methodhttps://redmine.ruby-lang.org/issues/12125?journal_id=910722021-03-25T02:26:49Znobu (Nobuyoshi Nakada)nobu@ruby-lang.org
<ul><li><strong>Status</strong> changed from <i>Closed</i> to <i>Open</i></li></ul><p>Re-opened as this feature has been reverted.</p> Ruby master - Feature #12125: Proposal: Shorthand operator for Object#methodhttps://redmine.ruby-lang.org/issues/12125?journal_id=910732021-03-25T06:32:00Zmarcandre (Marc-Andre Lafortune)marcandre-ruby-core@marc-andre.ca
<ul></ul><p>Since then, we have <code>_1</code>:</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="no">Dir</span><span class="p">[</span><span class="s2">"*/*.c"</span><span class="p">].</span><span class="nf">map</span><span class="p">{</span><span class="no">File</span><span class="p">.</span><span class="nf">basename</span><span class="p">(</span><span class="n">_1</span><span class="p">)}</span>
</code></pre>
<p>My understanding is that a syntax for method would also be less performant.</p>
<p><a class="user active user-mention" href="https://redmine.ruby-lang.org/users/9554">@cvss (Kirill Vechera)</a>' example with <code>Hash#[]</code> is not convincing as using <code>to_h</code> is simply better.</p> Ruby master - Feature #12125: Proposal: Shorthand operator for Object#methodhttps://redmine.ruby-lang.org/issues/12125?journal_id=910842021-03-25T14:55:06Zcvss (Kirill Vechera)cv-c@jetware.io
<ul></ul><p><a class="user active user-mention" href="https://redmine.ruby-lang.org/users/182">@marcandre (Marc-Andre Lafortune)</a>, comparing performance, the <code>#method</code> way is better:</p>
<p>The <code>map{File.basename(_1)}</code> code has two performance leaks: 1) it creates a new block to pass it to 'map', 2) this block looks up the <code>basename</code> method on each iteration</p>
<p>The <code>map(&File.method(:basename))</code> passes directly the method without creating an intermediate block and the <code>basename</code> is looked up only once while expanding the argument of <code>map</code>.</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="n">a</span> <span class="o">=</span> <span class="p">[</span><span class="s1">'aa/bb'</span><span class="p">]</span><span class="o">*</span><span class="mi">10000</span>
<span class="no">Benchmark</span><span class="p">.</span><span class="nf">measure</span> <span class="p">{</span> <span class="mi">100</span><span class="p">.</span><span class="nf">times</span><span class="p">{</span> <span class="n">a</span><span class="p">.</span><span class="nf">map</span><span class="p">{</span><span class="o">|</span><span class="n">a</span><span class="o">|</span> <span class="no">File</span><span class="p">.</span><span class="nf">basename</span><span class="p">(</span><span class="n">a</span><span class="p">)}</span> <span class="p">}</span> <span class="p">}</span> <span class="c1"># 0.400000 0.000000 0.400000 ( 0.411006)</span>
<span class="no">Benchmark</span><span class="p">.</span><span class="nf">measure</span> <span class="p">{</span> <span class="mi">100</span><span class="p">.</span><span class="nf">times</span><span class="p">{</span> <span class="n">a</span><span class="p">.</span><span class="nf">map</span><span class="p">(</span><span class="o">&</span><span class="no">File</span><span class="p">.</span><span class="nf">method</span><span class="p">(</span><span class="ss">:basename</span><span class="p">))</span> <span class="p">}</span> <span class="p">}</span> <span class="c1"># 0.310000 0.010000 0.320000 ( 0.330659)</span>
</code></pre> Ruby master - Feature #12125: Proposal: Shorthand operator for Object#methodhttps://redmine.ruby-lang.org/issues/12125?journal_id=910862021-03-25T15:25:18Zcvss (Kirill Vechera)cv-c@jetware.io
<ul></ul><p>I agree, <code>to_h</code> is better, but for hashes only. When we have no such a shorthand with other classes or other constructors, we can:</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="n">some_even_set</span> <span class="o">=</span> <span class="n">some_array</span><span class="o">&</span><span class="p">.</span><span class="nf">select</span><span class="p">(</span><span class="o">&</span><span class="ss">:even?</span><span class="p">)</span><span class="o">&</span><span class="p">.</span><span class="nf">then</span><span class="p">(</span><span class="o">&</span><span class="no">Set</span><span class="o">.</span><span class="ss">:new</span><span class="p">)</span>
</code></pre>
<p>After writing some code in 2.7.0 with <code>.:</code> I feel that</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="nf">any?</span><span class="p">(</span><span class="o">&</span><span class="n">some_even_set</span><span class="o">.</span><span class="ss">:include?</span><span class="p">)</span>
</code></pre>
<p>is more clean than</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="nf">any?</span><span class="p">{</span><span class="o">|</span><span class="n">x</span><span class="o">|</span> <span class="n">some_even_set</span><span class="p">.</span><span class="nf">include?</span> <span class="n">x</span><span class="p">}</span>
<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="nf">any?</span><span class="p">{</span><span class="n">some_even_set</span><span class="p">.</span><span class="nf">include?</span> <span class="n">_1</span><span class="p">}</span>
</code></pre> Ruby master - Feature #12125: Proposal: Shorthand operator for Object#methodhttps://redmine.ruby-lang.org/issues/12125?journal_id=910872021-03-25T15:32:41Zmarcandre (Marc-Andre Lafortune)marcandre-ruby-core@marc-andre.ca
<ul></ul><p>cvss (Kirill Vechera) wrote in <a href="#note-31">#note-31</a>:</p>
<blockquote>
<p><a class="user active user-mention" href="https://redmine.ruby-lang.org/users/182">@marcandre (Marc-Andre Lafortune)</a>, comparing performance, the <code>#method</code> way is better:</p>
<p>The <code>map{File.basename(_1)}</code> code has two performance leaks: 1) it creates a new block to pass it to 'map', 2) this block looks up the <code>basename</code> method on each iteration</p>
</blockquote>
<p>My understanding is that 1) has no cost as the block is never captured 2) indeed plays a (small) role</p>
<blockquote>
<p>The <code>map(&File.method(:basename))</code> passes directly the method without creating an intermediate block and the <code>basename</code> is looked up only once while expanding the argument of <code>map</code>.</p>
</blockquote>
<p>Right, but there needs to be a <code>Method</code> object created, which is non negligible.</p>
<p>Using <code>benchmark-ips</code> improves the reliability. Here are the results I get:</p>
<pre><code># 10000 elements (as above):
method: 364.4 i/s
block: 322.4 i/s - 1.13x (± 0.00) slower
# 1000 elements:
method: 3624.2 i/s
block: 3212.6 i/s - same-ish: difference falls within error
# 100 elements:
method: 35250.7 i/s
block: 33684.3 i/s - same-ish: difference falls within error
# 10 elements:
block: 320628.1 i/s
method: 249288.9 i/s - 1.29x (± 0.00) slower
# 3 elements:
block: 956542.2 i/s
method: 477741.7 i/s - 2.00x (± 0.00) slower
</code></pre>
<p>I would venture to say that most loops are done with arrays much smaller than 1000 elements.</p>
<p>Here is the code I used:</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="n">gem</span> <span class="s1">'benchmark-ips'</span>
<span class="nb">require</span> <span class="s1">'benchmark/ips'</span>
<span class="p">[</span><span class="mi">10000</span><span class="p">,</span> <span class="mi">1000</span><span class="p">,</span> <span class="mi">100</span><span class="p">,</span> <span class="mi">10</span><span class="p">,</span> <span class="mi">3</span><span class="p">].</span><span class="nf">each</span> <span class="k">do</span> <span class="o">|</span><span class="n">n</span><span class="o">|</span>
<span class="n">a</span> <span class="o">=</span> <span class="p">[</span><span class="s1">'aa/bb'</span><span class="p">]</span><span class="o">*</span><span class="n">n</span>
<span class="nb">puts</span> <span class="s2">"</span><span class="si">#{</span><span class="n">n</span><span class="si">}</span><span class="s2"> elements"</span>
<span class="no">Benchmark</span><span class="p">.</span><span class="nf">ips</span> <span class="k">do</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">report</span><span class="p">(</span><span class="s1">'block'</span><span class="p">)</span> <span class="p">{</span>
<span class="n">a</span><span class="p">.</span><span class="nf">map</span><span class="p">{</span><span class="o">|</span><span class="n">a</span><span class="o">|</span> <span class="no">File</span><span class="p">.</span><span class="nf">basename</span><span class="p">(</span><span class="n">a</span><span class="p">)</span> <span class="p">}</span>
<span class="p">}</span>
<span class="n">x</span><span class="p">.</span><span class="nf">report</span><span class="p">(</span><span class="s1">'method'</span><span class="p">)</span> <span class="p">{</span>
<span class="n">a</span><span class="p">.</span><span class="nf">map</span><span class="p">(</span><span class="o">&</span><span class="no">File</span><span class="p">.</span><span class="nf">method</span><span class="p">(</span><span class="ss">:basename</span><span class="p">))</span>
<span class="p">}</span>
<span class="n">x</span><span class="p">.</span><span class="nf">compare!</span>
<span class="k">end</span>
<span class="k">end</span>
</code></pre> Ruby master - Feature #12125: Proposal: Shorthand operator for Object#methodhttps://redmine.ruby-lang.org/issues/12125?journal_id=910882021-03-25T15:37:28Zmarcandre (Marc-Andre Lafortune)marcandre-ruby-core@marc-andre.ca
<ul></ul><p><a class="user active user-mention" href="https://redmine.ruby-lang.org/users/9554">@cvss (Kirill Vechera)</a>, your two other examples are also not convincing. Here is how one can write them:</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="n">some_even_set</span> <span class="o">=</span> <span class="n">some_array</span><span class="p">.</span><span class="nf">select</span><span class="p">(</span><span class="o">&</span><span class="ss">:even?</span><span class="p">).</span><span class="nf">to_set</span>
<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="nf">any?</span><span class="p">(</span><span class="n">some_even_set</span><span class="p">)</span>
</code></pre> Ruby master - Feature #12125: Proposal: Shorthand operator for Object#methodhttps://redmine.ruby-lang.org/issues/12125?journal_id=945182021-11-08T18:13:25ZAzuma-01 (Azuma Eleth)
<ul></ul><p>Hello,<br>
I cannot help myself to see than all proposal are of the form:<br>
<code> (expression) (shorthand_operator) (method_name)</code></p>
<p>while I had seen some interesting option, to me, that format seem to add an obsure behaviour rater than a shorthand.<br>
Personaly, when i mix the words 'Ruby' and 'shorthand', i see %string<br>
%i, %q, %r, %s, %w, %x</p>
<p>Why not adding %m to the party? something like<br>
<code> %m{(expression)(space)(method_name)}</code><br>
That should not be to hard to idantify and translate to<br>
<code> (expression).method(:method_name)</code><br>
If there is no expression, we assume the value self</p>
<pre><code class="ruby syntaxhl" data-language="ruby"> <span class="o">%</span><span class="n">m</span><span class="o"><</span><span class="no">Math</span> <span class="n">sqrt</span><span class="o">></span> <span class="c1">#=> #<Method: Math.sqrt></span>
<span class="o">%</span><span class="n">m</span><span class="p">(</span><span class="n">foo</span><span class="p">.</span><span class="nf">bar</span><span class="p">.</span><span class="nf">baz</span> <span class="n">something</span><span class="p">)</span> <span class="c1">#=> #<Method: Baz#something></span>
<span class="o">%</span><span class="n">m</span><span class="ss">:to_s</span><span class="p">:</span> <span class="c1">#=> #<Method: main.to_s()></span>
<span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">4</span><span class="p">,</span> <span class="mi">9</span><span class="p">,</span> <span class="mi">16</span><span class="p">,</span> <span class="mi">25</span><span class="p">].</span><span class="nf">map</span><span class="p">(</span><span class="o">&</span> <span class="o">%</span><span class="n">m</span><span class="s2">"Math sqrt"</span><span class="p">)</span> <span class="c1">#=> [1.0, 2.0, 3.0, 4.0, 5.0]</span>
</code></pre>
<p>To enable meta-programming, it can be done the same way than all others %string does it...<br>
with an upper case version.</p>
<pre><code class="ruby syntaxhl" data-language="ruby"> <span class="n">x</span> <span class="o">=</span> <span class="o">::</span><span class="no">Kernel</span><span class="p">.</span><span class="nf">gets</span><span class="p">.</span><span class="nf">chomp</span>
<span class="o">%</span><span class="no">M</span><span class="p">[</span><span class="no">MyModule</span> <span class="c1">#{x}]</span>
</code></pre>
<p>In that form, the question I ask myself is if the method_name should be an explicit symbol or not. The above exemple assume it dose not.</p> Ruby master - Feature #12125: Proposal: Shorthand operator for Object#methodhttps://redmine.ruby-lang.org/issues/12125?journal_id=950302021-12-02T14:00:33Zcvss (Kirill Vechera)cv-c@jetware.io
<ul></ul><p>One more use case - method composition, for example from <a class="issue tracker-2 status-1 priority-4 priority-default" title="Feature: users.detect(:name, "Dorian") as shorthand for users.detect { |user| user.name == "Dorian" } (Open)" href="https://redmine.ruby-lang.org/issues/18369">#18369</a>:</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="n">collection</span><span class="p">.</span><span class="nf">detect</span><span class="p">(</span><span class="o">&</span><span class="ss">:first_name</span><span class="o">>></span><span class="s2">"Dorian"</span><span class="o">.</span><span class="ss">:==</span><span class="p">)</span>
</code></pre> Ruby master - Feature #12125: Proposal: Shorthand operator for Object#methodhttps://redmine.ruby-lang.org/issues/12125?journal_id=958362022-01-07T18:23:46Zkonsolebox (K B)
<ul></ul><p>Has <code>&&</code> been considered?</p>
<pre><code>Dir["*/*.c"].map(&&File.basename)
</code></pre>
<p>It can also adapt to outside usage so <code>&File.basename</code> equals <code>File.method(:basename)</code>.</p>