Ruby Issue Tracking System: Issueshttps://redmine.ruby-lang.org/https://redmine.ruby-lang.org/favicon.ico?17113305112018-01-24T14:35:58ZRuby Issue Tracking System
Redmine Ruby master - Feature #14392 (Open): Pipe operatorhttps://redmine.ruby-lang.org/issues/143922018-01-24T14:35:58Zdsferreira (Daniel Ferreira)
<p>I would like to see implemented in ruby a pipe operator as we have in elixir.</p>
<p>An example of application I have in mind is this:</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">bar</span><span class="p">(</span><span class="n">var</span><span class="p">)</span>
<span class="nb">puts</span> <span class="err">“</span><span class="no">Hello</span> <span class="c1">#{var}!”</span>
<span class="k">end</span> <span class="o">|></span> <span class="kp">private</span>
<span class="k">def</span> <span class="nf">baz</span><span class="p">(</span><span class="n">arg</span><span class="p">)</span>
<span class="n">bar</span><span class="p">(</span><span class="n">arg</span><span class="p">)</span>
<span class="k">end</span>
<span class="k">end</span>
<span class="n">foo</span> <span class="o">=</span> <span class="no">Foo</span><span class="p">.</span><span class="nf">new</span>
<span class="n">foo</span><span class="p">.</span><span class="nf">baz</span><span class="p">(</span><span class="s2">"Fred"</span><span class="p">)</span> <span class="c1"># => "Hello Fred!"</span>
</code></pre>
<p>It can also help simplify method chains:</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="k">class</span> <span class="nc">Secret</span>
<span class="k">def</span> <span class="nf">initialise</span><span class="p">(</span><span class="n">user</span><span class="p">,</span> <span class="n">password</span><span class="p">)</span>
<span class="vi">@user</span> <span class="o">=</span> <span class="n">user</span>
<span class="vi">@password</span> <span class="o">=</span> <span class="n">password</span>
<span class="k">end</span>
<span class="k">def</span> <span class="nf">second_pass</span><span class="p">(</span><span class="n">encrypted_string</span><span class="p">)</span>
<span class="n">encrypted_string</span><span class="p">.</span><span class="nf">chain_4</span><span class="p">.</span><span class="nf">chain_5</span><span class="p">.</span><span class="nf">chain_6</span>
<span class="k">end</span> <span class="o">|></span> <span class="kp">private</span>
<span class="c1">##</span>
<span class="c1"># Super encryption</span>
<span class="k">def</span> <span class="nf">super_encryption</span>
<span class="vi">@password</span><span class="p">.</span><span class="nf">chain_1</span><span class="p">.</span><span class="nf">chain_2</span><span class="p">.</span><span class="nf">chain_3</span>
<span class="o">|></span> <span class="n">second_pass</span>
<span class="k">end</span> <span class="o">|></span> <span class="kp">public</span>
<span class="k">end</span>
</code></pre>
<p>And also simplify codes like this:</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">bar</span><span class="p">(</span><span class="o">*</span><span class="n">args</span><span class="p">)</span>
<span class="n">baz</span> <span class="o">=</span> <span class="n">args</span><span class="p">.</span><span class="nf">select</span> <span class="p">{</span> <span class="o">|</span><span class="n">arg</span><span class="o">|</span> <span class="n">arg</span> <span class="o">=~</span> <span class="sr">/regex/</span> <span class="p">}.</span><span class="nf">first</span>
<span class="n">good?</span><span class="p">(</span><span class="n">baz</span><span class="p">)</span>
<span class="k">end</span>
<span class="kp">public</span> <span class="ss">:bar</span>
<span class="k">def</span> <span class="nf">good</span><span class="p">(</span><span class="n">arg</span><span class="p">)</span>
<span class="n">arg</span><span class="p">.</span><span class="nf">to_s</span><span class="p">.</span><span class="nf">size</span> <span class="o">></span> <span class="mi">10</span>
<span class="k">end</span>
<span class="kp">private</span> <span class="ss">:good</span>
<span class="k">end</span>
</code></pre>
<p>to become:</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="k">class</span> <span class="nc">Foo</span>
<span class="c1">##</span>
<span class="c1"># Bar public method.</span>
<span class="k">def</span> <span class="nf">bar</span><span class="p">(</span><span class="o">*</span><span class="n">args</span><span class="p">)</span>
<span class="n">args</span><span class="p">.</span><span class="nf">select</span> <span class="p">{</span> <span class="o">|</span><span class="n">arg</span><span class="o">|</span> <span class="n">arg</span> <span class="o">=~</span> <span class="sr">/regex/</span> <span class="p">}.</span><span class="nf">first</span>
<span class="o">|></span> <span class="n">good?</span>
<span class="k">end</span> <span class="o">|></span> <span class="kp">public</span>
<span class="k">def</span> <span class="nf">good</span><span class="p">(</span><span class="n">arg</span><span class="p">)</span>
<span class="n">arg</span><span class="p">.</span><span class="nf">to_s</span><span class="p">.</span><span class="nf">size</span> <span class="o">></span> <span class="mi">10</span>
<span class="k">end</span> <span class="o">|></span> <span class="kp">private</span>
<span class="k">end</span>
</code></pre>
<p>Lots of local variables would be saved and I would expect some performance improvements with that.</p> Ruby master - Feature #14336 (Rejected): Create new method String#symbol? and deprecate Symbol classhttps://redmine.ruby-lang.org/issues/143362018-01-08T09:57:29Zdsferreira (Daniel Ferreira)
<p>From the discussions on the three previous issues related to the String vs Symbol subject (<a href="https://bugs.ruby-lang.org/issues/5964" class="external">5964</a>, <a href="https://bugs.ruby-lang.org/issues/7792" class="external">7792</a>, <a href="https://bugs.ruby-lang.org/issues/14277" class="external">14277</a>) there are some conclusions we can assume:</p>
<ul>
<li>Current String vs Symbol is not the ideal scenario. See: Matz and Koichi comments.</li>
<li>Current philosophy is to use Symbols as identifiers and Strings when strings are needed.</li>
<li>Current situation is that Symbols are being used in many code bases as strings except for strings that really need the String methods.</li>
<li>Current situation is that we are designing APIs to handle both String and Symbol inputs forcing an overhead of API development.</li>
</ul>
<p>I propose the deprecation of <code>Symbol</code> class and the introduction of <code>String#symbol?</code>.</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="n">foo</span> <span class="o">=</span> <span class="ss">:foo</span>
<span class="n">foo</span><span class="p">.</span><span class="nf">class</span> <span class="c1"># => String</span>
<span class="n">foo</span><span class="p">.</span><span class="nf">symbol?</span> <span class="c1"># => true</span>
<span class="n">bar</span> <span class="o">=</span> <span class="s2">"bar"</span>
<span class="n">bar</span><span class="p">.</span><span class="nf">class</span> <span class="c1"># => String</span>
<span class="n">bar</span><span class="p">.</span><span class="nf">symbol?</span> <span class="c1"># => false</span>
</code></pre>
<p>For backwards compatibility transition path I propose:</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="k">class</span> <span class="nc">Symbol</span>
<span class="k">def</span> <span class="nc">self</span><span class="o">.</span><span class="nf">===</span><span class="p">(</span><span class="n">var</span><span class="p">)</span>
<span class="nb">warn</span> <span class="p">(</span><span class="s2">"Warning message regarding deprecated class"</span><span class="p">)</span>
<span class="k">if</span> <span class="n">var</span><span class="p">.</span><span class="nf">class</span> <span class="o">==</span> <span class="no">Symbol</span>
<span class="kp">true</span>
<span class="k">elsif</span> <span class="n">var</span><span class="p">.</span><span class="nf">class</span> <span class="o">==</span> <span class="no">String</span> <span class="o">&&</span> <span class="n">var</span><span class="p">.</span><span class="nf">symbol?</span>
<span class="kp">true</span>
<span class="k">else</span>
<span class="kp">false</span>
<span class="k">end</span>
<span class="k">end</span>
<span class="k">end</span>
<span class="k">class</span> <span class="nc">String</span>
<span class="k">def</span> <span class="nf">is_a?</span><span class="p">(</span><span class="n">klass</span><span class="p">)</span>
<span class="k">case</span> <span class="n">klass</span>
<span class="k">when</span> <span class="no">String</span>
<span class="kp">true</span>
<span class="k">when</span> <span class="no">Symbol</span>
<span class="nb">self</span><span class="p">.</span><span class="nf">symbol?</span>
<span class="k">else</span>
<span class="kp">false</span>
<span class="k">end</span>
<span class="k">end</span>
<span class="k">end</span>
</code></pre> Ruby master - Feature #14277 (Rejected): Improve strings vs symbols ambiguityhttps://redmine.ruby-lang.org/issues/142772018-01-03T04:06:47Zdsferreira (Daniel Ferreira)
<p>This is the ambiguity:</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="kp">alias_method</span> <span class="ss">:foo</span><span class="p">,</span> <span class="ss">:bar</span>
<span class="kp">alias_method</span> <span class="s2">"foo"</span><span class="p">,</span> <span class="s2">"bar"</span>
</code></pre>
<p>Ruby developers are using strings and symbols interchangeably as if they were the same thing.<br>
This is happening in ruby core, in ruby gems and in ruby applications.</p>
<hr>
<p>This discussion as started 5 years ago in two separate feature requests (both rejected):</p>
<ul>
<li><a href="https://bugs.ruby-lang.org/issues/5964" class="external">5964</a></li>
<li><a href="https://bugs.ruby-lang.org/issues/7792" class="external">7792</a></li>
</ul>
<p>I believe ruby will be much better once the ambiguity between strings and symbols is resolved for good<br>
and ruby 3.0 is a very good opportunity to do so.</p>
<p>From further discussions I got a light of hope that a solution may be accepted if certain conditions are met.<br>
Specifically, a clear transition path that could lead the community towards the break of backwards compatibility.</p>
<p>In the issue <a href="https://bugs.ruby-lang.org/issues/7792" class="external">Make symbols and strings the same thing</a></p>
<p>ko1 (Koichi Sasada) wrote:</p>
<blockquote>
<p>Please consider transition path for users who are using symbol and string difference like:</p>
<p>key = ...<br>
...<br>
when key<br>
case String<br>
...<br>
case Symbol<br>
...<br>
end<br>
How to find out such programs?</p>
</blockquote>
<p>he also wrote:</p>
<blockquote>
<p>If you (or someone) find out any good transition path, we think we can consider again.</p>
</blockquote>
<p>Can we discuss here what are the rules that would allow the transition path solution to be accepted?</p>
<p>Also what solutions for the problem are we envisioning?</p>
<ol>
<li>Use current symbols syntax as yet another strings syntax and stop using Symbols?</li>
<li>Use current symbols syntax as yet another strings syntax and start use Symbols with a new syntax?</li>
<li>Use current symbols syntax as yet another strings syntax and use Symbols purely as a class?</li>
</ol>
<p>From the challenge presented by Koichi I understand that the transition path to be accepted must allow the current code to raise a warning for the situation where the Symbol is not anymore a Symbol but a String.</p>
<p>Is this assumption correct?</p>
<p>If this is the case then all we need is to make <code>String::===(foo)</code> and <code>Symbol::===(foo)</code> to raise warnings every time <code>foo</code> is a string and it was created using former symbol syntax.</p>
<p>This means the <code>foo</code> object needs to contain encapsulated the information of the syntax used to define it.</p>
<p>Any drawbacks?</p>
<p>NOTE: (I'm only considering solutions 2. and 3. for the purpose of this analysis. Meaning Symbol class will still exist.)</p> Ruby master - Feature #14276 (Open): Ruby core debugger APIhttps://redmine.ruby-lang.org/issues/142762018-01-03T02:52:04Zdsferreira (Daniel Ferreira)
<p>I would like to propose the creation of a ruby core minimal API for a Debugger.</p>
<p>Historically we have been relying on gems as providers of debug functionality.<br>
This has caused problems with debugger APIs being broken and the debugger gems being outdated by ruby releases.<br>
This happened in the transitions from 1.8.* to 1.9.* and 1.9.* to 2.**</p>
<p>Currently ruby community relies mostly on <em>byebug</em> gem (+ pry) for debugging purposes.</p>
<p>Recently a new bug <a href="https://bugs.ruby-lang.org/issues/14226" class="external">14226</a> was raised due to changes in ruby internals that broke <em>byebug</em>.</p>
<p>I consider that the debugger should be a core part of a language like ruby.<br>
Developing production code without an available debugger is not very manageable.</p>
<p>For this reason I believe we should have a way of guaranteeing that each ruby release will not break the debugger.</p>
<p>Also having full control of the debugger API is very convenient for future purposes.<br>
This way third party entities can rely on it to develop productivity tools.</p>
<p>I see two ways we can accomplish this:</p>
<ul>
<li>Defining core Debug API namespace where we would create the minimal interface for ruby core debug functionality (Not sure if only cruby or a broader API adopted and designed in collaboration with the other ruby implementations).</li>
<li>Creating debug gem in standard lib with the same purpose. Having the guarantee that the unit tests will run for every ruby release.</li>
</ul>
<p>The main goal in my mind would be to have a bare minimum (TDD?) development environment available upon ruby installation<br>
with each bare minimum API providing the base functionality to allow the development of full fledged solutions capable of rivaling with the best solutions in the market.<br>
For that goal I would include here for consideration the same approach for other functionalities such as:</p>
<ul>
<li>Coverage</li>
<li>Documentation</li>
<li>Benchmarks</li>
<li>Tests</li>
<li>Performance</li>
<li>Linter</li>
<li>?</li>
</ul>
<p>I believe we have currently a good situation with regards to:</p>
<ul>
<li>Documentation (Rdoc)</li>
<li>Tests (Minitest)</li>
</ul>
<p>Why not try to replicate those examples for the remaining areas?<br>
Are documentation and tests so much different from the rest?</p>
<p>If we succeeded to do that we could present ruby to the new comer with a simpler development environment easing the entry level.<br>
We could put simple documentation in ruby-lang.org to show how to achieve a professional development workflow with ruby with no fuss.</p>
<p>A full TDD environment available upon installation it is a great marketing headline in my perspective.</p>
<p>Just to finalise.<br>
The goal here is not to have ruby core replacing the existing gems.<br>
The goal is to give a clear path for these gems while allowing others to develop even further in top of a sound base<br>
without worries regarding future support on the APIs being used.</p> Ruby master - Bug #12412 (Rejected): Extend safe navigation operatorhttps://redmine.ruby-lang.org/issues/124122016-05-22T05:45:42Zdsferreira (Daniel Ferreira)
<p>I wonder if we couldn't extend the safe navigation operator to work with any object rather than just nil.</p>
<p>I tend to still use this kind of code in some scenarios, specially when I work with objects with dynamic interfaces or arguments with different possible object types:</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">bar</span><span class="p">(</span><span class="n">baz</span><span class="p">)</span>
<span class="k">if</span> <span class="n">baz</span><span class="p">.</span><span class="nf">respond_to?</span><span class="p">(</span><span class="ss">:qux</span><span class="p">)</span>
<span class="k">return</span> <span class="n">baz</span><span class="p">.</span><span class="nf">qux</span>
<span class="k">end</span>
<span class="s1">'whatever'</span>
<span class="k">end</span>
<span class="k">end</span>
</code></pre>
<p>What if we extend the safe navigation operator to work with any kind of object?<br>
If it doesn't respond to the method it would return nil like this:</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">bar</span><span class="p">(</span><span class="n">baz</span><span class="p">)</span>
<span class="n">baz</span><span class="o">&</span><span class="p">.</span><span class="nf">qux</span> <span class="o">||</span> <span class="s1">'whatever'</span>
<span class="k">end</span>
<span class="k">end</span>
</code></pre>
<p>In order to not break backwards compatibility we should keep the current behaviour as well so the rational would be:</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="kp">nil</span><span class="o">&</span><span class="p">.</span><span class="nf">any_method</span>
<span class="c1"># => nil</span>
<span class="n">foo</span><span class="o">&</span><span class="p">.</span><span class="nf">non_responding_method</span>
<span class="c1"># => nil</span>
</code></pre> Ruby master - Bug #12376 (Rejected): No error for elseif conditionhttps://redmine.ruby-lang.org/issues/123762016-05-13T10:41:06Zdsferreira (Daniel Ferreira)
<p>Something I have been for a long time wondering about.<br>
I don't know if this is a parsing problem or not but for me it seems like it is.</p>
<p>Replication:</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="err">$</span> <span class="n">irb</span>
<span class="o">></span> <span class="no">RUBY_VERSION</span>
<span class="o">=></span> <span class="s1">'2.3.0'</span>
<span class="o">></span> <span class="n">a</span> <span class="o">=</span> <span class="mi">1</span>
<span class="o">></span> <span class="k">if</span> <span class="n">a</span> <span class="o">==</span> <span class="mi">2</span>
<span class="o">></span> <span class="nb">puts</span> <span class="mi">2</span>
<span class="o">></span> <span class="k">elsif</span> <span class="n">a</span> <span class="o">==</span> <span class="mi">3</span>
<span class="o">></span> <span class="nb">puts</span> <span class="mi">3</span>
<span class="o">></span> <span class="n">elseif</span> <span class="n">a</span> <span class="o">==</span> <span class="mi">1</span>
<span class="o">></span> <span class="nb">puts</span> <span class="mi">1</span>
<span class="o">></span> <span class="k">else</span>
<span class="o">></span> <span class="nb">puts</span> <span class="mi">0</span>
<span class="o">></span> <span class="k">end</span>
<span class="mi">0</span>
<span class="o">=></span> <span class="kp">nil</span>
</code></pre>
<p>Shouldn't we have a parse error triggered here?<br>
We can replace <em>elseif</em> for any other instruction like <em>foo</em> for instance.</p>
<p>I believe this behaviour is around for a long time.</p> Ruby master - Bug #12370 (Rejected): require 'mkmf' changes Object#respond_to? behaviour https://redmine.ruby-lang.org/issues/123702016-05-11T14:25:59Zdsferreira (Daniel Ferreira)
<p>Replication steps:</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="err">$</span> <span class="n">irb</span>
<span class="o">></span> <span class="no">RUBY_VERSION</span>
<span class="o">=></span> <span class="s1">'2.3.0'</span>
<span class="o">></span> <span class="nb">require</span> <span class="s1">'yaml'</span>
<span class="o">></span> <span class="no">YAML</span><span class="p">.</span><span class="nf">public_method_defined?</span><span class="p">(</span><span class="ss">:configuration</span><span class="p">)</span>
<span class="o">=></span> <span class="kp">false</span>
<span class="o">></span> <span class="no">YAML</span><span class="p">.</span><span class="nf">respond_to?</span><span class="p">(</span><span class="ss">:configuration</span><span class="p">)</span>
<span class="o">=></span> <span class="kp">false</span>
<span class="o">></span> <span class="nb">require</span> <span class="s1">'mkmf'</span>
<span class="o">></span> <span class="no">YAML</span><span class="p">.</span><span class="nf">public_method_defined?</span><span class="p">(</span><span class="ss">:configuration</span><span class="p">)</span>
<span class="o">=></span> <span class="kp">false</span>
<span class="o">></span> <span class="no">YAML</span><span class="p">.</span><span class="nf">respond_to?</span><span class="p">(</span><span class="ss">:configuration</span><span class="p">)</span>
<span class="o">=></span> <span class="kp">true</span>
</code></pre>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="no">Object</span><span class="p">.</span><span class="nf">constants</span> <span class="k">do</span> <span class="o">|</span><span class="n">constant</span><span class="o">|</span>
<span class="n">constant</span><span class="p">.</span><span class="nf">respond_to?</span><span class="p">(</span><span class="ss">:configuration</span><span class="p">)</span> <span class="o">==></span> <span class="kp">true</span>
<span class="k">end</span>
</code></pre>
<p>--Also there is a different behaviour for core classes over library or gem classes and/or modules under Object namespace.--<br>
Wrong: It is a difference between modules and classes which is fine!<br>
See below on update #8.</p>
<p>The changed behaviour is triggered by:</p>
<p>mkmf.rb:2718 =></p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="kp">include</span> <span class="no">MakeMakefile</span>
</code></pre> Ruby master - Feature #9992 (Open): Access Modifiers (Internal Interfaces)https://redmine.ruby-lang.org/issues/99922014-06-28T19:05:49Zdsferreira (Daniel Ferreira)
<p>Hi,</p>
<p>I would like to discuss with you the concept of Internal Interfaces.</p>
<p>Currently ruby offers three access modifiers choices to set methods visibility:</p>
<ul>
<li>public</li>
<li>protected</li>
<li>private</li>
</ul>
<p>Public methods define what we may call the Public Interface.<br>
Private methods are private to the class and its subclasses.<br>
Protected methods are public for the subclasses.</p>
<p>I would like to work with a new access modifier that would allow the creation of Internal methods.</p>
<p>Internal methods would be object methods that could only be called within the namespace.</p>
<p>Ex:</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="k">module</span> <span class="nn">Foo</span><span class="p">;</span> <span class="k">end</span>
<span class="k">class</span> <span class="nc">Foo::Bar</span>
<span class="k">def</span> <span class="nf">baz</span>
<span class="nb">puts</span> <span class="err">‘</span><span class="n">baz</span><span class="err">’</span>
<span class="k">end</span>
<span class="n">internal</span> <span class="ss">:baz</span>
<span class="k">end</span>
<span class="k">class</span> <span class="nc">Foo::Qux</span>
<span class="k">def</span> <span class="nf">baz</span>
<span class="o">::</span><span class="no">Foo</span><span class="o">::</span><span class="no">Bar</span><span class="p">.</span><span class="nf">new</span><span class="p">.</span><span class="nf">baz</span>
<span class="k">end</span>
<span class="kp">public</span> <span class="ss">:baz</span>
<span class="k">end</span>
</code></pre>
<p>What about this use case:</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="k">module</span> <span class="nn">Foo</span><span class="p">;</span> <span class="k">end</span>
<span class="c1">##</span>
<span class="c1"># Template class</span>
<span class="c1">#</span>
<span class="c1"># ==== Example</span>
<span class="c1"># </span>
<span class="c1"># Foo::SubClass.run(:arg1)</span>
<span class="c1"># #=> ...</span>
<span class="k">class</span> <span class="nc">Foo::Base</span>
<span class="k">def</span> <span class="nf">initialize</span><span class="p">(</span><span class="n">arg</span><span class="p">)</span>
<span class="vi">@arg</span> <span class="o">=</span> <span class="n">arg</span>
<span class="k">end</span>
<span class="k">def</span> <span class="nc">self</span><span class="o">.</span><span class="nf">run</span><span class="p">(</span><span class="n">arg</span><span class="p">)</span>
<span class="nb">self</span><span class="p">.</span><span class="nf">new</span><span class="p">(</span><span class="n">arg</span><span class="p">).</span><span class="nf">perform</span>
<span class="k">end</span>
<span class="nb">public_class_method</span> <span class="ss">:run</span>
<span class="c1">##</span>
<span class="c1"># Override abstract method</span>
<span class="k">def</span> <span class="nf">perform</span>
<span class="k">raise</span> <span class="no">NotImplementedError</span>
<span class="k">end</span>
<span class="n">internal</span> <span class="ss">:perform</span>
<span class="k">end</span>
<span class="c1">##</span>
<span class="c1"># Test subclass.</span>
<span class="c1"># </span>
<span class="c1"># ==== Example</span>
<span class="c1">#</span>
<span class="c1"># Foo::Bar.run("Hello!")</span>
<span class="c1"># # => My argument is Hello!</span>
<span class="k">class</span> <span class="nc">Foo::Bar</span> <span class="o"><</span> <span class="no">Foo</span><span class="o">::</span><span class="no">Base</span>
<span class="k">def</span> <span class="nf">perform</span>
<span class="nb">puts</span> <span class="s2">"My argument is: "</span> <span class="o">+</span> <span class="vi">@arg</span>
<span class="k">end</span>
<span class="n">internal</span> <span class="ss">:perform</span>
<span class="k">end</span>
</code></pre>
<p>Is this something that we can think about in a future implementation of ruby?<br>
An extra feature that would not break backward compatibility.</p>
<p>Cheers,<br>
Daniel</p>