package overload;
-our $VERSION = '1.00';
+our $VERSION = '1.03';
-$overload::hint_bits = 0x20000;
+$overload::hint_bits = 0x20000; # HINT_LOCALIZE_HH
sub nil {}
sub AddrRef {
my $package = ref $_[0];
return "$_[0]" unless $package;
- bless $_[0], overload::Fake; # Non-overloaded package
- my $str = "$_[0]";
- bless $_[0], $package; # Back
- $package . substr $str, index $str, '=';
-}
-sub StrVal {
- (OverloadedStringify($_[0]) or ref($_[0]) eq 'Regexp') ?
- (AddrRef(shift)) :
- "$_[0]";
+ require Scalar::Util;
+ my $class = Scalar::Util::blessed($_[0]);
+ my $class_prefix = defined($class) ? "$class=" : "";
+ my $type = Scalar::Util::reftype($_[0]);
+ my $addr = Scalar::Util::refaddr($_[0]);
+ return sprintf("$class_prefix$type(0x%x)", $addr);
}
+*StrVal = *AddrRef;
+
sub mycan { # Real can would leave stubs.
my ($package, $meth) = @_;
return \*{$package . "::$meth"} if defined &{$package . "::$meth"};
}
%constants = (
- 'integer' => 0x1000,
- 'float' => 0x2000,
- 'binary' => 0x4000,
- 'q' => 0x8000,
- 'qr' => 0x10000,
+ 'integer' => 0x1000, # HINT_NEW_INTEGER
+ 'float' => 0x2000, # HINT_NEW_FLOAT
+ 'binary' => 0x4000, # HINT_NEW_BINARY
+ 'q' => 0x8000, # HINT_NEW_STRING
+ 'qr' => 0x10000, # HINT_NEW_RE
);
%ops = ( with_assign => "+ - * / % ** << >> x .",
=head1 NAME
-overload - Package for overloading perl operations
+overload - Package for overloading Perl operations
=head1 SYNOPSIS
"**", "**=", "<<", "<<=", ">>", ">>=", "x", "x=", ".", ".=",
For these operations a substituted non-assignment variant can be called if
-the assignment variant is not available. Methods for operations "C<+>",
-"C<->", "C<+=>", and "C<-=>" can be called to automatically generate
-increment and decrement methods. The operation "C<->" can be used to
+the assignment variant is not available. Methods for operations C<+>,
+C<->, C<+=>, and C<-=> can be called to automatically generate
+increment and decrement methods. The operation C<-> can be used to
autogenerate missing methods for unary minus or C<abs>.
See L<"MAGIC AUTOGENERATION">, L<"Calling Conventions for Mutators"> and
"&", "^", "|", "neg", "!", "~",
-"C<neg>" stands for unary minus. If the method for C<neg> is not
+C<neg> stands for unary minus. If the method for C<neg> is not
specified, it can be autogenerated using the method for
-subtraction. If the method for "C<!>" is not specified, it can be
-autogenerated using the methods for "C<bool>", or "C<\"\">", or "C<0+>".
+subtraction. If the method for C<!> is not specified, it can be
+autogenerated using the methods for C<bool>, or C<"">, or C<0+>.
=item * I<Increment and decrement>
=item * I<Boolean, string and numeric conversion>
- "bool", "\"\"", "0+",
+ 'bool', '""', '0+',
If one or two of these operations are not overloaded, the remaining ones can
be used instead. C<bool> is used in the flow control operators
-(like C<while>) and for the ternary "C<?:>" operation. These functions can
+(like C<while>) and for the ternary C<?:> operation. These functions can
return any arbitrary Perl value. If the corresponding operation for this value
is overloaded too, that operation will be called again with this value.
happens both for the I<read-filehandle> syntax C<E<lt>$varE<gt>> and
I<globbing> syntax C<E<lt>${var}E<gt>>.
+B<BUGS> Even in list context, the iterator is currently called only
+once and with scalar context.
+
=item * I<Dereferencing>
'${}', '@{}', '%{}', '&{}', '*{}'.
=item overload::StrVal(arg)
-Gives string value of C<arg> as in absence of stringify overloading.
+Gives string value of C<arg> as in 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
+C<Scalar::Util::refaddr()>, which is faster.
=item overload::Overloaded(arg)
=head1 Overloading constants
-For some application Perl parser mangles constants too much. It is possible
-to hook into this process via overload::constant() and overload::remove_constant()
-functions.
+For some applications, the Perl parser mangles constants too much.
+It is possible to hook into this process via C<overload::constant()>
+and C<overload::remove_constant()> functions.
These functions take a hash as an argument. The recognized keys of this hash
-are
+are:
=over 8
=head2 Two-face references
Suppose you want to create an object which is accessible as both an
-array reference and a hash reference, similar to the
-L<pseudo-hash|perlref/"Pseudo-hashes: Using an array as a hash">
-builtin Perl type. Let's make it better than a pseudo-hash by
-allowing index 0 to be treated as a normal element.
+array reference and a hash reference.
package two_refs;
use overload '%{}' => \&gethash, '@{}' => sub { $ {shift()} };