X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=pod%2Fperltoot.pod;h=5180306688aca861781a0ce8c486f8e1ffa9d79f;hb=42e1efa1e62f0d241a2d8e4847bce98f732060a3;hp=4a212fba91c8c17711ea59f1665586a52354ce91;hpb=eac7fe86f47901babc387c242e8dc65d73838746;p=p5sagit%2Fp5-mst-13.2.git

diff --git a/pod/perltoot.pod b/pod/perltoot.pod
index 4a212fb..5180306 100644
--- a/pod/perltoot.pod
+++ b/pod/perltoot.pod
@@ -1016,7 +1016,8 @@ dubiously-OO languages like C++.
 The way it works is actually pretty simple: just put more than one package
 name in your @ISA array.  When it comes time for Perl to go finding
 methods for your object, it looks at each of these packages in order.
-Well, kinda.  It's actually a fully recursive, depth-first order.
+Well, kinda.  It's actually a fully recursive, depth-first order by
+default (see L<mro> for alternate method resolution orders).
 Consider a bunch of @ISA arrays like this:
 
     @First::ISA    = qw( Alpha );
@@ -1120,6 +1121,66 @@ higher available.   This is not the same as loading in that exact version
 number.  No mechanism currently exists for concurrent installation of
 multiple versions of a module.  Lamentably.
 
+=head2 Deeper UNIVERSAL details
+
+It is also valid (though perhaps unwise in most cases) to put other
+packages' names in @UNIVERSAL::ISA.  These packages will also be
+implicitly inherited by all classes, just as UNIVERSAL itself is.
+However, neither UNIVERSAL nor any of its parents from the @ISA tree
+are explicit base classes of all objects.  To clarify, given the
+following:
+
+    @UNIVERSAL::ISA = ('REALLYUNIVERSAL');
+
+    package REALLYUNIVERSAL;
+    sub special_method { return "123" }
+
+    package Foo;
+    sub normal_method { return "321" }
+
+Calling Foo->special_method() will return "123", but calling
+Foo->isa('REALLYUNIVERSAL') or Foo->isa('UNIVERSAL') will return
+false.
+
+If your class is using an alternate mro like C3 (see
+L<mro>), method resolution within UNIVERSAL / @UNIVERSAL::ISA will
+still occur in the default depth-first left-to-right manner,
+after the class's C3 mro is exhausted.
+
+All of the above is made more intuitive by realizing what really
+happens during method lookup, which is roughly like this
+ugly pseudo-code:
+
+    get_mro(class) {
+        # recurses down the @ISA's starting at class,
+        # builds a single linear array of all
+        # classes to search in the appropriate order.
+        # The method resolution order (mro) to use
+        # for the ordering is whichever mro "class"
+        # has set on it (either default (depth first
+        # l-to-r) or C3 ordering).
+        # The first entry in the list is the class
+        # itself.
+    }
+
+    find_method(class, methname) {
+        foreach $class (get_mro(class)) {
+            if($class->has_method(methname)) {
+                return ref_to($class->$methname);
+            }
+        }
+        foreach $class (get_mro(UNIVERSAL)) {
+            if($class->has_method(methname)) {
+                return ref_to($class->$methname);
+            }
+        }
+        return undef;
+    }
+
+However the code that implements UNIVERSAL::isa does not
+search in UNIVERSAL itself, only in the package's actual
+@ISA.
+
 =head1 Alternate Object Representations
 
 Nothing requires objects to be implemented as hash references.  An object