That's all fine, but that doesn't mean that String will allow itself to
be compared to my class:

irb(main):003:0> class Str; def initialize(s) @s = s; end;  def to_str()
@s; end end
=> nil
irb(main):004:0> str = Str.new('hi')
=> #<Str:0x339fbc @s="hi">
irb(main):005:0> 'hi' == str
=> false
irb(main):006:0> 'hi' == str.to_str
=> true

I can add as many methods as I want to String, I can even proxy every
single method in it using #undefined_method (which is as duck-typed as
you can get) but I still don't think a String object will ever "== =>
true" to my class.

Am I right about this?

What you can do is override String.== to take this into consideration.

class String
        alias :_equals :==
        def ==(o)
                _equals(o.to_s)
        end
end

On 3/13/2005, "Sam Roberts" <srobe...@uniserve.com> wrote:

Not sure if there's a version requirement; works with 1.8.2,
I believe.

    if (TYPE(str2) != T_STRING) {
        if (!rb_respond_to(str2, rb_intern("to_str"))) {
            return Qfalse;
        }
        return rb_equal(str2, str1);              
    }

Clever.  :-)

On 3/13/2005, "Navindra Umanee" <navin...@cs.mcgill.ca> wrote:

First of all, an *single* explicit method is used, not the representative
API of the class; for example in this instance, anything that defines
#to_s
could be considered to be valid input; sometimes more matching methods
might be required. It is considerably harder to construct the idiom this
way, so I can see the need for this compromise.

Secondly, the naming is confusing. #to_str? str is not a class and a very
similar name #to_s does something different. A better choice would use the
entire class name (lowercase would be fine) and clearly indicate that
it's
not necessarily being made into another class but used as an instance of
the other class; hence SomeClass#as_string or something similar like my
favourite SomeClass#quack_like_a_string.

I think this is being changed somehow in 2.0, even if it's just better
integration and clearer guidelines for usage.

  "somestr" == your_obj

your_obj needs #to_str and #== (#<=> won't do it)

  "somestr" <=> your_obj

your_obj needs #to_str and #<=>

  "somestr".eql?(your_obj)

you can't do do this.

So String will 'invert" == and <=> if the argument has a #to_str, but no
other methods will be inverted.

Do I understand correctly?

Sam

The code I played with:

class Str
  def to_str; 'str'; end
# def eql?(s); true; end
# def ==(s); true; end
  def eql?(s); true; end
# def <=>(s); 0; end
end

p Str.new == 'a'
p 'a' == Str.new

p Str.new.eql?('a')
p 'a'.eql?(Str.new)

In other languages, they would all implement "interface String", or
inherit from a pure virtual "String" base class, or something..

I think the naming makes sense, looked at this way, and since the naming
isn't going to change (for backwards compat reasons), lets choose to
look at it this way.

Other examples are #to_int and #to_ary.

I'd like to see the beginnings of a "Ruby Idiom Guide". String right now
is magical in how it inverts comparisons to allow things that have
#to_str to compare against itself. It isn't consistent. Fixnum seems to
do it whether #to_int is defined or not. Whats going on there?

  $ irb
  class One; def to_int; 1; end; def ==(other); 1 == other; end; end
     => nil
  one = One.new
     => #<One:0x1d1584>
  one == 1
     => true
  1 == one
     => true
  2 == one
     => false
  one == 2
     => false
  class Unity; def to_ary; [1,1]; end; def ==(other); [1,1] == other; end; end
     => nil
  unity = Unity.new
     => #<Unity:0x33b1a0>
  unity == [1,1]
     => true
  [1,1] == unity
     => true
  class OneX; def ==(other); 1 == other; end; end
     => nil
  class UnityX; def ==(other); [1,1] == other; end; end
     => nil
  onex = OneX.new
     => #<OneX:0x32290c>
  unityx = UnityX.new
     => #<UnityX:0x31daec>
  [1,1] == unityx
     => false
  1 == onex
     => true

Huh? It always happens? I'll have to look into this more to figure out
whats going on... then submit docs.

Anyhow, I don't think it is common to implement this. But for
duck-typing to be consistent and pervasive we all have to, don't we?

So, for example, if I make a class that is a representation of a concept
of time that has a range past the unix time_t rollover (which kills
Time), and I want people to be able to use it where the use Time and
never know it's my own version, how I should do this needs to be
documented.

For example, I might decide that #to_tim is the way to indicate this (or
#to_time, if you prefer, don't get stuck on the name).

I think I should then override Time#===, #<=>, ... so that if +other+
isn't of class Time, but has a #to_tim method, it would call +other OP
self+.

Some folks talk about duck-typing like it magically happens, but it
doesn't, really, you have to make it happen. I should get
ProgrammingRuby2, see if this is covered there, I just haven't seen it
at a bookstore, yet. Guess I should just order, but I like to support
physical book stores.

Am Samstag, 19. Mär 2005, 02:21:15 +0900 schrieb Sam Roberts:

File `numeric.c', Function `num_equal()', line 806.

Bertram

If doing it all the time is a good idea, why don't Array and String do
it that way?