How does Perl polymorphism work? - perl

Question

I am unable to figure out an explanation on how polymorphism works in Perl. I understand what polymorphism means but I am trying to figure out how it internally works within perl. Can someone point me to some documentation that explains it. All the google searches I have done gives me examples of what polymorphism is in perl but not how perl makes it work.

Answer 1

When a method is invoked on an object or class, Perl looks to see if that method is provided directly by the class itself.
Because classes are simply Perl packages, it is simply a matter of looking for the existence of a subroutine &Class::method.
If no such subroutine is found, Perl examines the #ISA array in the same package (i.e. #Class::ISA) which contains a list of base classes for the class, and does the same check for every package/class that appears in there.
Each of those classes in turn may also have an #ISA array, so the search is recursive.
Finally, if the method is found nowhere by this method, Perl looks in a special package UNIVERSAL for a subroutine &UNIVERSAL::method.
A failure at this point goes on to invoke the AUTOLOAD system, but that is really beyond the principle of polymorphism.
A failure to find a suitable matching method anywhere raises an exception.

Answer 2

Chapter 7 from Object Oriented Perl, Damian Conway, Manning (2000) is called Polymorphism. Ten pages.
Be advised, however, in case you're coming from C++ or Java or C# or similar, that there's not so much to know about "polymorphism" in Perl. I'd even say the concept of polymorphism makes things more complicated than they are in Perl.
I think the mechanism a Perl programmer should be striving to understand is how method lookup works. The answer is: depth-first recursive scanning through the #ISA arrays of packages.
An example, let's do $o->bla. Our $o is blessed into the A package, which doesn't have an implementation of bla. But it inherits from first B and then C (#ISA = ('B', 'C')). So let's do a lookup in B first. It doesn't define the method either. If it had parent classes, we'd continue our lookup there. But it doesn't. So we now look into C, and fortunately it does have the method, else that would be a runtime error, because the package of last resort, UNIVERSAL, doesn't define bla either.

Answer 3

An object method call is basically an optimised* version of the following:
my $class = ref($_[0]);
my #isa = mro::get_linear_isa($class);
for my $pkg (#isa) {
if (exists(&{$pkg.'::'.$method_name})) {
return &{$pkg.'::'.$method_name};
}
}
ref gets the name of the class associated with the object. The class is stored in the object's variable.
$ perl -MDevel::Peek -e'my $o = {}; Dump($o); bless($o, "SomeClass"); Dump($o);'
SV = IV(0x9e4ae0c) at 0x9e4ae10
REFCNT = 1
FLAGS = (PADMY,ROK)
RV = 0x9e317d0
SV = PVHV(0x9e36808) at 0x9e317d0
REFCNT = 1
FLAGS = (SHAREKEYS)
ARRAY = 0x0
KEYS = 0
FILL = 0
MAX = 7
RITER = -1
EITER = 0x0
SV = IV(0x9e4ae0c) at 0x9e4ae10
REFCNT = 1
FLAGS = (PADMY,ROK)
RV = 0x9e317d0
SV = PVHV(0x9e36808) at 0x9e317d0
REFCNT = 1
FLAGS = (OBJECT,SHAREKEYS) <----
STASH = 0x9e323d0 "SomeClass" <----
ARRAY = 0x0
KEYS = 0
FILL = 0
MAX = 7
RITER = -1
EITER = 0x0
get_linear_isa is based on #ISA in package $class, and the #ISA of the packages named therein.
Since the class name is in the object and since Perl can check its symbol table at run-time, a virtual method table isn't needed to provide polymorphism.
* — It caches which package provides method $method_name for class $class. Also, it surely doesn't calculate the whole linear ISA upfront, but as needed.

Answer 4

This well suits inheritance-based polymorphism and gives some idea of what Perl does specifically. I have always used chapter 12.5. Class Inheritance in Programming Perl as a reference for these things.

Answer 5

Polymorphism is simply the idea that objects of different types respond to method calls of the same name. Weakly typed languages, such as Perl, are "implicitly polymorphic".
For example, a CGI object, an Apache2::Request object, and a Plack::Request object all have a param method that will return the parameters of an HTTP request. I could write a function that accepts an object as a parameter, and call the param method on that object, and get an HTTP request parameter, without knowing what type of object it is.
Strongly typed languages don't work this way because their functions specify the data types of their parameters. I can't call a function in Java with an object of type Dog if it was expecting one of Cat. So the strongly typed languages have to create special mechanisms to allow for polymorphism.