[ruby-talk:7815] Re: Some private_instance_method are not private_methods?

> |-------------------------
> |def diff(aModule)
> |    aModule.private_instance_methods- aModule.private_methods
> |end
>
> You are subtracting set of aModule's private methods from set of
> private instance methods of an instance of a class which includes
> aModule.  The result would be nonsense.  Get it?
>
> 							matz.
>
Ah, I just wanted a convenient way to figure out the #private_methods of an object
of type Module ended asking for the #private_methods for the object Module of type
Class?

I guess what you are saying:
Kernel  instance_of   Module
    ||
Object
     |
Module

This would turn any private_method for an Object of type Module - for example
Kernel - into a private_instance_method of Kernel and then by inclusion (and
inheritance) into a private_instance_method of type Module?  Hm, doesn't this  also
work the other way around? (by design I suppose?)

class Module
private
def ops
end
end
module Test
end

p Module.private_instance_methods.include? ("ops") # true
p Test.private_methods.include?("ops")  # true

# This also true for the buildin method append_features in diff(Module)

A = Module.new
X = Module.new
Y = Module.new
module X
    append_features(A) #  include X into A - okay because
end                     # append_features private_methods of Object A
p A.ancestors # [A,X] module ancestors
class Module
def  outer(aMod) #  makes the private_instance_method visible
   append_features(aMod)
end
end
Y.outer(A)
p A.ancestors  #[A,Y,X]

Thank you very much for clearing up my confusion.

Christoph