Here's a case where a bug report stumped me and made me feel I'm missing something:
<http://rt.perl.org/rt3/Ticket/Display.html?id=69260> I'll give a somewhat summarized version of the above page, which gradually turns into a set of questions and not enough answers: * It has been decided that attribute slots of the type $!foo are only allowed *syntactically* within the class block that declares them. (The exception to this, I guess, is the 'trusts' directive.) But this means that something like this anonymous method my $reveal-foo = method { say $!foo } isn't allowed. I think that's good, because it would provide a very easy way to break encapsulation of an object; just call $object.$reveal-foo() on it. * Today we discovered that it's possible to break encapsulation by detaching a method from an object of one class, and calling that method on an object of another class. Which means that breaking the encapsulation of a foreign class is as easy as creating a custom class with all of the same private attributes, and with a method to print (or otherwise reveal) them. * It is my feeling that such encapsulation-breakage shouldn't be allowed. Do you agree, p6l? * If it isn't allowed, which of the two steps is disallowed? *Detaching* a method containing references to private accessor slots (thereby extending the syntactic restriction of "no private accessors outside of the class block"), or *attaching* an anonymous method to an object belonging to a different class than the one from which it was detached (thereby by necessity having to complicate anonymous methods somewhat)? I only see those three options: a. Allow this form of encapsulation breakage. b. Disallow detaching of certain methods. c. Disallow attaching of certain anonymous methods. I must confess I don't particularly like either option. I'm by no means an OO expert. It would be interesting to hear your views on this. // Carl
