From: Harry Ohlsen <harryo@...>
Date: 2002-10-12T07:59:39+09:00
Subject: Re: Polymorphism, Isomorphism

OK. Here's what I came up with ...

------------------------------------------------

class Object
    def implements?(interface)
        if interface.type == Module
            $__implements_interface__ = interface

            interface = nil

            eval %[
                class TEMPCLASS__
                    include $__implements_interface__
                end

                interface = TEMPCLASS__.new.methods - Object.methods
            ]

            self.implements? interface
        elsif interface.type == Array
            !(interface.flatten.map { |m| implements? m } .include? false)
        else
            self.respond_to? interface
        end

    end
end

module Runnable
    def run
    end
end

module Turnable
    def turn
    end
end

class Nose
    include Runnable
end

class Tap
    include Runnable
    include Turnable

    def hot
    end

    def cold
    end
end

Temperatures = [:hot, :cold]

puts Nose.new.implements? Runnable # => true
puts Nose.new.implements? Turnable # => false
puts Nose.new.implements? Temperatures # => false

puts Tap.new.implements? [Runnable, Turnable, Temperatures] # => true

---------------------------------------------------------

The map() now does recursive calls, but only to one level, because of the 
flatten(), so that shouldn't be a hideous efficiency issue.

I did that in order to allow interfaces to be defined as nested arrays of both 
modules and method names, since I could imagine people wanting to do that,as 
in the example above.

Of course, probably noone really wants to use something like this.  But I 
don't care ... I just wanted to have some fun :-) !!

Harry O.