overload(3p) Perl Programmers Reference Guide overload(3p)

overload(3p) Perl Programmers Reference Guide overload(3p) #

overload(3p) Perl Programmers Reference Guide overload(3p)

NNAAMMEE #

 overload - Package for overloading Perl operations

SSYYNNOOPPSSIISS #

     package SomeThing;

     use overload
         '+' => \&myadd,
         '-' => \&mysub;
         # etc
     ...

     package main;
     $a = SomeThing->new( 57 );
     $b = 5 + $a;
     ...
     if (overload::Overloaded $b) {...}
     ...
     $strval = overload::StrVal $b;

DDEESSCCRRIIPPTTIIOONN #

 This pragma allows overloading of Perl's operators for a class.  To
 overload built-in functions, see "Overriding Built-in Functions" in
 perlsub instead.

FFuunnddaammeennttaallss _D_e_c_l_a_r_a_t_i_o_n

 Arguments of the "use overload" directive are (key, value) pairs.  For
 the full set of legal keys, see "Overloadable Operations" below.

 Operator implementations (the values) can be subroutines, references to
 subroutines, or anonymous subroutines - in other words, anything legal
 inside a "&{ ... }" call.  Values specified as strings are interpreted as
 method names.  Thus

     package Number;
     use overload
         "-" => "minus",
         "*=" => \&muas,
         '""' => sub { ...; };

 declares that subtraction is to be implemented by method "minus()" in the
 class "Number" (or one of its base classes), and that the function
 "Number::muas()" is to be used for the assignment form of multiplication,
 "*=".  It also defines an anonymous subroutine to implement
 stringification: this is called whenever an object blessed into the
 package "Number" is used in a string context (this subroutine might, for
 example, return the number as a Roman numeral).

 _C_a_l_l_i_n_g _C_o_n_v_e_n_t_i_o_n_s _a_n_d _M_a_g_i_c _A_u_t_o_g_e_n_e_r_a_t_i_o_n

 The following sample implementation of "minus()" (which assumes that
 "Number" objects are simply blessed references to scalars) illustrates
 the calling conventions:

     package Number;
     sub minus {
         my ($self, $other, $swap) = @_;
         my $result = $$self - $other;         # *
         $result = -$result if $swap;
         ref $result ? $result : bless \$result;
     }
     # * may recurse once - see table below

 Three arguments are passed to all subroutines specified in the "use
 overload" directive (with exceptions - see below, particularly
 "nomethod").

 The first of these is the operand providing the overloaded operator
 implementation - in this case, the object whose "minus()" method is being
 called.

 The second argument is the other operand, or "undef" in the case of a
 unary operator.

 The third argument is set to TRUE if (and only if) the two operands have
 been swapped.  Perl may do this to ensure that the first argument ($self)
 is an object implementing the overloaded operation, in line with general
 object calling conventions.  For example, if $x and $y are "Number"s:

     operation   |   generates a call to
     ============|======================
     $x - $y     |   minus($x, $y, '')
     $x - 7      |   minus($x, 7, '')
     7 - $x      |   minus($x, 7, 1)

 Perl may also use "minus()" to implement other operators which have not
 been specified in the "use overload" directive, according to the rules
 for "Magic Autogeneration" described later.  For example, the "use
 overload" above declared no subroutine for any of the operators "--",
 "neg" (the overload key for unary minus), or "-=".  Thus

     operation   |   generates a call to
     ============|======================
     -$x         |   minus($x, 0, 1)
     $x--        |   minus($x, 1, undef)
     $x -= 3     |   minus($x, 3, undef)

 Note the "undef"s: where autogeneration results in the method for a
 standard operator which does not change either of its operands, such as
 "-", being used to implement an operator which changes the operand
 ("mutators": here, "--" and "-="), Perl passes undef as the third
 argument.  This still evaluates as FALSE, consistent with the fact that
 the operands have not been swapped, but gives the subroutine a chance to
 alter its behaviour in these cases.

 In all the above examples, "minus()" is required only to return the
 result of the subtraction: Perl takes care of the assignment to $x.  In
 fact, such methods should _n_o_t modify their operands, even if "undef" is
 passed as the third argument (see "Overloadable Operations").

 The same is not true of implementations of "++" and "--": these are
 expected to modify their operand.  An appropriate implementation of "--"
 might look like

     use overload '--' => "decr",
         # ...
     sub decr { --${$_[0]}; }

 If the "bitwise" feature is enabled (see feature), a fifth TRUE argument
 is passed to subroutines handling "&", "|", "^" and "~".  This indicates
 that the caller is expecting numeric behaviour.  The fourth argument will
 be "undef", as that position ($_[3]) is reserved for use by "nomethod".

 _M_a_t_h_e_m_a_g_i_c_, _M_u_t_a_t_o_r_s_, _a_n_d _C_o_p_y _C_o_n_s_t_r_u_c_t_o_r_s

 The term 'mathemagic' describes the overloaded implementation of
 mathematical operators.  Mathemagical operations raise an issue.
 Consider the code:

     $a = $b;
     --$a;

 If $a and $b are scalars then after these statements

     $a == $b - 1

 An object, however, is a reference to blessed data, so if $a and $b are
 objects then the assignment "$a = $b" copies only the reference, leaving
 $a and $b referring to the same object data.  One might therefore expect
 the operation "--$a" to decrement $b as well as $a.  However, this would
 not be consistent with how we expect the mathematical operators to work.

 Perl resolves this dilemma by transparently calling a copy constructor
 before calling a method defined to implement a mutator ("--", "+=", and
 so on.).  In the above example, when Perl reaches the decrement
 statement, it makes a copy of the object data in $a and assigns to $a a
 reference to the copied data.  Only then does it call "decr()", which
 alters the copied data, leaving $b unchanged.  Thus the object metaphor
 is preserved as far as possible, while mathemagical operations still work
 according to the arithmetic metaphor.

 Note: the preceding paragraph describes what happens when Perl
 autogenerates the copy constructor for an object based on a scalar.  For
 other cases, see "Copy Constructor".

OOvveerrllooaaddaabbllee OOppeerraattiioonnss The complete list of keys that can be specified in the “use overload” directive are given, separated by spaces, in the values of the hash %overload::ops:

  with_assign      => '+ - * / % ** << >> x .',
  assign           => '+= -= *= /= %= **= <<= >>= x= .=',
  num_comparison   => '< <= > >= == !=',
  '3way_comparison'=> '<=> cmp',
  str_comparison   => 'lt le gt ge eq ne',
  binary           => '& &= | |= ^ ^= &. &.= |. |.= ^. ^.=',
  unary            => 'neg ! ~ ~.',
  mutators         => '++ --',
  func             => 'atan2 cos sin exp abs log sqrt int',
  conversion       => 'bool "" 0+ qr',
  iterators        => '<>',
  filetest         => '-X',
  dereferencing    => '${} @{} %{} &{} *{}',
  matching         => '~~',
  special          => 'nomethod fallback ='

 Most of the overloadable operators map one-to-one to these keys.
 Exceptions, including additional overloadable operations not apparent
 from this hash, are included in the notes which follow.  This list is
 subject to growth over time.

 A warning is issued if an attempt is made to register an operator not
 found above.

 •    "not"

      The operator "not" is not a valid key for "use overload".  However,
      if the operator "!" is overloaded then the same implementation will
      be used for "not" (since the two operators differ only in
      precedence).

 •    "neg"

      The key "neg" is used for unary minus to disambiguate it from binary
      "-".

 •    "++", "--"

      Assuming they are to behave analogously to Perl's "++" and "--",
      overloaded implementations of these operators are required to mutate
      their operands.

      No distinction is made between prefix and postfix forms of the
      increment and decrement operators: these differ only in the point at
      which Perl calls the associated subroutine when evaluating an
      expression.

 •    _A_s_s_i_g_n_m_e_n_t_s

          +=  -=  *=  /=  %=  **=  <<=  >>=  x=  .=
          &=  |=  ^=  &.=  |.=  ^.=

      Simple assignment is not overloadable (the '=' key is used for the
      "Copy Constructor").  Perl does have a way to make assignments to an
      object do whatever you want, but this involves using ttiiee(()), not
      overload - see "tie" in perlfunc and the "COOKBOOK" examples below.

      The subroutine for the assignment variant of an operator is required
      only to return the result of the operation.  It is permitted to
      change the value of its operand (this is safe because Perl calls the
      copy constructor first), but this is optional since Perl assigns the
      returned value to the left-hand operand anyway.

      An object that overloads an assignment operator does so only in
      respect of assignments to that object.  In other words, Perl never
      calls the corresponding methods with the third argument (the "swap"
      argument) set to TRUE. For example, the operation

          $a *= $b

      cannot lead to $b's implementation of "*=" being called, even if $a
      is a scalar.  (It can, however, generate a call to $b's method for
      "*").

 •    _N_o_n_-_m_u_t_a_t_o_r_s _w_i_t_h _a _m_u_t_a_t_o_r _v_a_r_i_a_n_t

           +  -  *  /  %  **  <<  >>  x  .
           &  |  ^  &.  |.  ^.

      As described above, Perl may call methods for operators like "+" and
      "&" in the course of implementing missing operations like "++",
      "+=", and "&=".  While these methods may detect this usage by
      testing the definedness of the third argument, they should in all
      cases avoid changing their operands.  This is because Perl does not
      call the copy constructor before invoking these methods.

 •    "int"

      Traditionally, the Perl function "int" rounds to 0 (see "int" in
      perlfunc), and so for floating-point-like types one should follow
      the same semantic.

 •    _S_t_r_i_n_g_, _n_u_m_e_r_i_c_, _b_o_o_l_e_a_n_, _a_n_d _r_e_g_e_x_p _c_o_n_v_e_r_s_i_o_n_s

          ""  0+  bool

      These conversions are invoked according to context as necessary.
      For example, the subroutine for '""' (stringify) may be used where
      the overloaded object is passed as an argument to "print", and that
      for 'bool' where it is tested in the condition of a flow control
      statement (like "while") or the ternary "?:" operation.

      Of course, in contexts like, for example, "$obj + 1", Perl will
      invoke $obj's implementation of "+" rather than (in this example)
      converting $obj to a number using the numify method '0+' (an
      exception to this is when no method has been provided for '+' and
      "fallback" is set to TRUE).

      The subroutines for '""', '0+', and 'bool' can return any arbitrary
      Perl value.  If the corresponding operation for this value is
      overloaded too, the operation will be called again with this value.

      As a special case if the overload returns the object itself then it
      will be used directly.  An overloaded conversion returning the
      object is probably a bug, because you're likely to get something
      that looks like "YourPackage=HASH(0x8172b34)".

          qr

      The subroutine for 'qr' is used wherever the object is interpolated
      into or used as a regexp, including when it appears on the RHS of a
      "=~" or "!~" operator.

      "qr" must return a compiled regexp, or a ref to a compiled regexp
      (such as "qr//" returns), and any further overloading on the return
      value will be ignored.

 •    _I_t_e_r_a_t_i_o_n

      If "<>" is overloaded then the same implementation is used for both
      the _r_e_a_d_-_f_i_l_e_h_a_n_d_l_e syntax "<$var>" and _g_l_o_b_b_i_n_g syntax "<${var}>".

 •    _F_i_l_e _t_e_s_t_s

      The key '-X' is used to specify a subroutine to handle all the
      filetest operators ("-f", "-x", and so on: see "-X" in perlfunc for
      the full list); it is not possible to overload any filetest operator
      individually.  To distinguish them, the letter following the '-' is
      passed as the second argument (that is, in the slot that for binary
      operators is used to pass the second operand).

      Calling an overloaded filetest operator does not affect the stat
      value associated with the special filehandle "_".  It still refers
      to the result of the last "stat", "lstat" or unoverloaded filetest.

      This overload was introduced in Perl 5.12.

 •    _M_a_t_c_h_i_n_g

      The key "~~" allows you to override the smart matching logic used by
      the "~~" operator and the switch construct ("given"/"when").  See
      "Switch Statements" in perlsyn and feature.

      Unusually, the overloaded implementation of the smart match operator
      does not get full control of the smart match behaviour.  In
      particular, in the following code:

          package Foo;
          use overload '~~' => 'match';

          my $obj =  Foo->new();
          $obj ~~ [ 1,2,3 ];

      the smart match does _n_o_t invoke the method call like this:

          $obj->match([1,2,3],0);

      rather, the smart match distributive rule takes precedence, so $obj
      is smart matched against each array element in turn until a match is
      found, so you may see between one and three of these calls instead:

          $obj->match(1,0);
          $obj->match(2,0);
          $obj->match(3,0);

      Consult the match table in  "Smartmatch Operator" in perlop for
      details of when overloading is invoked.

 •    _D_e_r_e_f_e_r_e_n_c_i_n_g

          ${}  @{}  %{}  &{}  *{}

      If these operators are not explicitly overloaded then they work in
      the normal way, yielding the underlying scalar, array, or whatever
      stores the object data (or the appropriate error message if the
      dereference operator doesn't match it).  Defining a catch-all
      'nomethod' (see below) makes no difference to this as the catch-all
      function will not be called to implement a missing dereference
      operator.

      If a dereference operator is overloaded then it must return a
      _r_e_f_e_r_e_n_c_e of the appropriate type (for example, the subroutine for
      key '${}' should return a reference to a scalar, not a scalar), or
      another object which overloads the operator: that is, the subroutine
      only determines what is dereferenced and the actual dereferencing is
      left to Perl.  As a special case, if the subroutine returns the
      object itself then it will not be called again - avoiding infinite
      recursion.

 •    _S_p_e_c_i_a_l

          nomethod  fallback  =

      See "Special Keys for "use overload"".

MMaaggiicc AAuuttooggeenneerraattiioonn If a method for an operation is not found then Perl tries to autogenerate a substitute implementation from the operations that have been defined.

 Note: the behaviour described in this section can be disabled by setting
 "fallback" to FALSE (see "fallback").

 In the following tables, numbers indicate priority.  For example, the
 table below states that, if no implementation for '!' has been defined
 then Perl will implement it using 'bool' (that is, by inverting the value
 returned by the method for 'bool'); if boolean conversion is also
 unimplemented then Perl will use '0+' or, failing that, '""'.

     operator | can be autogenerated from
              |
              | 0+   ""   bool   .   x
     =========|==========================
        0+    |       1     2
        ""    |  1          2
        bool  |  1    2
        int   |  1    2     3
        !     |  2    3     1
        qr    |  2    1     3
        .     |  2    1     3
        x     |  2    1     3
        .=    |  3    2     4    1
        x=    |  3    2     4        1
        <>    |  2    1     3

-X | 2 1 3 #

 Note: The iterator ('<>') and file test ('-X') operators work as normal:
 if the operand is not a blessed glob or IO reference then it is converted
 to a string (using the method for '""', '0+', or 'bool') to be
 interpreted as a glob or filename.

     operator | can be autogenerated from
              |
              |  <   <=>   neg   -=    -
     =========|==========================
        neg   |                        1
        -=    |                        1
        --    |                   1    2
        abs   | a1    a2    b1        b2    [*]
        <     |        1
        <=    |        1
        >     |        1
        >=    |        1
        ==    |        1
        !=    |        1

     * one from [a1, a2] and one from [b1, b2]

 Just as numeric comparisons can be autogenerated from the method for
 '<=>', string comparisons can be autogenerated from that for 'cmp':

      operators          |  can be autogenerated from
     ====================|===========================
      lt gt le ge eq ne  |  cmp

 Similarly, autogeneration for keys '+=' and '++' is analogous to '-=' and
 '--' above:

     operator | can be autogenerated from
              |
              |  +=    +
     =========|==========================
         +=   |        1
         ++   |   1    2

 And other assignment variations are analogous to '+=' and '-=' (and
 similar to '.=' and 'x=' above):

               operator ||  *= /= %= **= <<= >>= &= ^= |= &.= ^.= |.=
     -------------------||-------------------------------------------
     autogenerated from ||  *  /  %  **  <<  >>  &  ^  |  &.  ^.  |.

 Note also that the copy constructor (key '=') may be autogenerated, but
 only for objects based on scalars.  See "Copy Constructor".

 _M_i_n_i_m_a_l _S_e_t _o_f _O_v_e_r_l_o_a_d_e_d _O_p_e_r_a_t_i_o_n_s

 Since some operations can be automatically generated from others, there
 is a minimal set of operations that need to be overloaded in order to
 have the complete set of overloaded operations at one's disposal.  Of
 course, the autogenerated operations may not do exactly what the user
 expects.  The minimal set is:

     + - * / % ** << >> x
     <=> cmp
     & | ^ ~ &. |. ^. ~.
     atan2 cos sin exp log sqrt int
     "" 0+ bool
     ~~

 Of the conversions, only one of string, boolean or numeric is needed
 because each can be generated from either of the other two.

SSppeecciiaall KKeeyyss ffoorr “"uussee oovveerrllooaadd"” _"_n_o_m_e_t_h_o_d_"

 The 'nomethod' key is used to specify a catch-all function to be called
 for any operator that is not individually overloaded.  The specified
 function will be passed four parameters.  The first three arguments
 coincide with those that would have been passed to the corresponding
 method if it had been defined.  The fourth argument is the "use overload"
 key for that missing method.  If the "bitwise" feature is enabled (see
 feature), a fifth TRUE argument is passed to subroutines handling "&",
 "|", "^" and "~" to indicate that the caller is expecting numeric
 behaviour.

 For example, if $a is an object blessed into a package declaring

     use overload 'nomethod' => 'catch_all', # ...

 then the operation

     3 + $a

 could (unless a method is specifically declared for the key '+') result
 in a call

     catch_all($a, 3, 1, '+')

 See "How Perl Chooses an Operator Implementation".

 _"_f_a_l_l_b_a_c_k_"

 The value assigned to the key 'fallback' tells Perl how hard it should
 try to find an alternative way to implement a missing operator.

 •   defined, but FALSE

         use overload "fallback" => 0, # ... ;

     This disables "Magic Autogeneration".

 •   "undef"

     In the default case where no value is explicitly assigned to
     "fallback", magic autogeneration is enabled.

• TRUE #

     The same as for "undef", but if a missing operator cannot be
     autogenerated then, instead of issuing an error message, Perl is
     allowed to revert to what it would have done for that operator if
     there had been no "use overload" directive.

     Note: in most cases, particularly the "Copy Constructor", this is
     unlikely to be appropriate behaviour.

 See "How Perl Chooses an Operator Implementation".

 _C_o_p_y _C_o_n_s_t_r_u_c_t_o_r

 As mentioned above, this operation is called when a mutator is applied to
 a reference that shares its object with some other reference.  For
 example, if $b is mathemagical, and '++' is overloaded with 'incr', and
 '=' is overloaded with 'clone', then the code

     $a = $b;
     # ... (other code which does not modify $a or $b) ...
     ++$b;

 would be executed in a manner equivalent to

     $a = $b;
     # ...
     $b = $b->clone(undef, "");
     $b->incr(undef, "");

 Note:

 •   The subroutine for '=' does not overload the Perl assignment
     operator: it is used only to allow mutators to work as described
     here.  (See "Assignments" above.)

 •   As for other operations, the subroutine implementing '=' is passed
     three arguments, though the last two are always "undef" and ''.

 •   The copy constructor is called only before a call to a function
     declared to implement a mutator, for example, if "++$b;" in the code
     above is effected via a method declared for key '++' (or 'nomethod',
     passed '++' as the fourth argument) or, by autogeneration, '+='.  It
     is not called if the increment operation is effected by a call to the
     method for '+' since, in the equivalent code,

         $a = $b;
         $b = $b + 1;

     the data referred to by $a is unchanged by the assignment to $b of a
     reference to new object data.

 •   The copy constructor is not called if Perl determines that it is
     unnecessary because there is no other reference to the data being
     modified.

 •   If 'fallback' is undefined or TRUE then a copy constructor can be
     autogenerated, but only for objects based on scalars.  In other cases
     it needs to be defined explicitly.  Where an object's data is stored
     as, for example, an array of scalars, the following might be
     appropriate:

         use overload '=' => sub { bless [ @{$_[0]} ] },  # ...

 •   If 'fallback' is TRUE and no copy constructor is defined then, for
     objects not based on scalars, Perl may silently fall back on simple
     assignment - that is, assignment of the object reference.  In effect,
     this disables the copy constructor mechanism since no new copy of the
     object data is created.  This is almost certainly not what you want.
     (It is, however, consistent: for example, Perl's fallback for the
     "++" operator is to increment the reference itself.)

HHooww PPeerrll CChhoooosseess aann OOppeerraattoorr IImmpplleemmeennttaattiioonn Which is checked first, “nomethod” or “fallback”? If the two operands of an operator are of different types and both overload the operator, which implementation is used? The following are the precedence rules:

 1.  If the first operand has declared a subroutine to overload the
     operator then use that implementation.

 2.  Otherwise, if fallback is TRUE or undefined for the first operand
     then see if the rules for autogeneration allows another of its
     operators to be used instead.

 3.  Unless the operator is an assignment ("+=", "-=", etc.), repeat step
     (1) in respect of the second operand.

 4.  Repeat Step (2) in respect of the second operand.

 5.  If the first operand has a "nomethod" method then use that.

 6.  If the second operand has a "nomethod" method then use that.

 7.  If "fallback" is TRUE for both operands then perform the usual
     operation for the operator, treating the operands as numbers,
     strings, or booleans as appropriate for the operator (see note).

 8.  Nothing worked - die.

 Where there is only one operand (or only one operand with overloading)
 the checks in respect of the other operand above are skipped.

 There are exceptions to the above rules for dereference operations
 (which, if Step 1 fails, always fall back to the normal, built-in
 implementations - see Dereferencing), and for "~~" (which has its own set
 of rules - see "Matching" under "Overloadable Operations" above).

 Note on Step 7: some operators have a different semantic depending on the
 type of their operands.  As there is no way to instruct Perl to treat the
 operands as, e.g., numbers instead of strings, the result here may not be
 what you expect.  See "BUGS AND PITFALLS".

LLoossiinngg OOvveerrllooaaddiinngg The restriction for the comparison operation is that even if, for example, “cmp” should return a blessed reference, the autogenerated “lt” function will produce only a standard logical value based on the numerical value of the result of “cmp”. In particular, a working numeric conversion is needed in this case (possibly expressed in terms of other conversions).

 Similarly, ".="  and "x=" operators lose their mathemagical properties if
 the string conversion substitution is applied.

 When you cchhoopp(()) a mathemagical object it is promoted to a string and its
 mathemagical properties are lost.  The same can happen with other
 operations as well.

IInnhheerriittaannccee aanndd OOvveerrllooaaddiinngg Overloading respects inheritance via the @ISA hierarchy. Inheritance interacts with overloading in two ways.

 Method names in the "use overload" directive
     If "value" in

       use overload key => value;

     is a string, it is interpreted as a method name - which may (in the
     usual way) be inherited from another class.

 Overloading of an operation is inherited by derived classes
     Any class derived from an overloaded class is also overloaded and
     inherits its operator implementations.  If the same operator is
     overloaded in more than one ancestor then the implementation is
     determined by the usual inheritance rules.

     For example, if "A" inherits from "B" and "C" (in that order), "B"
     overloads "+" with "\&D::plus_sub", and "C" overloads "+" by
     "plus_meth", then the subroutine "D::plus_sub" will be called to
     implement operation "+" for an object in package "A".

 Note that in Perl version prior to 5.18 inheritance of the "fallback" key
 was not governed by the above rules.  The value of "fallback" in the
 first overloaded ancestor was used.  This was fixed in 5.18 to follow the
 usual rules of inheritance.

RRuunn--ttiimmee OOvveerrllooaaddiinngg Since all “use” directives are executed at compile-time, the only way to change overloading during run-time is to

     eval 'use overload "+" => \&addmethod';

 You can also use

     eval 'no overload "+", "--", "<="';

 though the use of these constructs during run-time is questionable.

PPuubblliicc FFuunnccttiioonnss Package “overload.pm” provides the following public functions:

 overload::StrVal(arg)
      Gives the string value of "arg" as in the absence of stringify
      overloading.  If you are using this to get the address of a
      reference (useful for checking if two references point to the same
      thing) then you may be better off using "builtin::refaddr()" or
      "Scalar::Util::refaddr()", which are faster.

 overload::Overloaded(arg)
      Returns true if "arg" is subject to overloading of some operations.

 overload::Method(obj,op)
      Returns "undef" or a reference to the method that implements "op".

      Such a method always takes three arguments, which will be enforced
      if it is an XS method.

OOvveerrllooaaddiinngg CCoonnssttaannttss For some applications, the Perl parser mangles constants too much. It is possible to hook into this process via “overload::constant()” and “overload::remove_constant()” functions.

 These functions take a hash as an argument.  The recognized keys of this
 hash are:

 integer to overload integer constants,

 float   to overload floating point constants,

 binary  to overload octal and hexadecimal constants,

 q       to overload "q"-quoted strings, constant pieces of "qq"- and
         "qx"-quoted strings and here-documents,

 qr      to overload constant pieces of regular expressions.

 The corresponding values are references to functions which take three
 arguments: the first one is the _i_n_i_t_i_a_l string form of the constant, the
 second one is how Perl interprets this constant, the third one is how the
 constant is used.  Note that the initial string form does not contain
 string delimiters, and has backslashes in backslash-delimiter
 combinations stripped (thus the value of delimiter is not relevant for
 processing of this string).  The return value of this function is how
 this constant is going to be interpreted by Perl.  The third argument is
 undefined unless for overloaded "q"- and "qr"- constants, it is "q" in
 single-quote context (comes from strings, regular expressions, and
 single-quote HERE documents), it is "tr" for arguments of "tr"/"y"
 operators, it is "s" for right-hand side of "s"-operator, and it is "qq"
 otherwise.

 Since an expression "ab$cd,," is just a shortcut for 'ab' . $cd . ',,',
 it is expected that overloaded constant strings are equipped with
 reasonable overloaded catenation operator, otherwise absurd results will
 result.  Similarly, negative numbers are considered as negations of
 positive constants.

 Note that it is probably meaningless to call the functions
 oovveerrllooaadd::::ccoonnssttaanntt(()) and oovveerrllooaadd::::rreemmoovvee__ccoonnssttaanntt(()) from anywhere but
 iimmppoorrtt(()) and uunniimmppoorrtt(()) methods.  From these methods they may be called
 as

     sub import {
        shift;
        return unless @_;
        die "unknown import: @_" unless @_ == 1 and $_[0] eq ':constant';
        overload::constant integer => sub {Math::BigInt->new(shift)};
     }

IIMMPPLLEEMMEENNTTAATTIIOONN #

 What follows is subject to change RSN.

 The table of methods for all operations is cached in magic for the symbol
 table hash for the package.  The cache is invalidated during processing
 of "use overload", "no overload", new function definitions, and changes
 in @ISA.

 (Every SVish thing has a magic queue, and magic is an entry in that
 queue.  This is how a single variable may participate in multiple forms
 of magic simultaneously.  For instance, environment variables regularly
 have two forms at once: their %ENV magic and their taint magic.  However,
 the magic which implements overloading is applied to the stashes, which
 are rarely used directly, thus should not slow down Perl.)

 If a package uses overload, it carries a special flag.  This flag is also
 set when new functions are defined or @ISA is modified.  There will be a
 slight speed penalty on the very first operation thereafter that supports
 overloading, while the overload tables are updated.  If there is no
 overloading present, the flag is turned off.  Thus the only speed penalty
 thereafter is the checking of this flag.

 It is expected that arguments to methods that are not explicitly supposed
 to be changed are constant (but this is not enforced).

CCOOOOKKBBOOOOKK #

 Please add examples to what follows!

TTwwoo--ffaaccee SSccaallaarrss Put this in _t_w_o___f_a_c_e_._p_m in your Perl library directory:

   package two_face;             # Scalars with separate string and
                                 # numeric values.
   sub new { my $p = shift; bless [@_], $p }
   use overload '""' => \&str, '0+' => \&num, fallback => 1;
   sub num {shift->[1]}
   sub str {shift->[0]}

 Use it as follows:

   require two_face;
   my $seven = two_face->new("vii", 7);
   printf "seven=$seven, seven=%d, eight=%d\n", $seven, $seven+1;
   print "seven contains 'i'\n" if $seven =~ /i/;

 (The second line creates a scalar which has both a string value, and a
 numeric value.)  This prints:

   seven=vii, seven=7, eight=8
   seven contains 'i'

TTwwoo--ffaaccee RReeffeerreenncceess Suppose you want to create an object which is accessible as both an array reference and a hash reference.

   package two_refs;
   use overload '%{}' => \&gethash, '@{}' => sub { $ {shift()} };
   sub new {
     my $p = shift;
     bless \ [@_], $p;
   }
   sub gethash {
     my %h;
     my $self = shift;
     tie %h, ref $self, $self;
     \%h;
   }

   sub TIEHASH { my $p = shift; bless \ shift, $p }
   my %fields;
   my $i = 0;
   $fields{$_} = $i++ foreach qw{zero one two three};
   sub STORE {
     my $self = ${shift()};
     my $key = $fields{shift()};
     defined $key or die "Out of band access";
     $$self->[$key] = shift;
   }
   sub FETCH {
     my $self = ${shift()};
     my $key = $fields{shift()};
     defined $key or die "Out of band access";
     $$self->[$key];
   }

 Now one can access an object using both the array and hash syntax:

   my $bar = two_refs->new(3,4,5,6);
   $bar->[2] = 11;
   $bar->{two} == 11 or die 'bad hash fetch';

 Note several important features of this example.  First of all, the
 _a_c_t_u_a_l type of $bar is a scalar reference, and we do not overload the
 scalar dereference.  Thus we can get the _a_c_t_u_a_l non-overloaded contents
 of $bar by just using $$bar (what we do in functions which overload
 dereference).  Similarly, the object returned by the TTIIEEHHAASSHH(()) method is
 a scalar reference.

 Second, we create a new tied hash each time the hash syntax is used.
 This allows us not to worry about a possibility of a reference loop,
 which would lead to a memory leak.

 Both these problems can be cured.  Say, if we want to overload hash
 dereference on a reference to an object which is _i_m_p_l_e_m_e_n_t_e_d as a hash
 itself, the only problem one has to circumvent is how to access this
 _a_c_t_u_a_l hash (as opposed to the _v_i_r_t_u_a_l hash exhibited by the overloaded
 dereference operator).  Here is one possible fetching routine:

   sub access_hash {
     my ($self, $key) = (shift, shift);
     my $class = ref $self;
     bless $self, 'overload::dummy'; # Disable overloading of %{}
     my $out = $self->{$key};
     bless $self, $class;        # Restore overloading
     $out;
   }

 To remove creation of the tied hash on each access, one may an extra
 level of indirection which allows a non-circular structure of references:

   package two_refs1;
   use overload '%{}' => sub { ${shift()}->[1] },
                '@{}' => sub { ${shift()}->[0] };
   sub new {
     my $p = shift;
     my $a = [@_];
     my %h;
     tie %h, $p, $a;
     bless \ [$a, \%h], $p;
   }
   sub gethash {
     my %h;
     my $self = shift;
     tie %h, ref $self, $self;
     \%h;
   }

   sub TIEHASH { my $p = shift; bless \ shift, $p }
   my %fields;
   my $i = 0;
   $fields{$_} = $i++ foreach qw{zero one two three};
   sub STORE {
     my $a = ${shift()};
     my $key = $fields{shift()};
     defined $key or die "Out of band access";
     $a->[$key] = shift;
   }
   sub FETCH {
     my $a = ${shift()};
     my $key = $fields{shift()};
     defined $key or die "Out of band access";
     $a->[$key];
   }

 Now if $baz is overloaded like this, then $baz is a reference to a
 reference to the intermediate array, which keeps a reference to an actual
 array, and the access hash.  The ttiiee(())ing object for the access hash is a
 reference to a reference to the actual array, so

 •   There are no loops of references.

 •   Both "objects" which are blessed into the class "two_refs1" are
     references to a reference to an array, thus references to a _s_c_a_l_a_r.
     Thus the accessor expression "$$foo->[$ind]" involves no overloaded
     operations.

SSyymmbboolliicc CCaallccuullaattoorr Put this in _s_y_m_b_o_l_i_c_._p_m in your Perl library directory:

   package symbolic;             # Primitive symbolic calculator
   use overload nomethod => \&wrap;

   sub new { shift; bless ['n', @_] }
   sub wrap {
     my ($obj, $other, $inv, $meth) = @_;
     ($obj, $other) = ($other, $obj) if $inv;
     bless [$meth, $obj, $other];
   }

 This module is very unusual as overloaded modules go: it does not provide
 any usual overloaded operators, instead it provides an implementation for
 "nomethod".  In this example the "nomethod" subroutine returns an object
 which encapsulates operations done over the objects: "symbolic->new(3)"
 contains "['n', 3]", "2 + symbolic->new(3)" contains "['+', 2, ['n',
 3]]".

 Here is an example of the script which "calculates" the side of
 circumscribed octagon using the above package:

   require symbolic;
   my $iter = 1;                 # 2**($iter+2) = 8
   my $side = symbolic->new(1);
   my $cnt = $iter;

   while ($cnt--) {
     $side = (sqrt(1 + $side**2) - 1)/$side;
   }
   print "OK\n";

 The value of $side is

   ['/', ['-', ['sqrt', ['+', 1, ['**', ['n', 1], 2]],
                        undef], 1], ['n', 1]]

 Note that while we obtained this value using a nice little script, there
 is no simple way to _u_s_e this value.  In fact this value may be inspected
 in debugger (see perldebug), but only if "bareStringify" OOption is set,
 and not via "p" command.

 If one attempts to print this value, then the overloaded operator "" will
 be called, which will call "nomethod" operator.  The result of this
 operator will be stringified again, but this result is again of type
 "symbolic", which will lead to an infinite loop.

 Add a pretty-printer method to the module _s_y_m_b_o_l_i_c_._p_m:

   sub pretty {
     my ($meth, $a, $b) = @{+shift};
     $a = 'u' unless defined $a;
     $b = 'u' unless defined $b;
     $a = $a->pretty if ref $a;
     $b = $b->pretty if ref $b;
     "[$meth $a $b]";
   }

 Now one can finish the script by

   print "side = ", $side->pretty, "\n";

 The method "pretty" is doing object-to-string conversion, so it is
 natural to overload the operator "" using this method.  However, inside
 such a method it is not necessary to pretty-print the _c_o_m_p_o_n_e_n_t_s $a and
 $b of an object.  In the above subroutine "[$meth $a $b]" is a catenation
 of some strings and components $a and $b.  If these components use
 overloading, the catenation operator will look for an overloaded operator
 "."; if not present, it will look for an overloaded operator "".  Thus it
 is enough to use

   use overload nomethod => \&wrap, '""' => \&str;
   sub str {
     my ($meth, $a, $b) = @{+shift};
     $a = 'u' unless defined $a;
     $b = 'u' unless defined $b;
     "[$meth $a $b]";
   }

 Now one can change the last line of the script to

   print "side = $side\n";

 which outputs

   side = [/ [- [sqrt [+ 1 [** [n 1 u] 2]] u] 1] [n 1 u]]

 and one can inspect the value in debugger using all the possible methods.

 Something is still amiss: consider the loop variable $cnt of the script.
 It was a number, not an object.  We cannot make this value of type
 "symbolic", since then the loop will not terminate.

 Indeed, to terminate the cycle, the $cnt should become false.  However,
 the operator "bool" for checking falsity is overloaded (this time via
 overloaded ""), and returns a long string, thus any object of type
 "symbolic" is true.  To overcome this, we need a way to compare an object
 to 0.  In fact, it is easier to write a numeric conversion routine.

 Here is the text of _s_y_m_b_o_l_i_c_._p_m with such a routine added (and slightly
 modified ssttrr(())):

   package symbolic;             # Primitive symbolic calculator
   use overload
     nomethod => \&wrap, '""' => \&str, '0+' => \&num;

   sub new { shift; bless ['n', @_] }
   sub wrap {
     my ($obj, $other, $inv, $meth) = @_;
     ($obj, $other) = ($other, $obj) if $inv;
     bless [$meth, $obj, $other];
   }
   sub str {
     my ($meth, $a, $b) = @{+shift};
     $a = 'u' unless defined $a;
     if (defined $b) {
       "[$meth $a $b]";
     } else {
       "[$meth $a]";
     }
   }
   my %subr = ( n => sub {$_[0]},
                sqrt => sub {sqrt $_[0]},
                '-' => sub {shift() - shift()},
                '+' => sub {shift() + shift()},
                '/' => sub {shift() / shift()},
                '*' => sub {shift() * shift()},
                '**' => sub {shift() ** shift()},
              );
   sub num {
     my ($meth, $a, $b) = @{+shift};
     my $subr = $subr{$meth}
       or die "Do not know how to ($meth) in symbolic";
     $a = $a->num if ref $a eq __PACKAGE__;
     $b = $b->num if ref $b eq __PACKAGE__;
     $subr->($a,$b);
   }

 All the work of numeric conversion is done in %subr and nnuumm(()).  Of
 course, %subr is not complete, it contains only operators used in the
 example below.  Here is the extra-credit question: why do we need an
 explicit recursion in nnuumm(())?  (Answer is at the end of this section.)

 Use this module like this:

   require symbolic;
   my $iter = symbolic->new(2);  # 16-gon
   my $side = symbolic->new(1);
   my $cnt = $iter;

   while ($cnt) {
     $cnt = $cnt - 1;            # Mutator '--' not implemented
     $side = (sqrt(1 + $side**2) - 1)/$side;
   }
   printf "%s=%f\n", $side, $side;
   printf "pi=%f\n", $side*(2**($iter+2));

 It prints (without so many line breaks)

   [/ [- [sqrt [+ 1 [** [/ [- [sqrt [+ 1 [** [n 1] 2]]] 1]
                           [n 1]] 2]]] 1]
      [/ [- [sqrt [+ 1 [** [n 1] 2]]] 1] [n 1]]]=0.198912
   pi=3.182598

 The above module is very primitive.  It does not implement mutator
 methods ("++", "-=" and so on), does not do deep copying (not required
 without mutators!), and implements only those arithmetic operations which
 are used in the example.

 To implement most arithmetic operations is easy; one should just use the
 tables of operations, and change the code which fills %subr to

   my %subr = ( 'n' => sub {$_[0]} );
   foreach my $op (split " ", $overload::ops{with_assign}) {
     $subr{$op} = $subr{"$op="} = eval "sub {shift() $op shift()}";
   }
   my @bins = qw(binary 3way_comparison num_comparison str_comparison);
   foreach my $op (split " ", "@overload::ops{ @bins }") {
     $subr{$op} = eval "sub {shift() $op shift()}";
   }
   foreach my $op (split " ", "@overload::ops{qw(unary func)}") {
     print "defining '$op'\n";
     $subr{$op} = eval "sub {$op shift()}";
   }

 Since subroutines implementing assignment operators are not required to
 modify their operands (see "Overloadable Operations" above), we do not
 need anything special to make "+=" and friends work, besides adding these
 operators to %subr and defining a copy constructor (needed since Perl has
 no way to know that the implementation of '+=' does not mutate the
 argument - see "Copy Constructor").

 To implement a copy constructor, add "'=' => \&cpy" to "use overload"
 line, and code (this code assumes that mutators change things one level
 deep only, so recursive copying is not needed):

   sub cpy {
     my $self = shift;
     bless [@$self], ref $self;
   }

 To make "++" and "--" work, we need to implement actual mutators, either
 directly, or in "nomethod".  We continue to do things inside "nomethod",
 thus add

     if ($meth eq '++' or $meth eq '--') {
       @$obj = ($meth, (bless [@$obj]), 1); # Avoid circular reference
       return $obj;
     }

 after the first line of wwrraapp(()).  This is not a most effective
 implementation, one may consider

   sub inc { $_[0] = bless ['++', shift, 1]; }

 instead.

 As a final remark, note that one can fill %subr by

   my %subr = ( 'n' => sub {$_[0]} );
   foreach my $op (split " ", $overload::ops{with_assign}) {
     $subr{$op} = $subr{"$op="} = eval "sub {shift() $op shift()}";
   }
   my @bins = qw(binary 3way_comparison num_comparison str_comparison);
   foreach my $op (split " ", "@overload::ops{ @bins }") {
     $subr{$op} = eval "sub {shift() $op shift()}";
   }
   foreach my $op (split " ", "@overload::ops{qw(unary func)}") {
     $subr{$op} = eval "sub {$op shift()}";
   }
   $subr{'++'} = $subr{'+'};
   $subr{'--'} = $subr{'-'};

 This finishes implementation of a primitive symbolic calculator in 50
 lines of Perl code.  Since the numeric values of subexpressions are not
 cached, the calculator is very slow.

 Here is the answer for the exercise: In the case of ssttrr(()), we need no
 explicit recursion since the overloaded "."-operator will fall back to an
 existing overloaded operator "".  Overloaded arithmetic operators _d_o _n_o_t
 fall back to numeric conversion if "fallback" is not explicitly
 requested.  Thus without an explicit recursion nnuumm(()) would convert "['+',
 $a, $b]" to "$a + $b", which would just rebuild the argument of nnuumm(()).

 If you wonder why defaults for conversion are different for ssttrr(()) and
 nnuumm(()), note how easy it was to write the symbolic calculator.  This
 simplicity is due to an appropriate choice of defaults.  One extra note:
 due to the explicit recursion nnuumm(()) is more fragile than ssyymm(()): we need
 to explicitly check for the type of $a and $b.  If components $a and $b
 happen to be of some related type, this may lead to problems.

_R_e_a_l_l_y SSyymmbboolliicc CCaallccuullaattoorr One may wonder why we call the above calculator symbolic. The reason is that the actual calculation of the value of expression is postponed until the value is _u_s_e_d.

 To see it in action, add a method

   sub STORE {
     my $obj = shift;
     $#$obj = 1;
     @$obj->[0,1] = ('=', shift);
   }

 to the package "symbolic".  After this change one can do

   my $a = symbolic->new(3);
   my $b = symbolic->new(4);
   my $c = sqrt($a**2 + $b**2);

 and the numeric value of $c becomes 5.  However, after calling

   $a->STORE(12);  $b->STORE(5);

 the numeric value of $c becomes 13.  There is no doubt now that the
 module symbolic provides a _s_y_m_b_o_l_i_c calculator indeed.

 To hide the rough edges under the hood, provide a ttiiee(())d interface to the
 package "symbolic".  Add methods

   sub TIESCALAR { my $pack = shift; $pack->new(@_) }
   sub FETCH { shift }
   sub nop {  }          # Around a bug

 (the bug, fixed in Perl 5.14, is described in "BUGS").  One can use this
 new interface as

   tie $a, 'symbolic', 3;
   tie $b, 'symbolic', 4;
   $a->nop;  $b->nop;    # Around a bug

   my $c = sqrt($a**2 + $b**2);

 Now numeric value of $c is 5.  After "$a = 12; $b = 5" the numeric value
 of $c becomes 13.  To insulate the user of the module add a method

   sub vars { my $p = shift; tie($_, $p), $_->nop foreach @_; }

 Now

   my ($a, $b);
   symbolic->vars($a, $b);
   my $c = sqrt($a**2 + $b**2);

   $a = 3; $b = 4;
   printf "c5  %s=%f\n", $c, $c;

   $a = 12; $b = 5;
   printf "c13  %s=%f\n", $c, $c;

 shows that the numeric value of $c follows changes to the values of $a
 and $b.

AAUUTTHHOORR #

 Ilya Zakharevich <_i_l_y_a_@_m_a_t_h_._m_p_s_._o_h_i_o_-_s_t_a_t_e_._e_d_u>.

SSEEEE AALLSSOO #

 The "overloading" pragma can be used to enable or disable overloaded
 operations within a lexical scope - see overloading.

DDIIAAGGNNOOSSTTIICCSS #

 When Perl is run with the --DDoo switch or its equivalent, overloading
 induces diagnostic messages.

 Using the "m" command of Perl debugger (see perldebug) one can deduce
 which operations are overloaded (and which ancestor triggers this
 overloading).  Say, if "eq" is overloaded, then the method "(eq" is shown
 by debugger.  The method "()" corresponds to the "fallback" key (in fact
 a presence of this method shows that this package has overloading
 enabled, and it is what is used by the "Overloaded" function of module
 "overload").

 The module might issue the following warnings:

 Odd number of arguments for overload::constant
     (W) The call to overload::constant contained an odd number of
     arguments.  The arguments should come in pairs.

 '%s' is not an overloadable type
     (W) You tried to overload a constant type the overload package is
     unaware of.

 '%s' is not a code reference
     (W) The second (fourth, sixth, ...) argument of overload::constant
     needs to be a code reference.  Either an anonymous subroutine, or a
     reference to a subroutine.

 overload arg '%s' is invalid
     (W) "use overload" was passed an argument it did not recognize.  Did
     you mistype an operator?

BBUUGGSS AANNDD PPIITTFFAALLLLSS #

 •   A pitfall when fallback is TRUE and Perl resorts to a built-in
     implementation of an operator is that some operators have more than
     one semantic, for example "|":

             use overload '0+' => sub { $_[0]->{n}; },
                 fallback => 1;
             my $x = bless { n => 4 }, "main";
             my $y = bless { n => 8 }, "main";
             print $x | $y, "\n";

     You might expect this to output "12".  In fact, it prints "<": the
     ASCII result of treating "|" as a bitwise string operator - that is,
     the result of treating the operands as the strings "4" and "8" rather
     than numbers.  The fact that numify ("0+") is implemented but
     stringify ("") isn't makes no difference since the latter is simply
     autogenerated from the former.

     The only way to change this is to provide your own subroutine for
     '|'.

 •   Magic autogeneration increases the potential for inadvertently
     creating self-referential structures.  Currently Perl will not free
     self-referential structures until cycles are explicitly broken.  For
     example,

         use overload '+' => 'add';
         sub add { bless [ \$_[0], \$_[1] ] };

     is asking for trouble, since

         $obj += $y;

     will effectively become

         $obj = add($obj, $y, undef);

     with the same result as

         $obj = [\$obj, \$foo];

     Even if no _e_x_p_l_i_c_i_t assignment-variants of operators are present in
     the script, they may be generated by the optimizer.  For example,

         "obj = $obj\n"

     may be optimized to

         my $tmp = 'obj = ' . $obj;  $tmp .= "\n";

 •   The symbol table is filled with names looking like line-noise.

 •   This bug was fixed in Perl 5.18, but may still trip you up if you are
     using older versions:

     For the purpose of inheritance every overloaded package behaves as if
     "fallback" is present (possibly undefined).  This may create
     interesting effects if some package is not overloaded, but inherits
     from two overloaded packages.

 •   Before Perl 5.14, the relation between overloading and ttiiee(())ing was
     broken.  Overloading was triggered or not based on the _p_r_e_v_i_o_u_s class
     of the ttiiee(())d variable.

     This happened because the presence of overloading was checked too
     early, before any ttiiee(())d access was attempted.  If the class of the
     value FFEETTCCHH(())ed from the tied variable does not change, a simple
     workaround for code that is to run on older Perl versions is to
     access the value (via "() = $foo" or some such) immediately after
     ttiiee(())ing, so that after this call the _p_r_e_v_i_o_u_s class coincides with
     the current one.

 •   Barewords are not covered by overloaded string constants.

 •   The range operator ".." cannot be overloaded.

perl v5.36.3 2023-02-15 overload(3p)