https://redmine.ruby-lang.org/https://redmine.ruby-lang.org/favicon.ico?17113305112017-05-19T13:37:39ZRuby Issue Tracking SystemRuby master - Feature #13581: Syntax sugar for method referencehttps://redmine.ruby-lang.org/issues/13581?journal_id=649482017-05-19T13:37:39ZHanmac (Hans Mackowiak)hanmac@gmx.de
<ul></ul><p>that might collide with <code>-> {}</code> a lambda syntax<br>
so i think the chances are low that ruby gets something like that.</p>
<p>so ruby probably does think its "<code>Math(->sqrt)</code>" and thats a Syntax error.</p> Ruby master - Feature #13581: Syntax sugar for method referencehttps://redmine.ruby-lang.org/issues/13581?journal_id=649522017-05-19T14:16:10Zamericodls (Americo Duarte)
<ul></ul><p>The <strong><code>-></code></strong> was just a suggestion... Could be another symbol or combination of symbols like <strong><code>Math->>sqrt</code></strong>, <strong><code>Math=>>sqrt</code></strong>, <strong><code>Math+>sqrt</code></strong>, <strong><code>Math$>sqrt</code></strong>, <strong><code>Math:>sqrt</code></strong>, etc<br>
I just think could have another way to write it than not a method calling with a symbol as argument, something more concise and expressive.</p>
<p>Hanmac (Hans Mackowiak) wrote:</p>
<blockquote>
<p>that might collide with -> {} a lambda syntax<br>
so i think the chances are low that ruby gets something like that.</p>
<p>so ruby probably does think its "Math(->sqrt)" and thats a Syntax error.</p>
</blockquote> Ruby master - Feature #13581: Syntax sugar for method referencehttps://redmine.ruby-lang.org/issues/13581?journal_id=649532017-05-19T14:43:07ZHanmac (Hans Mackowiak)hanmac@gmx.de
<ul></ul><p>my current thinking is if that short form should do symbol support.</p>
<p>if <code>Math->sym</code> should be supported, than the normal variant need to be <code>Math->:sqrt</code></p>
<p>i currently think if we also could abuse the call method.</p>
<p>so we could harness "<code>Math.(:sqrt)</code>" into something.</p> Ruby master - Feature #13581: Syntax sugar for method referencehttps://redmine.ruby-lang.org/issues/13581?journal_id=649692017-05-20T00:27:24Zamericodls (Americo Duarte)
<ul></ul><p>Why the version with symbol (<code>Math->:sqrt</code>) needs to be supported?</p> Ruby master - Feature #13581: Syntax sugar for method referencehttps://redmine.ruby-lang.org/issues/13581?journal_id=663662017-08-31T06:31:02Zmatz (Yukihiro Matsumoto)matz@ruby.or.jp
<ul></ul><p>I am for adding syntax sugar for method reference. But I don't like proposed syntax (e.g. <code>-></code>).<br>
Any other idea?</p>
<p>Matz.</p> Ruby master - Feature #13581: Syntax sugar for method referencehttps://redmine.ruby-lang.org/issues/13581?journal_id=663962017-08-31T08:48:49Znobu (Nobuyoshi Nakada)nobu@ruby-lang.org
<ul></ul><p><code>obj\.method</code></p> Ruby master - Feature #13581: Syntax sugar for method referencehttps://redmine.ruby-lang.org/issues/13581?journal_id=664012017-08-31T10:10:08ZHanmac (Hans Mackowiak)hanmac@gmx.de
<ul></ul><p>nobu (Nobuyoshi Nakada) wrote:</p>
<blockquote>
<p><code>obj\.method</code></p>
</blockquote>
<p>i am not sure about that:</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="n">obj</span><span class="p">\</span>
<span class="p">.</span><span class="nf">method</span>
</code></pre>
<p>is already valid ruby code, so i am not sure</p>
<p>PS: when using "<code>&obj.method(:symbol)</code>" should that be optimized if able?</p> Ruby master - Feature #13581: Syntax sugar for method referencehttps://redmine.ruby-lang.org/issues/13581?journal_id=664042017-08-31T12:10:55Zzverok (Victor Shepelev)zverok.offline@gmail.com
<ul></ul><blockquote>
<p>I am for adding syntax sugar for method reference. But I don't like proposed syntax (e.g. ->).<br>
Any other idea?</p>
</blockquote>
<p>In my pet projects, I often alias <code>method</code> as <code>m</code>. It is readable enough, short enough and easy to remember, once you've seen it:</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="n">roots</span> <span class="o">=</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="nf">map</span><span class="p">(</span><span class="o">&</span><span class="no">Math</span><span class="p">.</span><span class="nf">m</span><span class="p">(</span><span class="ss">:sqrt</span><span class="p">))</span>
<span class="sx">%w[foo bar baz]</span><span class="p">.</span><span class="nf">each</span><span class="p">(</span><span class="o">&</span><span class="n">m</span><span class="p">(</span><span class="ss">:puts</span><span class="p">))</span>
</code></pre>
<p>..., and, if introduced into language core, can be easily backported to earlier versions (through something like <code>backports</code> or <code>polyfill</code> gem).</p>
<p>Another weird-ish idea, following the first one closely, is <code>.:</code>, which (for me) looks guessable:</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">map</span><span class="p">(</span><span class="o">&</span><span class="no">Math</span><span class="o">.</span><span class="ss">:sqrt</span><span class="p">)</span>
<span class="sx">%w[foo bar baz]</span><span class="p">.</span><span class="nf">each</span><span class="p">(</span><span class="o">&.</span><span class="ss">:puts</span><span class="p">)</span>
</code></pre>
<p>(BTW, object-less form should also be considered, when weighing proposals, don't you think?)</p> Ruby master - Feature #13581: Syntax sugar for method referencehttps://redmine.ruby-lang.org/issues/13581?journal_id=664052017-08-31T12:30:04Zk0kubun (Takashi Kokubun)takashikkbn@gmail.com
<ul></ul><p>Another idea: <code>&obj:method</code></p>
<p>It just puts receiver between <code>&</code> and <code>:</code> from existing one. I'm not sure it conflicts with existing syntax or not but I feel it's consistent with <code>&:foo</code> syntax.</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="n">roots</span> <span class="o">=</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="nf">map</span><span class="p">(</span><span class="o">&</span><span class="no">Math</span><span class="ss">:sqrt</span><span class="p">)</span>
<span class="sx">%w[foo bar baz]</span><span class="p">.</span><span class="nf">each</span><span class="p">(</span><span class="o">&</span><span class="nb">self</span><span class="ss">:puts</span><span class="p">)</span>
</code></pre> Ruby master - Feature #13581: Syntax sugar for method referencehttps://redmine.ruby-lang.org/issues/13581?journal_id=664062017-08-31T12:56:32ZHanmac (Hans Mackowiak)hanmac@gmx.de
<ul></ul><p>k0kubun (Takashi Kokubun) wrote:</p>
<blockquote>
<p>Another idea: <code>&obj:method</code></p>
</blockquote>
<p>hm i like that idea, but think that might be a bit conflicting, that depends on if obj is an object or not?</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><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="n">obj</span><span class="ss">:method</span> <span class="c1">#=> syntax error</span>
</code></pre>
<p>but notice that: (xyz not known)</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="n">xyz</span><span class="ss">:method</span> <span class="c1">#=> undefined method 'xyz' for main</span>
</code></pre>
<p>it thinks that it's <code>xyz(:method)</code></p> Ruby master - Feature #13581: Syntax sugar for method referencehttps://redmine.ruby-lang.org/issues/13581?journal_id=664082017-08-31T13:12:38Zk0kubun (Takashi Kokubun)takashikkbn@gmail.com
<ul></ul><p>Oh, I'm so sad to hear <code>obj:method</code> (without <code>&</code>) is already valid. I still have hope to have it only when it's put with <code>&</code> in the last of arguments because that case is not valid for now.</p>
<pre><code>irb(main):001:0> def obj(method); method; end
=> :obj
irb(main):002:0> obj:method
=> :method
irb(main):003:0> obj(&obj:method)
SyntaxError: (irb):3: syntax error, unexpected tSYMBEG, expecting keyword_do or '{' or '('
obj(&obj:method)
^
from /home/k0kubun/.rbenv/versions/2.4.1/bin/irb:11:in `<main>'
irb(main):004:0> obj(&(obj:method))
SyntaxError: (irb):4: syntax error, unexpected tLABEL
obj(&(obj:method))
^
from /home/k0kubun/.rbenv/versions/2.4.1/bin/irb:11:in `<main>'
irb(main):005:0> obj &obj:method
SyntaxError: (irb):5: syntax error, unexpected tSYMBEG, expecting keyword_do or '{' or '('
obj &obj:method
^
from /home/k0kubun/.rbenv/versions/2.4.1/bin/irb:11:in `<main>'
irb(main):006:0> obj &(obj:method)
SyntaxError: (irb):6: syntax error, unexpected tLABEL
obj &(obj:method)
^
from /home/k0kubun/.rbenv/versions/2.4.1/bin/irb:11:in `<main>'
</code></pre>
<p>I've never seen a person who writes <code>a(:b)</code> as <code>a:b</code> (without space or parenthesis before "<code>:</code>") and personally I don't expect <code>&a:b</code> to be <code>&a(:b)</code>.</p> Ruby master - Feature #13581: Syntax sugar for method referencehttps://redmine.ruby-lang.org/issues/13581?journal_id=664102017-08-31T14:27:53Znobu (Nobuyoshi Nakada)nobu@ruby-lang.org
<ul></ul><p>Hanmac (Hans Mackowiak) wrote:</p>
<blockquote>
<p>i am not sure about that:</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="n">obj</span><span class="p">\</span>
<span class="p">.</span><span class="nf">method</span>
</code></pre>
<p>is already valid ruby code, so i am not sure</p>
</blockquote>
<p>It's different at all.<br>
My example is a token <code>\.</code>, do not split.</p>
<blockquote>
<p>PS: when using "&obj.method(:symbol)" should that be optimized if able?</p>
</blockquote>
<p>Probably, but it's not possible to guarantee that it will return the method object.</p> Ruby master - Feature #13581: Syntax sugar for method referencehttps://redmine.ruby-lang.org/issues/13581?journal_id=664112017-08-31T14:31:40Znobu (Nobuyoshi Nakada)nobu@ruby-lang.org
<ul></ul><p>k0kubun (Takashi Kokubun) wrote:</p>
<blockquote>
<p>Another idea: <code>&obj:method</code></p>
</blockquote>
<p>Consider more complex example, <code>&(obj.some.method(args)):method</code>, not only a simple reciever.<br>
<code>&</code> and <code>:</code> are separated too far.</p> Ruby master - Feature #13581: Syntax sugar for method referencehttps://redmine.ruby-lang.org/issues/13581?journal_id=664122017-08-31T14:51:33ZHanmac (Hans Mackowiak)hanmac@gmx.de
<ul></ul><p>my idea for optimising <code>&obj.method(:symbol)</code><br>
is that it already creates a proc (object) without going over a <code>Method</code> object,<br>
i don't know if that would be an good idea for that.</p> Ruby master - Feature #13581: Syntax sugar for method referencehttps://redmine.ruby-lang.org/issues/13581?journal_id=664202017-09-01T00:56:22Zmrkn (Kenta Murata)muraken@gmail.com
<ul></ul><p>How about <code>obj.{method_name}</code> for the syntax sugar of <code>obj.method(:method_name)</code>?</p> Ruby master - Feature #13581: Syntax sugar for method referencehttps://redmine.ruby-lang.org/issues/13581?journal_id=664352017-09-01T06:15:32Zzverok (Victor Shepelev)zverok.offline@gmail.com
<ul></ul><p>Another pretty unholy idea: resemble the way Ruby docs document the methods:</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">map</span><span class="p">(</span><span class="o">&</span><span class="no">Math</span><span class="c1">#sqrt)</span>
<span class="sx">%w[foo bar baz]</span><span class="p">.</span><span class="nf">each</span><span class="p">(</span><span class="o">&</span><span class="c1">#puts)</span>
</code></pre>
<p>Yes, it conflicts with comment syntax, but in fact, no sane person should join the comment sign immediately after non-space symbol.</p>
<p>And we already have parsing ambiguities like this:</p>
<ul>
<li>
<code>foo -bar</code> → <code>foo(-bar)</code>;</li>
<li>
<code>foo - bar</code> → <code>foo.-(bar)</code>.</li>
</ul> Ruby master - Feature #13581: Syntax sugar for method referencehttps://redmine.ruby-lang.org/issues/13581?journal_id=664362017-09-01T06:36:25Ztom_dalling (Tom Dalling)
<ul></ul><p>What about triple colon <code>:::</code>?</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">map</span><span class="p">(</span><span class="o">&</span><span class="no">Math</span><span class="o">::</span><span class="ss">:sqrt</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">each</span><span class="p">(</span><span class="o">&::</span><span class="ss">:puts</span><span class="p">)</span>
</code></pre>
<p><code>::</code> is for looking up constants, so it kind of makes sense that <code>:::</code> is for looking up methods.</p> Ruby master - Feature #13581: Syntax sugar for method referencehttps://redmine.ruby-lang.org/issues/13581?journal_id=664372017-09-01T08:30:53Ztom-lord (Tom Lord)lord.thom@gmail.com
<ul></ul><p>Consider the following:</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="k">def</span> <span class="nf">get_method</span><span class="p">(</span><span class="n">sym</span><span class="p">,</span> <span class="n">object</span> <span class="o">=</span> <span class="no">Object</span><span class="p">)</span>
<span class="n">object</span><span class="p">.</span><span class="nf">send</span><span class="p">(</span><span class="ss">:method</span><span class="p">,</span> <span class="n">sym</span><span class="p">)</span>
<span class="k">end</span>
</code></pre>
<p>This allows us to write code like:</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">4</span><span class="p">,</span> <span class="mi">9</span><span class="p">].</span><span class="nf">map</span> <span class="o">&</span><span class="n">get_method</span><span class="p">(</span><span class="ss">:sqrt</span><span class="p">,</span> <span class="no">Math</span><span class="p">)</span>
</code></pre>
<p>So as an idea, how about introducing some syntax sugar for the above - such as:</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">4</span><span class="p">,</span> <span class="mi">9</span><span class="p">].</span><span class="nf">map</span> <span class="o">&~></span><span class="p">(</span><span class="ss">:sqrt</span><span class="p">,</span> <span class="no">Math</span><span class="p">)</span>
</code></pre>
<p>Where in general, <code>~></code> (or whatever) could be the "method lookup operator".</p>
<p>For example, this would yield:</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="o">~></span><span class="p">(</span><span class="ss">:puts</span><span class="p">)</span> <span class="c1"># => #<Method: Class(Kernel)#puts></span>
<span class="o">~></span><span class="p">(</span><span class="ss">:sqrt</span><span class="p">,</span> <span class="no">Math</span><span class="p">)</span> <span class="c1"># => #<Method: Math.sqrt></span>
<span class="o">~></span><span class="p">(</span><span class="ss">:sqrt</span><span class="p">)</span> <span class="c1"># => NameError: undefined method `sqrt' for class `#<Class:Object>'</span>
</code></pre> Ruby master - Feature #13581: Syntax sugar for method referencehttps://redmine.ruby-lang.org/issues/13581?journal_id=669832017-09-29T00:19:19Zk0kubun (Takashi Kokubun)takashikkbn@gmail.com
<ul><li><strong>Is duplicate of</strong> <i><a class="issue tracker-2 status-1 priority-4 priority-default" href="/issues/12125">Feature #12125</a>: Proposal: Shorthand operator for Object#method</i> added</li></ul> Ruby master - Feature #13581: Syntax sugar for method referencehttps://redmine.ruby-lang.org/issues/13581?journal_id=673232017-10-19T01:46:08Zamericodls (Americo Duarte)
<ul></ul><p>matz (Yukihiro Matsumoto) wrote:</p>
<blockquote>
<p>I am for adding syntax sugar for method reference. But I don't like proposed syntax (e.g. <code>-></code>).<br>
Any other idea?</p>
<p>Matz.</p>
</blockquote>
<p>What do you think about: <code>Kernel:puts</code>, <code>Kernel~>puts</code>, <code>Kernel:>puts</code> ?</p> Ruby master - Feature #13581: Syntax sugar for method referencehttps://redmine.ruby-lang.org/issues/13581?journal_id=697582018-01-24T09:49:40Zzverok (Victor Shepelev)zverok.offline@gmail.com
<ul></ul><p>Just to push this forward, here are all the syntaxes from this and duplicate <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>.<br>
I am taking <code>Math.sqrt</code> and <code>puts</code> as examples:</p>
<ul>
<li>
<code>map(&Math->sqrt)</code> (and just <code>each(&->puts)</code> probably?) -- Matz is explicitly against it;</li>
<li>
<code>map(&Math\.sqrt)</code> (not sure about puts);</li>
<li>
<code>map(&Math.m(:sqrt))</code>, <code>each(&m(:puts))</code> (just shortening, no language syntax change)</li>
<li>
<code>map(&Math.:sqrt)</code>, <code>each(&.:puts)</code>
</li>
<li>
<code>map(&Math:sqrt)</code>, <code>each(&self:puts)</code>
</li>
<li>
<code>map(&Math#sqrt)</code>, <code>each(&#puts)</code> (it was my proposal, "just how it looks in docs", but I should reconsider: in docs it is <code>Math::sqrt</code>, in fact)</li>
<li>
<code>map(&Math:::sqrt)</code>, <code>each(&:::puts)</code>
</li>
<li>
<code>map(&~>(:sqrt, Math)</code>), <code>each(&~>(:puts))</code>
</li>
<li>
<a href="https://bugs.ruby-lang.org/issues/12125#note-4" class="external">several</a> by <a class="user active user-mention" href="https://redmine.ruby-lang.org/users/10677">@Papierkorb (Stefan Merettig)</a>:
<ul>
<li>
<code>map(&Math.>sqrt)</code>, <code>each(&.>puts)</code> (<a class="user active user-mention" href="https://redmine.ruby-lang.org/users/4">@nobu (Nobuyoshi Nakada)</a>: conflicts with existing syntax)</li>
<li>
<code>map(&Math<sqrt>)</code>, <code>each(&<puts>)</code> (<a class="user active user-mention" href="https://redmine.ruby-lang.org/users/4">@nobu (Nobuyoshi Nakada)</a>: conflicts with existing syntax)</li>
<li>
<code>map(&Math&>sqrt)</code>, <code>each(&&>puts)</code>
</li>
<li>
<code>map(&Math|>sqrt)</code>, <code>each(&|>puts)</code> (too confusable with Elixir-like pipe, probably)</li>
</ul>
</li>
</ul>
<p>Can please please somebody lift this question to next Developer Meeting and make an Executive Decision?..</p>
<p>I personally really like <code>.:</code> (called "tetris operator" in other ticket).</p> Ruby master - Feature #13581: Syntax sugar for method referencehttps://redmine.ruby-lang.org/issues/13581?journal_id=697712018-01-24T14:48:48Zdsferreira (Daniel Ferreira)
<ul></ul><p>zverok (Victor Shepelev) wrote:</p>
<blockquote>
<p>map(&Math|>sqrt), each(&|>puts) (too confusable with Elixir-like pipe, probably)</p>
</blockquote>
<p>I tend to agree with that.<br>
In fact I was hoping to get the pipe operator introduced in ruby. (Created an issue with that in mind: <a href="https://bugs.ruby-lang.org/issues/14392" class="external">https://bugs.ruby-lang.org/issues/14392</a>).</p>
<p>Taking that pipe operator example as an operator that sends messages maybe we can use it to send a message to the class or module. Like this:</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="ss">:sqrt</span> <span class="o">|></span> <span class="no">Math</span>
</code></pre>
<p>Since <code>Math</code> is not a method the message would extract the method from the object.</p>
<p>If this is not practical maybe we could invert the operator and do:</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="no">Math</span> <span class="o"><|</span> <span class="ss">:sqrt</span>
</code></pre> Ruby master - Feature #13581: Syntax sugar for method referencehttps://redmine.ruby-lang.org/issues/13581?journal_id=698292018-01-25T12:23:43Znobu (Nobuyoshi Nakada)nobu@ruby-lang.org
<ul></ul><p>zverok (Victor Shepelev) wrote:</p>
<blockquote>
<ul>
<li>
<code>map(&Math.>sqrt)</code>, <code>each(&.>puts)</code>
</li>
</ul>
</blockquote>
<p>This conflicts with existing syntax.</p>
<blockquote>
<ul>
<li>
<code>map(&Math&>sqrt)</code>, <code>each(&&>puts)</code> (<a class="user active user-mention" href="https://redmine.ruby-lang.org/users/4">@nobu (Nobuyoshi Nakada)</a>: conflicts with existing syntax)</li>
</ul>
</blockquote>
<p>Not this.</p> Ruby master - Feature #13581: Syntax sugar for method referencehttps://redmine.ruby-lang.org/issues/13581?journal_id=698302018-01-25T12:31:39Zzverok (Victor Shepelev)zverok.offline@gmail.com
<ul></ul><p><a class="user active user-mention" href="https://redmine.ruby-lang.org/users/4">@nobu (Nobuyoshi Nakada)</a> Thanks, I've updated the list.</p>
<p>Can you please add it to next Developer Meeting's agenda?..</p> Ruby master - Feature #13581: Syntax sugar for method referencehttps://redmine.ruby-lang.org/issues/13581?journal_id=701152018-02-01T22:05:35Zmpapis (Michal Papis)mpapis@gmail.com
<ul></ul><p>Not sure it's worth it - but while we are at this thinking of a shorthand one of the proposals <code>&Math&>sqrt</code> made me think if it could be automated and all the iterators could recognize methods and we could avoid the initial <code>&</code> to this <code>map(Math...)</code> - skipped the operator as it's not clear what's preferred.</p>
<p>My two cents to the operator - what about <code>!</code> and <code>@</code> would they conflict? (yes for the Kernel, not sure about Class'es).</p> Ruby master - Feature #13581: Syntax sugar for method referencehttps://redmine.ruby-lang.org/issues/13581?journal_id=701162018-02-01T23:13:09Znobu (Nobuyoshi Nakada)nobu@ruby-lang.org
<ul></ul><p>mpapis (Michal Papis) wrote:</p>
<blockquote>
<p>Not sure it's worth it - but while we are at this thinking of a shorthand one of the proposals <code>&Math&>sqrt</code> made me think if it could be automated and all the iterators could recognize methods and we could avoid the initial <code>&</code> to this <code>map(Math...)</code> - skipped the operator as it's not clear what's preferred.</p>
</blockquote>
<p>It can't distinguish passing block and passing <code>Method</code> object.</p>
<blockquote>
<p>My two cents to the operator - what about <code>!</code> and <code>@</code> would they conflict? (yes for the Kernel, not sure about Class'es).</p>
</blockquote>
<p><code>Math!sqrt</code> and <code>Math@sqrt</code>?<br>
They are valid syntax now.</p>
<p>You can try with <code>ruby -c</code>.</p>
<pre><code>$ ruby -wc -e 'Math!sqrt'
Syntax OK
$ ruby -wc -e 'Math@sqrt'
Syntax OK
</code></pre>
<p>They are interpreted as a method call without a receiver, <code>Math(!sqrt)</code> and <code>Math(@sqrt)</code> respectively.</p> Ruby master - Feature #13581: Syntax sugar for method referencehttps://redmine.ruby-lang.org/issues/13581?journal_id=701182018-02-02T01:51:36Zduerst (Martin Dürst)duerst@it.aoyama.ac.jp
<ul></ul><p>nobu (Nobuyoshi Nakada) wrote:</p>
<blockquote>
<pre><code>$ ruby -wc -e 'Math!sqrt'
Syntax OK
$ ruby -wc -e 'Math@sqrt'
Syntax OK
</code></pre>
<p>They are interpreted as a method call without a receiver, <code>Math(!sqrt)</code> and <code>Math(@sqrt)</code> respectively.</p>
</blockquote>
<p>This may be just me, but I think this kind of syntax without spaces could (or even should) be depreciated.</p>
<p>That doesn't mean that for the purpose of this issue, I like <code>!</code> or <code>@</code>. But they might be usable for other purposes.</p> Ruby master - Feature #13581: Syntax sugar for method referencehttps://redmine.ruby-lang.org/issues/13581?journal_id=701192018-02-02T05:33:07Znobu (Nobuyoshi Nakada)nobu@ruby-lang.org
<ul></ul><p>duerst (Martin Dürst) wrote:</p>
<blockquote>
<p>This may be just me, but I think this kind of syntax without spaces could (or even should) be depreciated.</p>
</blockquote>
<p>It would hurt code-golfers and quine-makers. :)</p> Ruby master - Feature #13581: Syntax sugar for method referencehttps://redmine.ruby-lang.org/issues/13581?journal_id=701242018-02-02T08:20:20ZHanmac (Hans Mackowiak)hanmac@gmx.de
<ul></ul><p>Question for <a class="user active user-mention" href="https://redmine.ruby-lang.org/users/4">@nobu (Nobuyoshi Nakada)</a> :</p>
<p>i don't know about the rubyVM but can <code>xyz(&method(:symbol))</code> or <code>xyz(&obj.method(:symbol))</code> be optimized like <code>xyz(&:symbol)</code> is?<br>
the one with the Symbol was optimized to not create a Proc object if not needed.</p>
<p>can be something similar with the Method object? or if not overwritten maybe not even creating a Method object at all?</p> Ruby master - Feature #13581: Syntax sugar for method referencehttps://redmine.ruby-lang.org/issues/13581?journal_id=701262018-02-02T08:27:41Znobu (Nobuyoshi Nakada)nobu@ruby-lang.org
<ul></ul><p>Hanmac (Hans Mackowiak) wrote:</p>
<blockquote>
<p>i don't know about the rubyVM but can <code>xyz(&method(:symbol))</code> or <code>xyz(&obj.method(:symbol))</code> be optimized like <code>xyz(&:symbol)</code> is?</p>
</blockquote>
<p>They have different meanings all.</p>
<p><code>xyz(&method(:symbol))</code> == <code>xyz {|x| symbol(x)}</code><br>
<code>xyz(&obj.method(:symbol))</code> == <code>xyz {|x| obj.symbol(x)}</code><br>
<code>xyz(&:symbol)</code> == <code>xyz {|x| x.symbol}</code></p> Ruby master - Feature #13581: Syntax sugar for method referencehttps://redmine.ruby-lang.org/issues/13581?journal_id=701272018-02-02T08:37:13ZHanmac (Hans Mackowiak)hanmac@gmx.de
<ul></ul><p>nobu (Nobuyoshi Nakada) wrote:</p>
<blockquote>
<p>Hanmac (Hans Mackowiak) wrote:</p>
<blockquote>
<p>i don't know about the rubyVM but can <code>xyz(&method(:symbol))</code> or <code>xyz(&obj.method(:symbol))</code> be optimized like <code>xyz(&:symbol)</code> is?</p>
</blockquote>
<p>They have different meanings all.</p>
<p><code>xyz(&method(:symbol))</code> == <code>xyz {|x| symbol(x)}</code><br>
<code>xyz(&obj.method(:symbol))</code> == <code>xyz {|x| obj.symbol(x)}</code><br>
<code>xyz(&:symbol)</code> == <code>xyz {|x| x.symbol}</code></p>
</blockquote>
<p>i know they are different meanings,<br>
i was just wondering if they can be optimized for the VM too, to make them run faster if able<br>
like with not creating extra ruby objects if not needed</p> Ruby master - Feature #13581: Syntax sugar for method referencehttps://redmine.ruby-lang.org/issues/13581?journal_id=701312018-02-02T10:57:44Znobu (Nobuyoshi Nakada)nobu@ruby-lang.org
<ul></ul><p>Hanmac (Hans Mackowiak) wrote:</p>
<blockquote>
<p>i know they are different meanings,</p>
</blockquote>
<p>Sorry, misread.</p>
<blockquote>
<p>i was just wondering if they can be optimized for the VM too, to make them run faster if able<br>
like with not creating extra ruby objects if not needed</p>
</blockquote>
<p>Once a <code>Method</code> as the result of <code>&</code> to passing a block is allowed, optimization of calling a <code>Method</code> object might be possible by adding a new block handler type for methods.<br>
No "extra ruby objects" would be the next step.</p> Ruby master - Feature #13581: Syntax sugar for method referencehttps://redmine.ruby-lang.org/issues/13581?journal_id=701612018-02-04T20:10:20Zlandongrindheim (Landon Grindheim)
<ul></ul><blockquote>
<ul>
<li>
<code>map(&Math->sqrt)</code> (and just <code>each(&->puts)</code> probably?) -- Matz is explicitly against it;</li>
</ul>
</blockquote>
<p>Is <code>map(&Math.&(:sqrt)</code> viable? Perhaps it would be confused with the safe navigation operator.</p> Ruby master - Feature #13581: Syntax sugar for method referencehttps://redmine.ruby-lang.org/issues/13581?journal_id=701622018-02-04T21:12:39Zjeremyevans0 (Jeremy Evans)merch-redmine@jeremyevans.net
<ul></ul><p>landongrindheim (Landon Grindheim) wrote:</p>
<blockquote>
<p>Is <code>map(&Math.&(:sqrt)</code> viable? Perhaps it would be confused with the safe navigation operator.</p>
</blockquote>
<p>No. It would break backward compatibility, as that is currently interpreted as:</p>
<pre><code>Math.&(:sqrt).to_proc
</code></pre>
<p>That code currently works if you do:</p>
<pre><code>def Math.&(x) proc{|a| a} end
</code></pre> Ruby master - Feature #13581: Syntax sugar for method referencehttps://redmine.ruby-lang.org/issues/13581?journal_id=701952018-02-05T17:39:19Zsevos (Artur Roszczyk)artur.roszczyk@gmail.com
<ul></ul><p>Have we ruled out <code>map(&obj:method)</code> syntax? Intuitively I find it consistent with <code>Symbol#to_proc</code></p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="k">class</span> <span class="nc">Foo</span>
<span class="k">def</span> <span class="nf">initialize</span><span class="p">(</span><span class="n">array</span><span class="p">)</span>
<span class="vi">@array</span> <span class="o">=</span> <span class="n">array</span>
<span class="k">end</span>
<span class="k">def</span> <span class="nf">call</span>
<span class="vi">@array</span>
<span class="p">.</span><span class="nf">map</span><span class="p">(</span><span class="o">&</span><span class="no">Math</span><span class="ss">:sqrt</span><span class="p">)</span>
<span class="p">.</span><span class="nf">map</span><span class="p">(</span><span class="o">&</span><span class="nb">self</span><span class="ss">:magic</span><span class="p">)</span>
<span class="p">.</span><span class="nf">map</span><span class="p">(</span><span class="o">&</span><span class="nb">self</span><span class="ss">:boo</span><span class="p">(</span><span class="mf">2.0</span><span class="p">))</span>
<span class="p">.</span><span class="nf">map</span><span class="p">(</span><span class="o">&</span><span class="ss">:ceil</span><span class="p">)</span>
<span class="p">.</span><span class="nf">each</span><span class="p">(</span><span class="o">&</span><span class="no">Kernel</span><span class="ss">:puts</span><span class="p">)</span>
<span class="k">end</span>
<span class="kp">private</span>
<span class="k">def</span> <span class="nf">magic</span><span class="p">(</span><span class="n">x</span><span class="p">)</span>
<span class="n">x</span> <span class="o">**</span> <span class="mi">3</span>
<span class="k">end</span>
<span class="k">def</span> <span class="nf">boo</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">a</span> <span class="o">/</span> <span class="n">b</span>
<span class="k">end</span>
<span class="k">end</span>
</code></pre>
<p>Alternatively, I am for triple colon:</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="k">class</span> <span class="nc">Foo</span>
<span class="k">def</span> <span class="nf">initialize</span><span class="p">(</span><span class="n">array</span><span class="p">)</span>
<span class="vi">@array</span> <span class="o">=</span> <span class="n">array</span>
<span class="k">end</span>
<span class="k">def</span> <span class="nf">call</span>
<span class="vi">@array</span>
<span class="p">.</span><span class="nf">map</span><span class="p">(</span><span class="o">&</span><span class="no">Math</span><span class="o">::</span><span class="ss">:sqrt</span><span class="p">)</span>
<span class="p">.</span><span class="nf">map</span><span class="p">(</span><span class="o">&</span><span class="nb">self</span><span class="o">::</span><span class="ss">:magic</span><span class="p">)</span>
<span class="p">.</span><span class="nf">map</span><span class="p">(</span><span class="o">&::</span><span class="ss">:boo</span><span class="p">(</span><span class="mf">2.0</span><span class="p">))</span> <span class="c1"># with triple colon we could omit self</span>
<span class="p">.</span><span class="nf">map</span><span class="p">(</span><span class="o">&</span><span class="ss">:ceil</span><span class="p">)</span>
<span class="p">.</span><span class="nf">each</span><span class="p">(</span><span class="o">&</span><span class="no">Kernel</span><span class="o">::</span><span class="ss">:puts</span><span class="p">)</span>
<span class="k">end</span>
<span class="kp">private</span>
<span class="k">def</span> <span class="nf">magic</span><span class="p">(</span><span class="n">x</span><span class="p">)</span>
<span class="n">x</span> <span class="o">**</span> <span class="mi">3</span>
<span class="k">end</span>
<span class="k">def</span> <span class="nf">boo</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">a</span> <span class="o">/</span> <span class="n">b</span>
<span class="k">end</span>
<span class="k">end</span>
</code></pre>
<p>This could translate to:</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="k">class</span> <span class="nc">Foo</span>
<span class="k">def</span> <span class="nf">initialize</span><span class="p">(</span><span class="n">array</span><span class="p">)</span>
<span class="vi">@array</span> <span class="o">=</span> <span class="n">array</span>
<span class="k">end</span>
<span class="k">def</span> <span class="nf">call</span>
<span class="vi">@array</span>
<span class="p">.</span><span class="nf">map</span> <span class="p">{</span> <span class="o">|</span><span class="n">x</span><span class="o">|</span> <span class="no">Math</span><span class="p">.</span><span class="nf">public_send</span><span class="p">(</span><span class="ss">:sqrt</span><span class="p">,</span> <span class="n">x</span><span class="p">)</span> <span class="p">}</span>
<span class="p">.</span><span class="nf">map</span> <span class="p">{</span> <span class="o">|</span><span class="n">x</span><span class="o">|</span> <span class="nb">self</span><span class="p">.</span><span class="nf">send</span><span class="p">(</span><span class="ss">:magic</span><span class="p">,</span> <span class="n">x</span><span class="p">)</span> <span class="p">}</span>
<span class="p">.</span><span class="nf">map</span> <span class="p">{</span> <span class="o">|</span><span class="n">x</span><span class="o">|</span> <span class="nb">self</span><span class="p">.</span><span class="nf">send</span><span class="p">(</span><span class="ss">:boo</span><span class="p">,</span> <span class="n">x</span><span class="p">,</span> <span class="mf">2.0</span><span class="p">)</span> <span class="p">}</span>
<span class="p">.</span><span class="nf">map</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">ceil</span> <span class="p">}</span>
<span class="p">.</span><span class="nf">each</span> <span class="p">{</span> <span class="o">|</span><span class="n">x</span><span class="o">|</span> <span class="no">Kernel</span><span class="p">.</span><span class="nf">public_send</span><span class="p">(</span><span class="ss">:puts</span><span class="p">,</span> <span class="n">x</span><span class="p">)</span> <span class="p">}</span>
<span class="k">end</span>
<span class="kp">private</span>
<span class="k">def</span> <span class="nf">magic</span><span class="p">(</span><span class="n">x</span><span class="p">)</span>
<span class="n">x</span> <span class="o">**</span> <span class="mi">3</span>
<span class="k">end</span>
<span class="k">def</span> <span class="nf">boo</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">a</span> <span class="o">/</span> <span class="n">b</span>
<span class="k">end</span>
<span class="k">end</span>
</code></pre>
<p>Applying additional arguments (aka <code>.map(&self:boo(2.0))</code> is just a proposal - I am not sure if this should be even possible - <code>Symbol#to_proc</code> does not allow that.</p>
<p>Another interesting question which we need to answer is:</p>
<p><strong>What visibility scope should be used when making a method call?</strong></p>
<p>Given the syntax <code>receiver:method</code> or <code>receiver:::method</code> if the receiver is <code>self</code> then we should expand this syntax sugar to <code>send()</code> allowing accessing the private interface of the current object (which is not the item from the iterator - we would use symbol to proc in that case). However, if the receiver is something else, we should expand to <code>public_send</code> to disallow accessing private methods of other objects.</p>
<p>Just my two cents ;)</p>
<p>Cheers,<br>
Artur</p> Ruby master - Feature #13581: Syntax sugar for method referencehttps://redmine.ruby-lang.org/issues/13581?journal_id=702222018-02-06T06:14:07Znobu (Nobuyoshi Nakada)nobu@ruby-lang.org
<ul></ul><p>Note that <code>&:</code> isn't a single operator, but combination of <code>&</code> prefix + a part of <code>:symbol</code>.<br>
So it should be valid syntax solely without <code>&</code>.</p> Ruby master - Feature #13581: Syntax sugar for method referencehttps://redmine.ruby-lang.org/issues/13581?journal_id=702232018-02-06T08:19:30Zsevos (Artur Roszczyk)artur.roszczyk@gmail.com
<ul></ul><p>After a while I am becoming a bigger fan of the triple colon operator. We could implement a class MethodSelector for handling the logic and the operator would be expected to return an instance of the class:</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="k">class</span> <span class="nc">MethodSelector</span>
<span class="k">def</span> <span class="nf">initialize</span><span class="p">(</span><span class="n">b</span><span class="p">,</span> <span class="n">receiver</span><span class="p">,</span> <span class="n">m</span><span class="p">)</span>
<span class="vi">@binding</span> <span class="o">=</span> <span class="n">b</span>
<span class="vi">@receiver</span> <span class="o">=</span> <span class="n">receiver</span>
<span class="vi">@method</span> <span class="o">=</span> <span class="n">m</span>
<span class="k">end</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">kwargs</span><span class="p">,</span> <span class="o">&</span><span class="n">block</span><span class="p">)</span>
<span class="c1"># ...</span>
<span class="k">end</span>
<span class="k">def</span> <span class="nf">to_proc</span>
<span class="k">if</span> <span class="vi">@binding</span><span class="p">.</span><span class="nf">eval</span><span class="p">(</span><span class="s2">"self"</span><span class="p">)</span> <span class="o">==</span> <span class="vi">@receiver</span>
<span class="nb">proc</span> <span class="k">do</span> <span class="o">|*</span><span class="n">args</span><span class="p">,</span> <span class="o">**</span><span class="n">kwargs</span><span class="p">,</span> <span class="o">&</span><span class="n">block</span><span class="o">|</span>
<span class="k">if</span> <span class="n">kwargs</span><span class="p">.</span><span class="nf">empty?</span>
<span class="vi">@receiver</span><span class="p">.</span><span class="nf">send</span><span class="p">(</span><span class="vi">@method</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">else</span>
<span class="vi">@receiver</span><span class="p">.</span><span class="nf">send</span><span class="p">(</span><span class="vi">@method</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">kwargs</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">else</span>
<span class="nb">proc</span> <span class="k">do</span> <span class="o">|*</span><span class="n">args</span><span class="p">,</span> <span class="o">**</span><span class="n">kwargs</span><span class="p">,</span> <span class="o">&</span><span class="n">block</span><span class="o">|</span>
<span class="k">if</span> <span class="n">kwargs</span><span class="p">.</span><span class="nf">empty?</span>
<span class="vi">@receiver</span><span class="p">.</span><span class="nf">public_send</span><span class="p">(</span><span class="vi">@method</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">else</span>
<span class="vi">@receiver</span><span class="p">.</span><span class="nf">public_send</span><span class="p">(</span><span class="vi">@method</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">kwargs</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>
<span class="k">end</span>
<span class="k">end</span>
<span class="c1"># Instead of MS() method we should implement ::: operator (taking two argiments):</span>
<span class="c1"># receiver:::method expands to MS(binding, receiver, method)</span>
<span class="k">class</span> <span class="nc">Object</span>
<span class="k">def</span> <span class="nf">MS</span><span class="p">(</span><span class="n">b</span><span class="p">,</span> <span class="n">receiver</span><span class="p">,</span> <span class="n">m</span><span class="p">)</span>
<span class="no">MethodSelector</span><span class="p">.</span><span class="nf">new</span><span class="p">(</span><span class="n">b</span><span class="p">,</span> <span class="n">receiver</span><span class="p">,</span> <span class="n">m</span><span class="p">)</span>
<span class="k">end</span>
<span class="k">end</span>
<span class="c1"># Example usage</span>
<span class="o">></span> <span class="no">MS</span><span class="p">(</span><span class="nb">binding</span><span class="p">,</span> <span class="no">Kernel</span><span class="p">,</span> <span class="ss">:puts</span><span class="p">)</span> <span class="c1"># the triple colon operator should expand current binding by default</span>
<span class="o">=></span> <span class="c1">#<MethodSelector:0x007fdba89bd0a8 @binding=#<Binding:0x007fdba89bd0d0>, @receiver=Kernel, @method=:puts></span>
<span class="o">></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">each</span><span class="p">(</span><span class="o">&</span><span class="no">MS</span><span class="p">(</span><span class="nb">binding</span><span class="p">,</span> <span class="no">Kernel</span><span class="p">,</span> <span class="ss">:puts</span><span class="p">))</span>
<span class="mi">1</span>
<span class="mi">2</span>
<span class="mi">3</span>
<span class="o">=></span> <span class="kp">nil</span>
</code></pre>
<p>There is still the question how to enable meta-programming with triple colon operator.<br>
Imagine the situation when the method name is dynamic. How to distinguish it from the symbol?</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="nb">method</span> <span class="o">=</span> <span class="ss">:puts</span>
<span class="no">Kernel</span><span class="o">::</span><span class="ss">:puts</span>
<span class="no">Kernel</span><span class="o">::</span><span class="ss">:method</span>
</code></pre>
<p>The only logical solution to me is the presence of the fourth colon for the symbol:</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="nb">method</span> <span class="o">=</span> <span class="ss">:puts</span>
<span class="no">Kernel</span><span class="o">::::</span><span class="nb">puts</span> <span class="c1"># evaluates as Kernel:::(:puts)</span>
<span class="no">Kernel</span><span class="o">::</span><span class="ss">:method</span> <span class="c1"># evaluates as Kernel:::(method)</span>
</code></pre>
<p>What are your thoughts?</p> Ruby master - Feature #13581: Syntax sugar for method referencehttps://redmine.ruby-lang.org/issues/13581?journal_id=702242018-02-06T08:39:19Zphluid61 (Matthew Kerwin)matthew@kerwin.net.au
<ul></ul><p>sevos (Artur Roszczyk) wrote:</p>
<blockquote>
<p>What are your thoughts?</p>
</blockquote>
<p>I have two:</p>
<ol>
<li>
<p>As always: do we really need more magic symbols? I like reading Ruby because it's <em>not</em> Perl.</p>
</li>
<li>
<p>If you're adding new syntax, you don't have to be clever. Symbol has <code>:"#{x}"</code> so why not propose <code>y:::"#{x}"</code>? Not that it adds much over <code>y.method(x)</code></p>
</li>
</ol> Ruby master - Feature #13581: Syntax sugar for method referencehttps://redmine.ruby-lang.org/issues/13581?journal_id=702262018-02-06T10:52:55Zsevos (Artur Roszczyk)artur.roszczyk@gmail.com
<ul></ul><p>phluid61 (Matthew Kerwin) wrote:</p>
<blockquote>
<p>sevos (Artur Roszczyk) wrote:</p>
<blockquote>
<p>What are your thoughts?</p>
</blockquote>
<p>I have two:</p>
<ol>
<li>As always: do we really need more magic symbols? I like reading Ruby because it's <em>not</em> Perl.<br>
I totally agree, but we still like -> {} syntax for lambdas, right? Let's play with ideas, maybe we can find something nice for a method selector, too ;)</li>
</ol>
</blockquote>
<blockquote>
<ol start="2">
<li>If you're adding new syntax, you don't have to be clever. Symbol has <code>:"#{x}"</code> so why not propose <code>y:::"#{x}"</code>? Not that it adds much over <code>y.method(x)</code>
</li>
</ol>
</blockquote>
<p>You're totally right! I was looking at triple-colon as an operator taking two arguments. Your idea of looking at this as a double-colon lookup operator is actually great, look:</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="n">irb</span><span class="p">(</span><span class="n">main</span><span class="p">):</span><span class="mo">006</span><span class="p">:</span><span class="mi">0</span><span class="o">></span> <span class="n">a</span> <span class="o">::</span> <span class="ss">:to_s</span>
<span class="no">SyntaxError</span><span class="p">:</span> <span class="p">(</span><span class="n">irb</span><span class="p">):</span><span class="mi">6</span><span class="p">:</span> <span class="n">syntax</span> <span class="n">error</span><span class="p">,</span> <span class="n">unexpected</span> <span class="n">tSYMBEG</span><span class="p">,</span> <span class="n">expecting</span> <span class="s1">'('</span>
<span class="n">a</span> <span class="o">::</span> <span class="ss">:to_s</span>
<span class="o">^</span>
<span class="n">from</span> <span class="sr">/Users/se</span><span class="n">vos</span><span class="o">/</span><span class="p">.</span><span class="nf">rbenv</span><span class="o">/</span><span class="n">versions</span><span class="o">/</span><span class="mf">2.4</span><span class="o">.</span><span class="mi">0</span><span class="o">/</span><span class="n">bin</span><span class="o">/</span><span class="n">irb</span><span class="p">:</span><span class="mi">11</span><span class="ss">:in</span> <span class="sb">`<main>'
irb(main):007:0> Kernel :: :t
SyntaxError: (irb):7: syntax error, unexpected tSYMBEG, expecting tCONSTANT
A :: :t
^
from /Users/sevos/.rbenv/versions/2.4.0/bin/irb:11:in `</span><span class="o"><</span><span class="n">main</span><span class="o">></span><span class="err">'</span>
</code></pre>
<p>We already have a lookup operator which takes object, constant on the left side and method name or constand on the right side.<br>
Maybe it would be possible to support symbols on the right side and expand them to <code>method(:symbol)</code> call?<br>
I would like just to emphasise again the need of respecting the method-to-be-called visibility depending on the current binding.</p> Ruby master - Feature #13581: Syntax sugar for method referencehttps://redmine.ruby-lang.org/issues/13581?journal_id=702282018-02-06T13:15:09Zphluid61 (Matthew Kerwin)matthew@kerwin.net.au
<ul></ul><p>sevos (Artur Roszczyk) wrote:</p>
<blockquote>
<p>phluid61 (Matthew Kerwin) wrote:</p>
<blockquote>
<p>sevos (Artur Roszczyk) wrote:</p>
<blockquote>
<p>What are your thoughts?</p>
</blockquote>
<p>I have two:</p>
<ol>
<li>As always: do we really need more magic symbols? I like reading Ruby because it's <em>not</em> Perl.</li>
</ol>
</blockquote>
<p>I totally agree, but we still like -> {} syntax for lambdas, right? Let's play with ideas, maybe we can find something nice for a method selector, too ;)</p>
</blockquote>
<p>Personally I hate it, and never use it. I like my code to say <code>lambda</code> when I make a Lambda, and (more often) <code>proc</code> when I make a Proc.</p>
<blockquote>
<blockquote>
<ol start="2">
<li>If you're adding new syntax, you don't have to be clever. Symbol has <code>:"#{x}"</code> so why not propose <code>y:::"#{x}"</code>? Not that it adds much over <code>y.method(x)</code>
</li>
</ol>
</blockquote>
<p>You're totally right! I was looking at triple-colon as an operator taking two arguments. Your idea of looking at this as a double-colon lookup operator is actually great, [...]</p>
</blockquote>
<p>Actually I was just suggesting a simple token, like <code>obj:::foo</code> or <code>obj.:foo</code>; if you really want to accept variable method names why not <code>obj:::"#{x}"</code> or <code>obj.:"#{x}"</code>?</p>
<p>Although I doubt I'd ever use it.</p>
<p>(Personally I find the idea of partially applied methods more useful.)</p>
<p>Cheers</p> Ruby master - Feature #13581: Syntax sugar for method referencehttps://redmine.ruby-lang.org/issues/13581?journal_id=703032018-02-12T23:54:41Zcben (Beni Cherniavsky-Paskin)cben@redhat.com
<ul></ul><p>A non-syntax idea: could <code>Math.method.sqrt</code> look significantly nicer than <code>Math.method(:sqrt)</code>?<br>
That is, .method without args would return a magic object that for any message returns the bound method of that name.</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">4</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">Math</span><span class="p">.</span><span class="nf">method</span><span class="p">.</span><span class="nf">sqrt</span><span class="p">).</span><span class="nf">each</span><span class="p">(</span><span class="o">&</span><span class="nb">method</span><span class="p">.</span><span class="nf">puts</span><span class="p">)</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="nf">map</span><span class="p">(</span><span class="o">&</span><span class="no">Math</span><span class="p">.</span><span class="nf">method</span><span class="p">(</span><span class="ss">:sqrt</span><span class="p">)).</span><span class="nf">each</span><span class="p">(</span><span class="o">&</span><span class="nb">method</span><span class="p">(</span><span class="ss">:puts</span><span class="p">))</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="nf">map</span><span class="p">{</span><span class="o">|*</span><span class="n">a</span><span class="o">|</span> <span class="no">Math</span><span class="p">.</span><span class="nf">sqrt</span><span class="p">(</span><span class="o">*</span><span class="n">a</span><span class="p">)}.</span><span class="nf">each</span><span class="p">{</span><span class="o">|*</span><span class="n">a</span><span class="o">|</span> <span class="nb">puts</span><span class="p">(</span><span class="o">*</span><span class="n">a</span><span class="p">)}</span>
</code></pre>
<p>Naive implementation (some names don't work, eg. <code>Math.method.method_missing</code>, and doesn't take visibility and refinements into account):</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="k">class</span> <span class="nc">Methods</span> <span class="o"><</span> <span class="no">BasicObject</span>
<span class="k">def</span> <span class="nf">initialize</span><span class="p">(</span><span class="n">obj</span><span class="p">)</span>
<span class="vi">@obj</span> <span class="o">=</span> <span class="n">obj</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="vi">@obj</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">def</span> <span class="nf">responds_to_missing?</span><span class="p">(</span><span class="nb">name</span><span class="p">)</span>
<span class="kp">true</span>
<span class="k">end</span>
<span class="k">end</span>
<span class="k">module</span> <span class="nn">MethodWithoutArgs</span>
<span class="k">def</span> <span class="nf">method</span><span class="p">(</span><span class="o">*</span><span class="n">args</span><span class="p">)</span>
<span class="k">if</span> <span class="n">args</span><span class="p">.</span><span class="nf">empty?</span>
<span class="no">Methods</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">else</span>
<span class="k">super</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="p">(</span><span class="no">MethodWithoutArgs</span><span class="p">)</span>
<span class="p">[</span><span class="mi">14</span><span class="p">]</span> <span class="n">pry</span><span class="p">(</span><span class="n">main</span><span class="p">)</span><span class="o">></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="nf">map</span><span class="p">(</span><span class="o">&</span><span class="no">Math</span><span class="p">.</span><span class="nf">method</span><span class="p">.</span><span class="nf">sqrt</span><span class="p">).</span><span class="nf">each</span><span class="p">(</span><span class="o">&</span><span class="nb">method</span><span class="p">.</span><span class="nf">puts</span><span class="p">)</span>
<span class="mf">1.0</span>
<span class="mf">2.0</span>
<span class="mf">3.0</span>
<span class="o">=></span> <span class="p">[</span><span class="mf">1.0</span><span class="p">,</span> <span class="mf">2.0</span><span class="p">,</span> <span class="mf">3.0</span><span class="p">]</span>
</code></pre>
<p>BTW, what about refinements? Is .method(:foo) ignorant about them? A benefit of a real syntax might be that it could "see" methods from lexically active refinements.</p>
<p>As for syntax, I'm wondering if something <em>postfix</em> might work. The reason I say this is I'm thinking of both &: and this as shorthands for writing out a block.<br>
<code>&:</code> can be read locally, it roughly "stands for" <code>|x| x.</code> :</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">map</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">to_s</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">map</span><span class="p">(</span><span class="o">&</span><span class="ss">:to_s</span><span class="p">)</span>
</code></pre>
<p>And with a bound method, we want to elide the argument declaration, plus the call that comes <em>after</em> the receiver.message:</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">4</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="n">a</span><span class="o">|</span> <span class="no">Math</span><span class="p">.</span><span class="nf">sqrt</span><span class="p">(</span><span class="o">*</span><span class="n">a</span><span class="p">)}.</span><span class="nf">each</span><span class="p">{</span><span class="o">|*</span><span class="n">a</span><span class="o">|</span> <span class="nb">puts</span><span class="p">(</span><span class="o">*</span><span class="n">a</span><span class="p">)}</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="nf">map</span><span class="p">(</span><span class="o">&</span><span class="no">Math</span><span class="p">.</span><span class="nf">sqrt</span><span class="p">:).</span><span class="nf">each</span><span class="p">(</span><span class="o">&</span><span class="nb">puts</span><span class="p">:)</span> <span class="c1"># half baked idea</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="nf">map</span><span class="p">(</span><span class="no">Math</span><span class="p">.</span><span class="nf">sqrt</span><span class="o">&</span><span class="p">).</span><span class="nf">each</span><span class="p">(</span><span class="nb">puts</span><span class="o">&</span><span class="p">)</span> <span class="c1"># quarter baked</span>
</code></pre>
<p>OK, actually there is a more generic feature I'd love much more than a syntax for bound methods: implicit notation for block arg:</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">map</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">to_s</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">map</span><span class="p">{</span><span class="n">_</span><span class="p">.</span><span class="nf">to_s</span><span class="p">}</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="nf">map</span><span class="p">{</span><span class="o">|</span><span class="n">x</span><span class="o">|</span> <span class="no">Math</span><span class="p">.</span><span class="nf">sqrt</span><span class="p">(</span><span class="n">x</span><span class="p">)}.</span><span class="nf">each</span><span class="p">{</span><span class="o">|</span><span class="n">x</span><span class="o">|</span> <span class="nb">puts</span><span class="p">(</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">4</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="no">Math</span><span class="p">.</span><span class="nf">sqrt</span><span class="p">(</span><span class="n">_</span><span class="p">)}.</span><span class="nf">each</span><span class="p">{</span><span class="nb">puts</span><span class="p">(</span><span class="n">_</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">map</span><span class="p">{</span><span class="o">|</span><span class="n">x</span><span class="o">|</span> <span class="mi">1</span><span class="o">/</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">map</span><span class="p">{</span><span class="mi">1</span><span class="o">/</span><span class="n">_</span><span class="p">}</span>
</code></pre>
<p>(I don't think <code>_</code> is possible, just an example)</p>
<p>The part I love most about this is that <code>{}</code> does <em>not</em> become <code>(&...)</code>!<br>
This doesn't easily handle multiple args, like bound methods do, but I think one arg is sweet spot for such shorthand anyway.</p>
<ul>
<li>I've tried prototyping this once by defining <code>Kernel._</code> that would look in caller frame, but didn't find any way to access arg in a block that didn't declare any |args|.</li>
</ul> Ruby master - Feature #13581: Syntax sugar for method referencehttps://redmine.ruby-lang.org/issues/13581?journal_id=703212018-02-14T00:52:50Zsevos (Artur Roszczyk)artur.roszczyk@gmail.com
<ul></ul><p>cben (Beni Cherniavsky-Paskin) wrote:</p>
<blockquote>
<p>A non-syntax idea: could <code>Math.method.sqrt</code> look significantly nicer than <code>Math.method(:sqrt)</code>?<br>
That is, .method without args would return a magic object that for any message returns the bound method of that name.</p>
</blockquote>
<p>Hey Beni! Thank you! This is a great idea! For my taste it looks significantly better!</p>
<p>Also, I took the liberty of implementing a prototype gem and I've added my two cents:</p>
<ul>
<li>method visibility check</li>
<li>arguments currying</li>
</ul>
<p>You can check it out on <a href="https://github.com/sevos/methods" class="external">Github</a></p> Ruby master - Feature #13581: Syntax sugar for method referencehttps://redmine.ruby-lang.org/issues/13581?journal_id=712352018-03-26T21:43:31Zpvande (Pieter van de Bruggen)
<ul></ul><p>As a blue sky alternative, why not consider something 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="nf">map</span><span class="p">(</span><span class="o">&></span> <span class="p">{</span><span class="no">Math</span><span class="p">.</span><span class="nf">sqrt</span><span class="p">})</span>
<span class="c1"># or perhaps more simply</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">map</span><span class="p">(</span><span class="o">&></span> <span class="no">Math</span><span class="p">.</span><span class="nf">sqrt</span><span class="p">)</span>
</code></pre>
<p>Pros:</p>
<ul>
<li>It's clean</li>
<li>It's readable</li>
<li>It reads like passing a block
<ul>
<li>Specifically, passing a lambda as a block</li>
</ul>
</li>
<li>It <em>also</em> reads something like the Elixir pipe operator</li>
</ul>
<p>Cons:</p>
<ul>
<li>It's only <em>looks</em> like Ruby code
<ul>
<li>Is <code>x.map(&> { a.b.c.d ; Math.sqrt })</code> valid? (I hope not.)</li>
<li>Is <code>x.map(&> do; Math.sqrt; end)</code> valid? (I hope not.)</li>
<li>Is <code>x.map(&> { begin; rescue; end })</code> valid? (I hope not.)</li>
<li>Is <code>x.map(&> { Math.sqrt if x })</code> valid? (I hope not.)</li>
<li>Is <code>x.map(&> { Math.sqrt rescue nil })</code> valid? (I hope not.)</li>
</ul>
</li>
<li>It's not actually a shorthand for <code>Object#method</code>.
<ul>
<li>The two clearest implementation paths are as a "macro", and as an "atypical evaluation context"
<ul>
<li>The macro approach simply transforms the code into a "proper" block, and passes the argument implicitly (see below for an example)</li>
<li>The other approach requires the interpreter to all non-terminal method calls, then produce a block invoking the terminal call with the yielded argument (see below for an example)</li>
</ul>
</li>
</ul>
</li>
</ul>
<p>Despite the "oddness" of this particular syntax, I think the clarity of expression is very much inline with the Ruby ideals, and is therefore worth discussing.</p>
<p><strong>Macro Example</strong></p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="n">fn</span><span class="p">(</span><span class="o">&></span> <span class="p">{</span> <span class="n">a</span><span class="p">.</span><span class="nf">b</span><span class="p">.</span><span class="nf">c</span><span class="p">.</span><span class="nf">d</span> <span class="p">})</span>
<span class="c1"># => fn() { |__x| a.b.c.d(__x) })</span>
</code></pre>
<p><strong>Atypical Evaluation Example</strong></p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="n">fn</span><span class="p">(</span><span class="o">&></span> <span class="p">{</span> <span class="n">a</span><span class="p">.</span><span class="nf">b</span><span class="p">.</span><span class="nf">c</span><span class="p">.</span><span class="nf">d</span> <span class="p">})</span>
<span class="c1"># => __target = a.b.c; fn() { |__x| __target.d(__x) })</span>
</code></pre> Ruby master - Feature #13581: Syntax sugar for method referencehttps://redmine.ruby-lang.org/issues/13581?journal_id=716112018-04-23T07:00:11Zbaweaver (Brandon Weaver)keystonelemur@gmail.com
<ul></ul><p>sevos (Artur Roszczyk) wrote:</p>
<blockquote>
<p>After a while I am becoming a bigger fan of the triple colon operator. We could implement a class MethodSelector for handling the logic and the operator would be expected to return an instance of the class:</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="k">class</span> <span class="nc">MethodSelector</span>
<span class="k">def</span> <span class="nf">initialize</span><span class="p">(</span><span class="n">b</span><span class="p">,</span> <span class="n">receiver</span><span class="p">,</span> <span class="n">m</span><span class="p">)</span>
<span class="vi">@binding</span> <span class="o">=</span> <span class="n">b</span>
<span class="vi">@receiver</span> <span class="o">=</span> <span class="n">receiver</span>
<span class="vi">@method</span> <span class="o">=</span> <span class="n">m</span>
<span class="k">end</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">kwargs</span><span class="p">,</span> <span class="o">&</span><span class="n">block</span><span class="p">)</span>
<span class="c1"># ...</span>
<span class="k">end</span>
<span class="k">def</span> <span class="nf">to_proc</span>
<span class="k">if</span> <span class="vi">@binding</span><span class="p">.</span><span class="nf">eval</span><span class="p">(</span><span class="s2">"self"</span><span class="p">)</span> <span class="o">==</span> <span class="vi">@receiver</span>
<span class="nb">proc</span> <span class="k">do</span> <span class="o">|*</span><span class="n">args</span><span class="p">,</span> <span class="o">**</span><span class="n">kwargs</span><span class="p">,</span> <span class="o">&</span><span class="n">block</span><span class="o">|</span>
<span class="k">if</span> <span class="n">kwargs</span><span class="p">.</span><span class="nf">empty?</span>
<span class="vi">@receiver</span><span class="p">.</span><span class="nf">send</span><span class="p">(</span><span class="vi">@method</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">else</span>
<span class="vi">@receiver</span><span class="p">.</span><span class="nf">send</span><span class="p">(</span><span class="vi">@method</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">kwargs</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">else</span>
<span class="nb">proc</span> <span class="k">do</span> <span class="o">|*</span><span class="n">args</span><span class="p">,</span> <span class="o">**</span><span class="n">kwargs</span><span class="p">,</span> <span class="o">&</span><span class="n">block</span><span class="o">|</span>
<span class="k">if</span> <span class="n">kwargs</span><span class="p">.</span><span class="nf">empty?</span>
<span class="vi">@receiver</span><span class="p">.</span><span class="nf">public_send</span><span class="p">(</span><span class="vi">@method</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">else</span>
<span class="vi">@receiver</span><span class="p">.</span><span class="nf">public_send</span><span class="p">(</span><span class="vi">@method</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">kwargs</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>
<span class="k">end</span>
<span class="k">end</span>
<span class="c1"># Instead of MS() method we should implement ::: operator (taking two argiments):</span>
<span class="c1"># receiver:::method expands to MS(binding, receiver, method)</span>
<span class="k">class</span> <span class="nc">Object</span>
<span class="k">def</span> <span class="nf">MS</span><span class="p">(</span><span class="n">b</span><span class="p">,</span> <span class="n">receiver</span><span class="p">,</span> <span class="n">m</span><span class="p">)</span>
<span class="no">MethodSelector</span><span class="p">.</span><span class="nf">new</span><span class="p">(</span><span class="n">b</span><span class="p">,</span> <span class="n">receiver</span><span class="p">,</span> <span class="n">m</span><span class="p">)</span>
<span class="k">end</span>
<span class="k">end</span>
<span class="c1"># Example usage</span>
<span class="o">></span> <span class="no">MS</span><span class="p">(</span><span class="nb">binding</span><span class="p">,</span> <span class="no">Kernel</span><span class="p">,</span> <span class="ss">:puts</span><span class="p">)</span> <span class="c1"># the triple colon operator should expand current binding by default</span>
<span class="o">=></span> <span class="c1">#<MethodSelector:0x007fdba89bd0a8 @binding=#<Binding:0x007fdba89bd0d0>, @receiver=Kernel, @method=:puts></span>
<span class="o">></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">each</span><span class="p">(</span><span class="o">&</span><span class="no">MS</span><span class="p">(</span><span class="nb">binding</span><span class="p">,</span> <span class="no">Kernel</span><span class="p">,</span> <span class="ss">:puts</span><span class="p">))</span>
<span class="mi">1</span>
<span class="mi">2</span>
<span class="mi">3</span>
<span class="o">=></span> <span class="kp">nil</span>
</code></pre>
<p>There is still the question how to enable meta-programming with triple colon operator.<br>
Imagine the situation when the method name is dynamic. How to distinguish it from the symbol?</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="nb">method</span> <span class="o">=</span> <span class="ss">:puts</span>
<span class="no">Kernel</span><span class="o">::</span><span class="ss">:puts</span>
<span class="no">Kernel</span><span class="o">::</span><span class="ss">:method</span>
</code></pre>
<p>The only logical solution to me is the presence of the fourth colon for the symbol:</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="nb">method</span> <span class="o">=</span> <span class="ss">:puts</span>
<span class="no">Kernel</span><span class="o">::::</span><span class="nb">puts</span> <span class="c1"># evaluates as Kernel:::(:puts)</span>
<span class="no">Kernel</span><span class="o">::</span><span class="ss">:method</span> <span class="c1"># evaluates as Kernel:::(method)</span>
</code></pre>
<p>What are your thoughts?</p>
</blockquote>
<p>I like the idea of triple-colon as well for succinctness.</p>
<p>Most of the alternative in terms of succinctness would involve discussing the no-parens syntax which is likely a non-starter for obvious compatibility reasons.</p>
<p>That is, unless there's a way to stop paren-free method calling in the presence of an <code>&</code> or <code>to_proc</code>:</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">map</span><span class="p">(</span><span class="o">&</span><span class="no">Math</span><span class="p">.</span><span class="nf">sqrt</span><span class="p">)</span>
<span class="no">Math</span><span class="p">.</span><span class="nf">sqrt</span><span class="p">.</span><span class="nf">to_proc</span>
</code></pre>
<p>...but that feels like an excess of black magic in the parser and would likely be prone to bugs.</p>
<p>I really do like what Scala does with underscores:</p>
<pre><code class="scala syntaxhl" data-language="scala"><span class="o">[</span><span class="err">1</span>,<span class="err">2</span>,<span class="err">3</span><span class="o">].</span><span class="py">map</span><span class="o">(</span><span class="k">_</span> <span class="o">*</span> <span class="mi">10</span><span class="o">)</span>
</code></pre>
<p>...but I also understand that that would also be hugely breaking in terms of syntax as well.</p>
<p>Really though I think given what Ruby already does the triple-colon is the cleanest route for now.</p> Ruby master - Feature #13581: Syntax sugar for method referencehttps://redmine.ruby-lang.org/issues/13581?journal_id=720722018-05-17T06:45:17Zmatz (Yukihiro Matsumoto)matz@ruby.or.jp
<ul></ul><p>Out of <a href="https://bugs.ruby-lang.org/issues/13581#change-69758" class="external">ruby-core:85038</a> candidates, <code>.:</code> looks best to me (followed by <code>:::</code>).<br>
Let me consider it for a while.</p>
<p>Matz.</p> Ruby master - Feature #13581: Syntax sugar for method referencehttps://redmine.ruby-lang.org/issues/13581?journal_id=722232018-05-23T09:47:08Zcben (Beni Cherniavsky-Paskin)cben@redhat.com
<ul></ul><p>Matz, could you give your thoughts on obj::method (with lowercase on right side) syntax?<br>
AFAICT it's synonym to obj.method?<br>
Does anybody use :: for method calls in practice?</p>
<p>I understand breaking compatibility can't be justified here, but I'm just curious — do you see this syntax as a feature to be preserved, or something to be avoided that might be (slowly) deprecated one day?</p> Ruby master - Feature #13581: Syntax sugar for method referencehttps://redmine.ruby-lang.org/issues/13581?journal_id=748222018-11-10T05:01:47Zianks (Ian Ker-Seymer)
<ul></ul><p>matz (Yukihiro Matsumoto) wrote:</p>
<blockquote>
<p>Out of <a href="https://bugs.ruby-lang.org/issues/13581#change-69758" class="external">ruby-core:85038</a> candidates, <code>.:</code> looks best to me (followed by <code>:::</code>).<br>
Let me consider it for a while.</p>
<p>Matz.</p>
</blockquote>
<p>Would love to see see either one implemented at this point. Not having an ergonomic way for functional composition is a pain.</p>
<p>My dream:</p>
<pre><code>slug = title
.then(&:strip)
.then(&:downcase)
.then(I18n:::transliterate)
.then(Utils:::hyphenate)
.then(Validations:::check_length)
.tap(PostLogger:::info)
</code></pre> Ruby master - Feature #13581: Syntax sugar for method referencehttps://redmine.ruby-lang.org/issues/13581?journal_id=748372018-11-12T07:20:33Znobu (Nobuyoshi Nakada)nobu@ruby-lang.org
<ul></ul><p><a href="https://github.com/nobu/ruby/tree/feature/13581-methref_op" class="external">https://github.com/nobu/ruby/tree/feature/13581-methref_op</a></p> Ruby master - Feature #13581: Syntax sugar for method referencehttps://redmine.ruby-lang.org/issues/13581?journal_id=748382018-11-12T10:29:17Zzverok (Victor Shepelev)zverok.offline@gmail.com
<ul></ul><p><a class="user active user-mention" href="https://redmine.ruby-lang.org/users/4">@nobu (Nobuyoshi Nakada)</a> Awesome!</p>
<p>Am I correct that receiver-less call, like <code>something.map(&.:puts)</code>, will be impossible?<br>
Is it a voluntary design decision, or limitation of what can be parsed?</p> Ruby master - Feature #13581: Syntax sugar for method referencehttps://redmine.ruby-lang.org/issues/13581?journal_id=748592018-11-14T14:46:48Zshevegen (Robert A. Heiler)shevegen@gmail.com
<ul></ul><p>I think <code>.:</code> is better than <code>:::</code> but it is not very pretty either. I have<br>
no better suggestion, though. Good syntax is not easy to use. :(</p>
<p>I agree with the functionality by the way.</p> Ruby master - Feature #13581: Syntax sugar for method referencehttps://redmine.ruby-lang.org/issues/13581?journal_id=748652018-11-15T01:50:50Znobu (Nobuyoshi Nakada)nobu@ruby-lang.org
<ul></ul><p>zverok (Victor Shepelev) wrote:</p>
<blockquote>
<p>Am I correct that receiver-less call, like <code>something.map(&.:puts)</code>, will be impossible?</p>
</blockquote>
<p>To allow that, <code>.:puts</code> should be a sole expression by itself.<br>
However ruby has the line continuation for “fluent interface” (like <a href="https://bugs.ruby-lang.org/issues/13581#change-74822" class="external">https://bugs.ruby-lang.org/issues/13581#change-74822</a>), for a decade.<br>
If <code>.:</code> will be introduced, I think it should obey that syntax too, and allowing it without the receiver feels confusing.</p>
<blockquote>
<p>Is it a voluntary design decision, or limitation of what can be parsed?</p>
</blockquote>
<p>It is easy to add a receiver-less syntax.<br>
<a href="https://github.com/ruby/ruby/commit/2307713962c3610f4e034e328af37b19be5c7c45" class="external">https://github.com/ruby/ruby/commit/2307713962c3610f4e034e328af37b19be5c7c45</a></p> Ruby master - Feature #13581: Syntax sugar for method referencehttps://redmine.ruby-lang.org/issues/13581?journal_id=748682018-11-15T08:42:43Zzverok (Victor Shepelev)zverok.offline@gmail.com
<ul></ul><p><a class="user active user-mention" href="https://redmine.ruby-lang.org/users/4">@nobu (Nobuyoshi Nakada)</a></p>
<blockquote>
<p>If <code>.:</code> will be introduced, I think it should obey that syntax too, and allowing it without the receiver feels confusing.</p>
</blockquote>
<p>Can you please show some example of confusing statements? I can't think of any from the top of my head, it seems that (if the parser can handle it), the context for <code>.:something</code> and <code>.something</code> is always clearly different.</p>
<p>I am concerned about receiver-less version because in our current codebase we found this idiom to be particularly useful:</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="c1"># in a large data-processing class</span>
<span class="n">some_input</span>
<span class="p">.</span><span class="nf">compact</span>
<span class="p">.</span><span class="nf">map</span><span class="p">(</span><span class="o">&</span><span class="nb">method</span><span class="p">(</span><span class="ss">:process_item</span><span class="p">))</span> <span class="c1"># it is private method of current class</span>
<span class="p">.</span><span class="nf">reject</span><span class="p">(</span><span class="o">&</span><span class="nb">method</span><span class="p">(</span><span class="ss">:spoiled?</span><span class="p">))</span>
<span class="p">.</span><span class="nf">tap</span><span class="p">(</span><span class="o">&</span><span class="nb">method</span><span class="p">(</span><span class="ss">:pp</span><span class="p">))</span> <span class="c1"># temp debugging statement</span>
<span class="p">.</span><span class="nf">group_by</span><span class="p">(</span><span class="o">&</span><span class="nb">method</span><span class="p">(</span><span class="ss">:grouping_criterion</span><span class="p">))</span>
<span class="p">.</span><span class="nf">yield_self</span><span class="p">(</span><span class="o">&</span><span class="nb">method</span><span class="p">(</span><span class="ss">:postprocess</span><span class="p">))</span>
<span class="c1"># which I'd be really happy to see as</span>
<span class="n">some_input</span>
<span class="p">.</span><span class="nf">compact</span>
<span class="p">.</span><span class="nf">map</span><span class="p">(</span><span class="o">&.</span><span class="ss">:process_item</span><span class="p">)</span>
<span class="p">.</span><span class="nf">reject</span><span class="p">(</span><span class="o">&.</span><span class="ss">:spoiled?</span><span class="p">)</span>
<span class="p">.</span><span class="nf">tap</span><span class="p">(</span><span class="o">&.</span><span class="ss">:pp</span><span class="p">)</span>
<span class="p">.</span><span class="nf">group_by</span><span class="p">(</span><span class="o">&.</span><span class="ss">:grouping_criterion</span><span class="p">)</span>
<span class="p">.</span><span class="nf">then</span><span class="p">(</span><span class="o">&.</span><span class="ss">:postprocess</span><span class="p">)</span>
</code></pre>
<p>Having to explicitly state <code>map(&self.:process_item)</code> is much less desirable.</p> Ruby master - Feature #13581: Syntax sugar for method referencehttps://redmine.ruby-lang.org/issues/13581?journal_id=748692018-11-15T10:02:25ZAlexWayfer (Alexander Popov)alex.wayfer@gmail.com
<ul></ul><p>zverok (Victor Shepelev) wrote:</p>
<blockquote>
<p><a class="user active user-mention" href="https://redmine.ruby-lang.org/users/4">@nobu (Nobuyoshi Nakada)</a></p>
<blockquote>
<p>If <code>.:</code> will be introduced, I think it should obey that syntax too, and allowing it without the receiver feels confusing.</p>
</blockquote>
<p>Can you please show some example of confusing statements? I can't think of any from the top of my head, it seems that (if the parser can handle it), the context for <code>.:something</code> and <code>.something</code> is always clearly different.</p>
<p>I am concerned about receiver-less version because in our current codebase we found this idiom to be particularly useful:</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="c1"># in a large data-processing class</span>
<span class="n">some_input</span>
<span class="p">.</span><span class="nf">compact</span>
<span class="p">.</span><span class="nf">map</span><span class="p">(</span><span class="o">&</span><span class="nb">method</span><span class="p">(</span><span class="ss">:process_item</span><span class="p">))</span> <span class="c1"># it is private method of current class</span>
<span class="p">.</span><span class="nf">reject</span><span class="p">(</span><span class="o">&</span><span class="nb">method</span><span class="p">(</span><span class="ss">:spoiled?</span><span class="p">))</span>
<span class="p">.</span><span class="nf">tap</span><span class="p">(</span><span class="o">&</span><span class="nb">method</span><span class="p">(</span><span class="ss">:pp</span><span class="p">))</span> <span class="c1"># temp debugging statement</span>
<span class="p">.</span><span class="nf">group_by</span><span class="p">(</span><span class="o">&</span><span class="nb">method</span><span class="p">(</span><span class="ss">:grouping_criterion</span><span class="p">))</span>
<span class="p">.</span><span class="nf">yield_self</span><span class="p">(</span><span class="o">&</span><span class="nb">method</span><span class="p">(</span><span class="ss">:postprocess</span><span class="p">))</span>
<span class="c1"># which I'd be really happy to see as</span>
<span class="n">some_input</span>
<span class="p">.</span><span class="nf">compact</span>
<span class="p">.</span><span class="nf">map</span><span class="p">(</span><span class="o">&.</span><span class="ss">:process_item</span><span class="p">)</span>
<span class="p">.</span><span class="nf">reject</span><span class="p">(</span><span class="o">&.</span><span class="ss">:spoiled?</span><span class="p">)</span>
<span class="p">.</span><span class="nf">tap</span><span class="p">(</span><span class="o">&.</span><span class="ss">:pp</span><span class="p">)</span>
<span class="p">.</span><span class="nf">group_by</span><span class="p">(</span><span class="o">&.</span><span class="ss">:grouping_criterion</span><span class="p">)</span>
<span class="p">.</span><span class="nf">then</span><span class="p">(</span><span class="o">&.</span><span class="ss">:postprocess</span><span class="p">)</span>
</code></pre>
<p>Having to explicitly state <code>map(&self.:process_item)</code> is much less desirable.</p>
</blockquote>
<p>Just an opinion:</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="n">processed</span> <span class="o">=</span>
<span class="n">some_input</span>
<span class="p">.</span><span class="nf">compact</span>
<span class="p">.</span><span class="nf">map</span> <span class="p">{</span> <span class="o">|</span><span class="n">element</span><span class="o">|</span> <span class="no">ProcessingItem</span><span class="p">.</span><span class="nf">new</span><span class="p">(</span><span class="n">element</span><span class="p">)</span> <span class="p">}</span> <span class="c1"># or `.map(&ProcessingItem.method(:new))`</span>
<span class="p">.</span><span class="nf">reject</span><span class="p">(</span><span class="o">&</span><span class="ss">:spoiled?</span><span class="p">)</span>
<span class="p">.</span><span class="nf">each</span><span class="p">(</span><span class="o">&</span><span class="ss">:pp</span><span class="p">)</span> <span class="c1"># temp debugging statement</span>
<span class="p">.</span><span class="nf">group_by</span><span class="p">(</span><span class="o">&</span><span class="ss">:grouping_criterion</span><span class="p">)</span>
<span class="n">postprocess</span> <span class="n">processed</span>
</code></pre>
<p>Or you can even use <code>ProcessingItems</code> collection class. With itself state and behavior. Instead of bunch of private methods in a processing class with the same (collection) argument.</p> Ruby master - Feature #13581: Syntax sugar for method referencehttps://redmine.ruby-lang.org/issues/13581?journal_id=748702018-11-15T10:09:08Zzverok (Victor Shepelev)zverok.offline@gmail.com
<ul></ul><blockquote>
<p>Just an opinion</p>
</blockquote>
<p>It is funny how when you show some imaginary code, quick-written just to illustrate the point of a language feature, people tend to discuss this code's design approaches instead.</p>
<p>Yes, obviously, in the situation like "several consecutive, algorithmically complex methods working on the same collection" it is <em>typically</em> wise to just wrap collection items. But that has <em>absolutely</em> nothing to do with the point of my example.</p> Ruby master - Feature #13581: Syntax sugar for method referencehttps://redmine.ruby-lang.org/issues/13581?journal_id=748722018-11-15T10:26:41ZAlexWayfer (Alexander Popov)alex.wayfer@gmail.com
<ul></ul><p>zverok (Victor Shepelev) wrote:</p>
<blockquote>
<blockquote>
<p>Just an opinion</p>
</blockquote>
<p>It is funny how when you show some imaginary code, quick-written just to illustrate the point of a language feature, people tend to discuss this code's design approaches instead.</p>
<p>Yes, obviously, in the situation like "several consecutive, algorithmically complex methods working on the same collection" it is <em>typically</em> wise to just wrap collection items. But that has <em>absolutely</em> nothing to do with the point of my example.</p>
</blockquote>
<p>I just try to use good (existing) sides of a language. Ruby already has nice <code>Symbol#to_proc</code> syntax. And yes, different "syntax sugars" allow to use different design approaches (classes vs functions, for example). But sometimes they also allow to create bad practices. I'm not sure, and I'm not against syntax sugar, but… I like solutions for real problems, not imaginary. With knowledge of solutions for imaginary problems we can create these problems later, without resolving them with other approaches.</p> Ruby master - Feature #13581: Syntax sugar for method referencehttps://redmine.ruby-lang.org/issues/13581?journal_id=748732018-11-15T10:58:34Zzverok (Victor Shepelev)zverok.offline@gmail.com
<ul></ul><blockquote>
<p>I like solutions for real problems, not imaginary.</p>
</blockquote>
<p>The <code>map(&method(:local_method))</code> or <code>yield_self(&method(:local_method))</code> pattern is absolutely real and very useful. My point was, we have plenty in our current codebase (and no, they are not "you just need to wrap collection items", my example was exaggerated for the illustrative purposes).</p>
<p>And I can definitely say it brings value for code design and clarity, and will be even more so with <code>map(&.:local_method)</code> syntax.</p> Ruby master - Feature #13581: Syntax sugar for method referencehttps://redmine.ruby-lang.org/issues/13581?journal_id=752042018-11-26T20:10:43Zshevegen (Robert A. Heiler)shevegen@gmail.com
<ul></ul><blockquote>
<p>The map(&method(:local_method)) or yield_self(&method(:local_method)) pattern is absolutely real<br>
and very useful.</p>
</blockquote>
<p>Everyone who suggests something tends to think of it as useful and often pretty too. :-)</p>
<p>I personally have become too picky perhaps. I already don't like yield_self much at all; "then"<br>
is better than yield_self though.</p>
<p>In ruby it is possible to avoid a lot of things and still end up writing pretty code that is<br>
fun.</p>
<blockquote>
<p>My point was, we have plenty in our current codebase</p>
</blockquote>
<p>I think a pretty syntax is great, but it is not necessarily ruby's primary design goal. It is<br>
difficult to say because I am not matz :) but I think matz has said before that ruby should<br>
be fun to use; and solve real problems; and help people. If you look at the safe navigation<br>
operator, this is a good example, in my opinion. Someone had a use case and suggested a<br>
solution to his problem, and matz agreed with the problem description and added the safe<br>
navigation operator.</p>
<p>There are lots of things I myself have not yet used, including the safe navigation operator.<br>
I also have not yet used the -> lambda variant. I no longer use @@variables either. I am<br>
sure other people have different means how to use and approach ruby. What I do use, and<br>
that has been somewhat newish (well not yet 10 years old I think), was the new additional<br>
hash syntax, since it has a net benefit - less to type, e. g.:</p>
<pre><code>:foo => :bar
</code></pre>
<p>versus</p>
<pre><code>foo: :bar
</code></pre>
<p>Especially if I have lots of entries, the second variant is indeed easier to use for me.</p>
<blockquote>
<p>And I can definitely say it brings value for code design and clarity, and will<br>
be even more so with map(&.:local_method) syntax.</p>
</blockquote>
<p>Using this reasoning we can say that EVERY addition is GOOD and USEFUL because we have<br>
more features. But it is not quite like that. More and more features make a language<br>
harder to use and more complicated too. Some features also look strange. For example,<br>
I personally dislike the map(&.:local_method). I don't have an alternative suggestion<br>
that is nice to read, but it is hard for me to visually distinguish between what is<br>
going on there.</p>
<p>Ultimately it is up to matz how he wants to change ruby, but I really don't feel that<br>
in all the discussions the trade off was or is really worth it. This may be up to<br>
personal preferences or habits, yes - but ... I don't know.</p>
<p>When I look at things such as map(&.:local_method) then the original suggestion in<br>
the issue of:</p>
<pre><code>roots = [1, 4, 9].map Math->method
</code></pre>
<p>becomes a LOT cleaner and easier to read. ;)</p>
<p>(Only thing that puts me off is that -> is used in e. g. LPC to invoke methods;<br>
I much prefer just the single "." notation. Do also note that I agree that we<br>
should be able to pass arguments to .map(&) but ... I don't know. It's visually<br>
not very pleasing to my eyes. :\ )</p> Ruby master - Feature #13581: Syntax sugar for method referencehttps://redmine.ruby-lang.org/issues/13581?journal_id=755052018-12-09T22:19:37Zshuber (Sean Huber)
<ul></ul><blockquote>
<p>matz (Yukihiro Matsumoto) wrote:</p>
<blockquote>
<p>Out of <a href="https://bugs.ruby-lang.org/issues/13581#change-69758" class="external">ruby-core:85038</a> candidates, <code>.:</code> looks best to me (followed by <code>:::</code>).<br>
Let me consider it for a while.</p>
<p>Matz.</p>
</blockquote>
</blockquote>
<p><a class="user active user-mention" href="https://redmine.ruby-lang.org/users/13">@matz (Yukihiro Matsumoto)</a> and <a class="user active user-mention" href="https://redmine.ruby-lang.org/users/4">@nobu (Nobuyoshi Nakada)</a></p>
<p>What do you guys think about this alternative syntax? (working proof of concept: <a href="https://github.com/LendingHome/pipe_operator" class="external">https://github.com/LendingHome/pipe_operator</a>)</p>
<pre><code>-9.pipe { abs | Math.sqrt | to_i }
#=> 3
[9, 64].map(&Math.|.sqrt)
#=> [3.0, 8.0]
[9, 64].map(&Math.|.sqrt.to_i.to_s)
#=> ["3", "8"]
"https://api.github.com/repos/ruby/ruby".| do
URI.parse
Net::HTTP.get
JSON.parse.fetch("stargazers_count")
yield_self { |n| "Ruby has #{n} stars" }
Kernel.puts
end
#=> Ruby has 15120 stars
</code></pre>
<p>There's nothing really new/special here - it's just a block of expressions like any other Ruby DSL and the pipe | operator has been around for decades!</p>
<p>The <a href="https://github.com/LendingHome/pipe_operator" class="external">https://github.com/LendingHome/pipe_operator</a> README contains many more examples and the implementation details - I would love to hear your thoughts!</p>
<p>Thanks,<br>
Sean Huber</p> Ruby master - Feature #13581: Syntax sugar for method referencehttps://redmine.ruby-lang.org/issues/13581?journal_id=755112018-12-10T02:25:35Znobu (Nobuyoshi Nakada)nobu@ruby-lang.org
<ul></ul><p>shuber (Sean Huber) wrote:</p>
<blockquote>
<p>What do you guys think about this alternative syntax? (working proof of concept: <a href="https://github.com/LendingHome/pipe_operator" class="external">https://github.com/LendingHome/pipe_operator</a>)</p>
</blockquote>
<p>It conflicts with existing <code>|</code> methods.</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="nb">p</span> <span class="mi">1</span><span class="o">.|</span><span class="mi">2</span> <span class="c1">#=> 3</span>
</code></pre> Ruby master - Feature #13581: Syntax sugar for method referencehttps://redmine.ruby-lang.org/issues/13581?journal_id=755152018-12-10T04:12:20Zshuber (Sean Huber)
<ul></ul><blockquote>
<p>It conflicts with existing <code>|</code> methods.</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="nb">p</span> <span class="mi">1</span><span class="o">.|</span><span class="mi">2</span> <span class="c1">#=> 3</span>
</code></pre>
</blockquote>
<p><a class="user active user-mention" href="https://redmine.ruby-lang.org/users/4">@nobu (Nobuyoshi Nakada)</a> That's just an alias for syntactic sugar - the actual method is named <code>__pipe__</code>! My thinking was that it's pretty similar to how we commonly use <code>send</code> (which can have conflicts in certain domains e.g. delivery services) but it's actually an "alias" of <code>__send__</code> which is double underscored to avoid conflicts. Some objects may have their own definitions of <code>|</code> but we always have <code>pipe</code> or <code>__pipe__</code> available to remove any ambiguity. Does that make sense?</p>
<pre><code>def __pipe__(*args, &block)
Pipe.new(self, *args, &block)
end
alias | __pipe__
alias pipe __pipe__
</code></pre>
<p>Within the context of a <code>__pipe__</code> block we don't have to worry about conflicting <code>|</code> since we "own" that definition:</p>
<pre><code>-9.pipe { abs | Math.sqrt | to_i } #=> 3
</code></pre>
<p>But like you stated, outside of a <code>__pipe__</code> block the definition of <code>|</code> could conflict:</p>
<pre><code>1.|2 #=> 3
</code></pre>
<p>One thought comes to mind though - this "pipe" behavior really only needs to trigger in two cases:</p>
<ol>
<li>pipe <code>|</code> is called with NO arguments e.g. <code>Math.|.sqrt</code>
</li>
<li>pipe <code>|</code> is called with ONLY a block e.g. `"test".| { Marshal.dump | Base64.encode64 }</li>
</ol>
<p>Do you know of any existing implementations of <code>|</code> in the Ruby stdlib that either accept NO arguments or ONLY a block? I believe most if not all expect an argument to be passed? If so then that would make conflicts more rare if it's something we could build logic around!</p> Ruby master - Feature #13581: Syntax sugar for method referencehttps://redmine.ruby-lang.org/issues/13581?journal_id=755732018-12-11T08:28:28Zshuber (Sean Huber)
<ul></ul><p><a class="user active user-mention" href="https://redmine.ruby-lang.org/users/13">@matz (Yukihiro Matsumoto)</a> This <code>pipe_operator</code> syntax actually looks very similar to <a href="https://github.com/matz/streem" class="external">https://github.com/matz/streem</a>!</p>
<pre><code>url.pipe { URI.parse | Net::HTTP.get | JSON.parse }
"https://api.github.com/repos/ruby/ruby".pipe do
URI.parse
Net::HTTP.get
JSON.parse.fetch("stargazers_count")
then { |n| "Ruby has #{n} stars" }
Kernel.puts
end
#=> Ruby has 15120 stars
</code></pre>
<p><a href="https://github.com/LendingHome/pipe_operator" class="external">https://github.com/LendingHome/pipe_operator</a></p> Ruby master - Feature #13581: Syntax sugar for method referencehttps://redmine.ruby-lang.org/issues/13581?journal_id=756782018-12-13T16:58:56Zshuber (Sean Huber)
<ul></ul><p>Also discussing pipe operators in <a href="https://bugs.ruby-lang.org/issues/14392#note-26" class="external">https://bugs.ruby-lang.org/issues/14392#note-26</a></p> Ruby master - Feature #13581: Syntax sugar for method referencehttps://redmine.ruby-lang.org/issues/13581?journal_id=756792018-12-13T17:51:50Zheadius (Charles Nutter)headius@headius.com
<ul></ul><p>Triple <code>:</code> doesn't parse right now and has some synergy with constant references:</p>
<pre><code>obj:::foo # => obj.method(:foo)
</code></pre> Ruby master - Feature #13581: Syntax sugar for method referencehttps://redmine.ruby-lang.org/issues/13581?journal_id=757802018-12-19T11:30:47Zzverok (Victor Shepelev)zverok.offline@gmail.com
<ul></ul><p>From <a href="https://docs.google.com/document/d/1q22gVRNbCIYOQw2djH4UPmT0gxVoBKvjvs0MqX5ILcU/pub" class="external">developer's meeting log</a>:</p>
<blockquote>
<p>2.7 or later<br>
knu: Introducing “…” (as in Lua) would allow for writing this way: ary.each { puts(...) }<br>
Matz: Allowing omission of “self” sounds like a bad idea because that makes each(&:puts) and each(&.:puts) look very similar but act so differently.</p>
</blockquote>
<p>The last Matz's notice makes a lot of sense for me, so I withdraw my petition for <code>self</code>-less operator :)</p> Ruby master - Feature #13581: Syntax sugar for method referencehttps://redmine.ruby-lang.org/issues/13581?journal_id=760212018-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 #13581: Syntax sugar for method referencehttps://redmine.ruby-lang.org/issues/13581?journal_id=827372019-11-20T10:21:16Zznz (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 #13581: Syntax sugar for method referencehttps://redmine.ruby-lang.org/issues/13581?journal_id=955572021-12-23T23:41:10Zhsbt (Hiroshi SHIBATA)hsbt@ruby-lang.org
<ul><li><strong>Project</strong> changed from <i>14</i> to <i>Ruby master</i></li></ul>