Inheritance interacts with overloading in two ways. The first occurs when a handler is named as a string rather than provided as a code reference or anonymous subroutine. When named as a string, the handler is interpreted as a method, and can therefore be inherited from superclasses.
The second interaction between inheritance and overloading is
that any class derived from a overloaded class is itself subject to
that overloading. In other words, overloading is itself inherited. The
set of handlers in a class is the union of handlers of all that
class's ancestors, recursively. If a handler can be found in several
different ancestors, the handler actually used is governed by the
usual rules for method inheritance. For example, if class
Alpha
inherits from classes Beta
and Gamma
in that order, and class
Beta
overloads +
with
&Beta::plus_sub
, but class
Gamma
overloads +
with the
string "plus_meth
", then
Beta::plus_sub
will be called when you try to apply
+
to an Alpha
object.
Since the value of the fallback
key is not a
handler, its inheritance is not governed by the rules given above. In
the current implementation, the fallback
value from
the first overloaded ancestor is used, but this is accidental and
subject to change without notice (well, without much notice).