Why doesn't `Range#cover?` raise an exception when comparison fails?

Question

Given that Time objects cannot be compared with Fixnum without explicit casting:

0 <= Time.now # => ArgumentError: comparison of Fixnum with Time failed
Time.now <= 10000000000 # => ArgumentError: comparison of Time with 10000000000 failed

and what the documentation for Range#cover? says,

cover?(obj) → true or false

Returns true if obj is between the begin and end of the range.

This tests begin <= obj <= end when exclude_end? is false and begin <= obj < end when exclude_end? is true.

I expect:

(0...10000000000).cover?(Time.now) # => false

to raise an exception rather than silently return false. Why doesn't it raise an exception?

It is understandable that, with explicit casting, the comparison works:

(0...10000000000).cover?(Time.now.to_i) # => true

`range_cover` uses `r_less` and r_less returns a positive value for non-comparable things: https://github.com/stulentsev/ruby/blob/62b750bb55916e526fb53cb4c19da777872c27f6/range.c#L174-L187 — Sergio Tulentsev, Feb 19 '16 at 15:04
@SergioTulentsev I am not that good in reading Ruby C-code. Does it mean that the doc is wrong? Can you elaborate that as an answer? — sawa, Feb 19 '16 at 15:10

Sergio Tulentsev · Accepted Answer · 2016-02-19T15:29:48.283

2

The doc doesn't mention an implementation detail. range_cover is implemented in terms of r_less (via r_cover_p). And r_less comment says:

/* compares _a_ and _b_ and returns:
 * < 0: a < b
 * = 0: a = b
 * > 0: a > b or non-comparable
 */

Here is the source of r_cover_p:

static VALUE
r_cover_p(VALUE range, VALUE beg, VALUE end, VALUE val)
{
  if (r_less(beg, val) <= 0) {
    int excl = EXCL(range);
    if (r_less(val, end) <= -excl)
      return Qtrue;
  }
  return Qfalse;
}

As we can see, a positive number returned from either of r_less invocations will result in a Qfalse.

Now, the reason why the doc doesn't mention it, I think, is to keep it light. Normally (99.9999% of cases), you're supposed to compare comparable things, right? And in the odd case you don't, you still get a correct answer ("this Time does not belong to this range of integers").

edited Feb 19 '16 at 15:29

answered Feb 19 '16 at 15:16

Sergio Tulentsev

226,338
43
373
367

1

"this Time does not belong to this range of integers" is what I expect for `include?`. I think the purpose for the method `cover?` to exist is to describe something different from it, namely that an element is **in between** the both ends, which for incomparable things, should be undefined. – sawa Feb 19 '16 at 15:30
1

@sawa: maybe they'll fix it someday :) – Sergio Tulentsev Feb 19 '16 at 15:35
Yeah, this is a bit more efficient than just waiting for the fix. – Sergio Tulentsev Feb 19 '16 at 15:53
1

jfyi, you have misspelled the method name in the ticket title. – Sergio Tulentsev Feb 19 '16 at 15:54

score 0 · Answer 2 · answered Feb 19 '16 at 14:34

0

I am pretty sure both .include? and .cover? uses the case quality operator (===) so the value you get is the same as:

p Time.now === 1000 #=> false

answered Feb 19 '16 at 14:34

hirolau

13,451
8
35
47

I see. Then it looks like a documentation bug, at least. But does that mean `Range#include?` and `Range#cover?` are the same? I suppose not. – sawa Feb 19 '16 at 14:35
According to "The Ruby Programming language book", `Range#cover?` in v1.9 same as `Range#include?` in 1.8. In 1.9 they are different. – Ilya Feb 19 '16 at 14:44
`cover?`, unlike `include?` doesn't use any equality operators. This is its strength: O(1) runtime. – Sergio Tulentsev Feb 19 '16 at 15:08

Why doesn't `Range#cover?` raise an exception when comparison fails?

2 Answers2