https://bugs.ruby-lang.org/https://bugs.ruby-lang.org/favicon.ico?17097754782019-05-21T08:16:17ZRuby Issue Tracking SystemRuby master - Feature #15864: Proposal: Add methods to determine if it is an infinite rangehttps://bugs.ruby-lang.org/issues/15864?journal_id=781002019-05-21T08:16:17Zshevegen (Robert A. Heiler)shevegen@gmail.com
<ul></ul><p>I think the proposal makes sense. The method names are a bit odd though.</p>
<p>I have no huge qualms with the inf* related methods, such as infinite? or<br>
finite? although it reads a bit odd; but I think that .beginless? and<br>
.endless? are very clumsy names.</p>
<p>Unfortunately I do not have better alternative suggestions either.</p>
<p>Perhaps it could suffice to only add e. g. ".infinite?" and we may not<br>
even need ".finite?".</p>
<p>The use case on the other hand is clear to me, IMO, in particular<br>
"(1..).size return Infinity, but ("a"..).size return nil." so it<br>
would make sense to give ruby users the ability to check for<br>
infinite in advance, rather than check for nil lateron.</p>
<blockquote>
<p>I think that there is no relation between Float::INFINITY and infinite Range</p>
</blockquote>
<p>I guess a/any concept of infinity should not necessarily be intrinsicalled<br>
tied down to a particular constant (e. g. Float::INFINITY) per se; in the latter<br>
case it would seem more like an implementation detail (to me), rather than a<br>
more general concept for/of infinity.</p> Ruby master - Feature #15864: Proposal: Add methods to determine if it is an infinite rangehttps://bugs.ruby-lang.org/issues/15864?journal_id=781102019-05-21T18:58:26ZEregon (Benoit Daloze)
<ul></ul><p>Why is <code>range.begin.nil? || range.end.nil?</code> not enough to check if beginless or endless Range?</p>
<p>Maybe we should integrate beginless/endless in pattern matching?</p>
<p>The use-case can be simplified quite a bit if we can assume <code>false</code> is not used as a Range endpoint:</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="k">def</span> <span class="nf">search_in</span><span class="p">(</span><span class="n">range</span><span class="p">)</span>
<span class="n">query</span> <span class="o">=</span> <span class="s2">"/search"</span>
<span class="k">if</span> <span class="n">range</span><span class="p">.</span><span class="nf">begin</span> <span class="o">&&</span> <span class="n">range</span><span class="p">.</span><span class="nf">end</span>
<span class="s2">"</span><span class="si">#{</span><span class="n">query</span><span class="si">}</span><span class="s2">?from=</span><span class="si">#{</span><span class="n">range</span><span class="p">.</span><span class="nf">begin</span><span class="si">}</span><span class="s2">&to=</span><span class="si">#{</span><span class="n">range</span><span class="p">.</span><span class="nf">end</span><span class="si">}</span><span class="s2">"</span>
<span class="k">elsif</span> <span class="n">range</span><span class="p">.</span><span class="nf">end</span>
<span class="s2">"</span><span class="si">#{</span><span class="n">query</span><span class="si">}</span><span class="s2">?to=</span><span class="si">#{</span><span class="n">range</span><span class="p">.</span><span class="nf">end</span><span class="si">}</span><span class="s2">"</span>
<span class="k">elsif</span> <span class="n">range</span><span class="p">.</span><span class="nf">begin</span>
<span class="s2">"</span><span class="si">#{</span><span class="n">query</span><span class="si">}</span><span class="s2">?from=</span><span class="si">#{</span><span class="n">range</span><span class="p">.</span><span class="nf">begin</span><span class="si">}</span><span class="s2">"</span>
<span class="k">else</span>
<span class="n">query</span>
<span class="k">end</span>
<span class="k">end</span>
</code></pre>
<p>I think <code>infinite?</code> is a different concept, which already exists as Numeric#infinite?, and should definitely handle the Float::INFINITY case if introduced.</p>
<p>I think these are probably bugs:</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="nb">p</span> <span class="p">(</span><span class="s2">"a"</span><span class="o">..</span><span class="p">).</span><span class="nf">size</span> <span class="c1"># => nil</span>
<span class="nb">p</span> <span class="p">(</span><span class="o">..</span><span class="s2">"z"</span><span class="p">).</span><span class="nf">size</span> <span class="c1"># => nil</span>
</code></pre>
<p>and should return infinity.</p> Ruby master - Feature #15864: Proposal: Add methods to determine if it is an infinite rangehttps://bugs.ruby-lang.org/issues/15864?journal_id=781122019-05-21T23:13:21Zmame (Yusuke Endoh)mame@ruby-lang.org
<ul></ul><p>I have no strong opinion to the proposal itself, but I'm also skeptical to the motivating example. I'd like to write:</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="k">def</span> <span class="nf">search_in</span><span class="p">(</span><span class="n">range</span><span class="p">)</span>
<span class="n">path</span> <span class="o">=</span> <span class="s2">"/search"</span>
<span class="n">query</span> <span class="o">=</span> <span class="p">[]</span>
<span class="n">query</span> <span class="o"><<</span> <span class="s2">"from=</span><span class="si">#{</span> <span class="n">range</span><span class="p">.</span><span class="nf">begin</span> <span class="si">}</span><span class="s2">"</span> <span class="k">if</span> <span class="n">range</span><span class="p">.</span><span class="nf">begin</span>
<span class="n">query</span> <span class="o"><<</span> <span class="s2">"to=</span><span class="si">#{</span> <span class="n">range</span><span class="p">.</span><span class="nf">end</span> <span class="si">}</span><span class="s2">"</span> <span class="k">if</span> <span class="n">range</span><span class="p">.</span><span class="nf">end</span>
<span class="n">query</span><span class="p">.</span><span class="nf">empty?</span> <span class="p">?</span> <span class="n">path</span> <span class="p">:</span> <span class="n">path</span> <span class="o">+</span> <span class="s2">"?"</span> <span class="o">+</span> <span class="n">query</span><span class="p">.</span><span class="nf">join</span><span class="p">(</span><span class="s2">"&"</span><span class="p">)</span>
<span class="k">end</span>
</code></pre>
<p>I have no idea when we want to check if a range is just infinite without checking the actual values.</p>
<p>Currently, <code>("a"..).size #=> nil</code> is intended because <code>("a".."z").size #=> nil</code>. According to <a class="user active user-mention" href="https://bugs.ruby-lang.org/users/182">@marcandre (Marc-Andre Lafortune)</a> <a href="https://bugs.ruby-lang.org/issues/14699#change-71575" class="external">https://bugs.ruby-lang.org/issues/14699#change-71575</a>, there is no special reason why <code>("a".."z").size</code> returns nil. So after <code>("a".."z").size</code> is implemented correctly, I agree that <code>("a"..).size</code> should return infinity.</p> Ruby master - Feature #15864: Proposal: Add methods to determine if it is an infinite rangehttps://bugs.ruby-lang.org/issues/15864?journal_id=781132019-05-22T01:14:07Zosyo (manga osyo)
<ul></ul><p>Thanks comments!</p>
<blockquote>
<p>I think infinite? is a different concept, which already exists as Numeric#infinite?, and should definitely handle the Float::INFINITY case if introduced</p>
</blockquote>
<p>I also considered the following implementation.</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="k">class</span> <span class="nc">Range</span>
<span class="k">def</span> <span class="nf">beginless?</span>
<span class="nb">self</span><span class="p">.</span><span class="nf">begin</span><span class="p">.</span><span class="nf">nil?</span> <span class="o">||</span> <span class="p">(</span><span class="nb">self</span><span class="p">.</span><span class="nf">begin</span><span class="p">.</span><span class="nf">respond_to?</span><span class="p">(</span><span class="ss">:infinite?</span><span class="p">)</span> <span class="o">&&</span> <span class="nb">self</span><span class="p">.</span><span class="nf">begin</span><span class="p">.</span><span class="nf">infinite?</span><span class="p">)</span>
<span class="k">end</span>
<span class="k">end</span>
</code></pre>
<p>MEMO: <code>Numeric#infinite?</code> should also consider returning something other than <code>true / false</code>.</p>
<blockquote>
<p>So after ("a".."z").size is implemented correctly, I agree that ("a"..).size should return infinity.</p>
</blockquote>
<p>I'm concerned about the performance of <code>("a".."z").size</code>.<br>
Can implement <code>("a".."z").size</code> with<code> O(1)</code> ?</p> Ruby master - Feature #15864: Proposal: Add methods to determine if it is an infinite rangehttps://bugs.ruby-lang.org/issues/15864?journal_id=781142019-05-22T01:22:22Zosyo (manga osyo)
<ul></ul><p>How about doing this?</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="p">(</span><span class="s2">"a"</span><span class="o">..</span><span class="s2">"z"</span><span class="p">).</span><span class="nf">size</span> <span class="c1"># => nil</span>
<span class="p">(</span><span class="o">..</span><span class="s2">"z"</span><span class="p">).</span><span class="nf">size</span> <span class="c1"># => Infinity</span>
<span class="p">(</span><span class="s2">"a"</span><span class="o">..</span><span class="p">).</span><span class="nf">size</span> <span class="c1"># => Infinity</span>
</code></pre> Ruby master - Feature #15864: Proposal: Add methods to determine if it is an infinite rangehttps://bugs.ruby-lang.org/issues/15864?journal_id=781172019-05-22T02:54:45Zmame (Yusuke Endoh)mame@ruby-lang.org
<ul></ul><p>Do you mean that <code>Range#infinite?</code> is no longer needed if the behavior of <code>("a"..).size</code> is changed? If not, I think it is a different topic from this ticket.</p> Ruby master - Feature #15864: Proposal: Add methods to determine if it is an infinite rangehttps://bugs.ruby-lang.org/issues/15864?journal_id=781412019-05-22T08:56:57Zmatz (Yukihiro Matsumoto)matz@ruby.or.jp
<ul></ul><p>I am against having <code>finite?</code> or <code>infinite?</code> methods. I don't think there's use-case for those methods.<br>
Meanwhile, I see the small possibility for the usage of <code>beginless?</code> and <code>endless?</code> methods. But I don't like the names.</p>
<p>Matz.</p> Ruby master - Feature #15864: Proposal: Add methods to determine if it is an infinite rangehttps://bugs.ruby-lang.org/issues/15864?journal_id=809012019-08-22T00:05:24Zmame (Yusuke Endoh)mame@ruby-lang.org
<ul><li><strong>Related to</strong> <i><a class="issue tracker-5 status-1 priority-4 priority-default" href="/issues/16114">Misc #16114</a>: Naming of "beginless range"</i> added</li></ul> Ruby master - Feature #15864: Proposal: Add methods to determine if it is an infinite rangehttps://bugs.ruby-lang.org/issues/15864?journal_id=809032019-08-22T00:07:38Zmrkn (Kenta Murata)muraken@gmail.com
<ul></ul><p>Other candidates from mathematical terms:</p>
<ul>
<li>
<code>unbounded?</code> for checking whether <code>begin</code> or <code>end</code> is <code>nil</code>
</li>
<li>
<code>lower_unbounded?</code>, <code>left_unbounded?</code>, or <code>unbounded_below?</code> for checking whether <code>begin</code> is <code>nil</code>
</li>
<li>
<code>upper_unbounded?</code>, <code>right_unbounded?</code>, or <code>unbounded_above?</code> for checking whether <code>end</code> is <code>nil</code>
</li>
</ul> Ruby master - Feature #15864: Proposal: Add methods to determine if it is an infinite rangehttps://bugs.ruby-lang.org/issues/15864?journal_id=809062019-08-22T03:23:04Zsawa (Tsuyoshi Sawada)
<ul></ul><p>Having negative meaning in the method name would make it complicated. Having <code>begin?</code> and <code>end?</code> instead of <code>beginless?</code> and <code>endless?</code> would be more natural, and easy to comprehend.</p>
<p>In fact, the given use case:</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="k">def</span> <span class="nf">search_in</span><span class="p">(</span><span class="n">range</span><span class="p">)</span>
<span class="n">query</span> <span class="o">=</span> <span class="s2">"/search"</span>
<span class="k">if</span> <span class="n">range</span><span class="p">.</span><span class="nf">finite?</span>
<span class="s2">"</span><span class="si">#{</span><span class="n">query</span><span class="si">}</span><span class="s2">?from=</span><span class="si">#{</span><span class="n">range</span><span class="p">.</span><span class="nf">begin</span><span class="si">}</span><span class="s2">&to=</span><span class="si">#{</span><span class="n">range</span><span class="p">.</span><span class="nf">end</span><span class="si">}</span><span class="s2">"</span>
<span class="k">elsif</span> <span class="n">range</span><span class="p">.</span><span class="nf">beginless?</span>
<span class="s2">"</span><span class="si">#{</span><span class="n">query</span><span class="si">}</span><span class="s2">?to=</span><span class="si">#{</span><span class="n">range</span><span class="p">.</span><span class="nf">end</span><span class="si">}</span><span class="s2">"</span>
<span class="k">elsif</span> <span class="n">range</span><span class="p">.</span><span class="nf">endless?</span>
<span class="s2">"</span><span class="si">#{</span><span class="n">query</span><span class="si">}</span><span class="s2">?from=</span><span class="si">#{</span><span class="n">range</span><span class="p">.</span><span class="nf">begin</span><span class="si">}</span><span class="s2">"</span>
<span class="k">else</span>
<span class="n">query</span>
<span class="k">end</span>
<span class="k">end</span>
</code></pre>
<p>is not straightforward; it is twisted. The intent of the <code>elsif range.beginless?</code> condition is actually to check whether the end exists, not whether the beginning is absent. Using <code>begin?</code> and <code>end?</code>, a more straightforward code can be written as follows (I also believe your last condition is redundant, and there is no case that corresponds to your <code>else</code> case).</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="k">def</span> <span class="nf">search_in</span><span class="p">(</span><span class="n">range</span><span class="p">)</span>
<span class="n">query</span> <span class="o">=</span> <span class="s2">"/search"</span>
<span class="k">if</span> <span class="n">range</span><span class="p">.</span><span class="nf">finite?</span>
<span class="s2">"</span><span class="si">#{</span><span class="n">query</span><span class="si">}</span><span class="s2">?from=</span><span class="si">#{</span><span class="n">range</span><span class="p">.</span><span class="nf">begin</span><span class="si">}</span><span class="s2">&to=</span><span class="si">#{</span><span class="n">range</span><span class="p">.</span><span class="nf">end</span><span class="si">}</span><span class="s2">"</span>
<span class="k">elsif</span> <span class="n">range</span><span class="p">.</span><span class="nf">end?</span>
<span class="s2">"</span><span class="si">#{</span><span class="n">query</span><span class="si">}</span><span class="s2">?to=</span><span class="si">#{</span><span class="n">range</span><span class="p">.</span><span class="nf">end</span><span class="si">}</span><span class="s2">"</span>
<span class="k">else</span> <span class="c1"># `range.begin?` is always `true`</span>
<span class="s2">"</span><span class="si">#{</span><span class="n">query</span><span class="si">}</span><span class="s2">?from=</span><span class="si">#{</span><span class="n">range</span><span class="p">.</span><span class="nf">begin</span><span class="si">}</span><span class="s2">"</span>
<span class="k">end</span>
<span class="k">end</span>
</code></pre> Ruby master - Feature #15864: Proposal: Add methods to determine if it is an infinite rangehttps://bugs.ruby-lang.org/issues/15864?journal_id=809102019-08-22T07:36:48Zmame (Yusuke Endoh)mame@ruby-lang.org
<ul></ul><blockquote>
<p>Having <code>begin?</code> and <code>end?</code> instead of <code>beginless?</code> and <code>endless?</code> would be more natural, and easy to comprehend.</p>
</blockquote>
<p>Agreed. Moreover, <code>Range#begin</code> and <code>#end</code> just work.</p>