Obviously, the first should be “contains?”, as that’s the word you use.

The other might be “in?”

Indeed, “contains” seems the most logical choice for me too.

Wait, include? is going away for numbers?

Console me in my sorrow!

if x in beg..end

Scratch that—I read the thread and I can see why include? is ambiguous.

I like (beg..end).has?(x), which I see has already been suggested even though I can’t read the rest.

I see too, matz doesn’t like contains? or has? because a Range doesn’t actually contain things. Please see the whole thread next time, slumos.

Maybe this doesn’t fit too well with other stuff, but it kind of makes sense to me …

(example with 1.8)

irb(main):001:0> class Range
irb(main):002:1> alias :=~ :include?
irb(main):003:1> end
=> nil
irb(main):004:0> (3..10) =~ 5
=> true
irb(main):005:0> (3..10) =~ 50
=> false

(beg..end).bounds?(x) x.bounded_by?(beg..end)

(beg..end).covers?(x)

I’d call the first range.enclose?(item).

I’m not sure about the second—what’s wrong about .include?()?

Thank you for translating!

Remeber that method names should not be conjugated – so contain without s.

What about this:

('a'..'aa').wrap? 'z'  # or
 ('a'..'aa').surround? 'z'

“Surround” is one of my favorite English words :)

Please correct me if I’m wrong. There is some confusion here. The following is what I understood so far:

The new methods are just counterparts for the ones you likely expect behind the names. Matz wants to make Ruby more intuitively with this addition.

I take cover? and found_between?, just for now.

No problem for numbers:

(1..7).include? 4  #-> true
 (1..7).member? 4 #-> true, synonym
 4.between?(1, 7)  #-> true

But with strings, it’s now:

('a'..'aa').to_a  #-> 'a', 'b', ..., 'z', 'aa'
 ('a'..'aa').include? 'b'  #-> true (new!)
 ('a'..'aa').member? 'b'  #-> true, synonym

'b'.between?('a', 'aa')  #-> false, as before

And now we need two methods that do it the other way: a comparison include? and a discreete between?:

('a'..'aa').cover? 'b'  #-> false
 ('a'..'aa').surround? 'b'  #-> false, alternative
 ('a'..'aa').wrap? 'b'  #-> false, alternative
 ('a'..'aa').bound? 'b'  #-> false, alternative

'b'.found_between?('a', 'aa')  #-> true
 'b'.in?('a', 'aa')  #-> true

I hope this clarifies my and your understanding of this advanced math philosophic stuff. Names are important.

“within range” is quite appropriate. However (beg..end).within? sounds the other way.. unless it acn be x.within? Range

phil602 sorry, my translation is wrong.

In 1.9, “include?” checks Number by magnitude relation.

murphy, I like “bound?”. I admit I haven’t read the thread, so I don’t know if there’s some kind of ueber-elite reason we can’t use it. All the same, I like “bound?”.

If member?/include? go back to checking a #succ “hit” then

r = 0..10000000000000000000000000000000000
r.member? 10000000000000000000000000000000

Don’t bother calling me when the calc is finished. I’ll be dead. Of course you might insist it will be optimized to account for numbers, but then you defeat the generalized usage of Range and might as well not bother with the sentinel-based behavior at all. How can one deal with an abstract class that might have a similar time intensive situation, even though there is a very simple and quick calculation to determine membership. There’s the real issue, the sentinel needs a way to provide a succ-based membership comparitor (it can be optional).

“contains” makes more sense especially when you consider ranges with decimal endpoints or non-numeric ranges. The requirement to construct a range is that objects can be compared using <=> ie that the object can be ordered in some fashion. “covers” to me seems to be the inverse of “contains”. Go with “contains”.

I don’t know about the first, but I think a good name for the second method would be :among_successors_up_to? or maybe just :among_successors? if you’re willing to deal with a little ambiguity about the second argument.

Yes, something like among? is a very good idea.

The thread says that a range does not “contain” elements, it “produces” elements.

(See http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-talk/167200 )

I sort of disagree, as i think the range implicitly defines a set, which definitely can “contain” elements.

However, if a range “produces” elements, then go with “produces?”.

(catching up on my reading after vacation)

The first problem to solve before fixing the names is the implementation of Range:

Right now, Ranges can be made of any objects that support <=> and succ. But a<=>a.succ != -1 for all a, especially if a is a String. So the first thing to do is change the requirement such that ‘rangeable’ objects must support ‘follows?’ and ‘succ’, where a.succ.follows?(a) == 1 and a.follows?(a.succ) == -1 for all a.

the follows method is equivalent to <=> for numeric types, but for strings it needs to be customized to match the succession generator.

Now that you have a sane range definition, you can have two names for range inclusion tests: range.spans(x) means range.first <= x <= range.last and

range.member?(x) means range.to_a.member?(x) (#because range.to_a uses succ to generate members. But it will use follows to skip the actual generation)

With this definition you would have: