func => "atan2 cos sin exp abs log sqrt int",
conversion => 'bool "" 0+',
iterators => '<>',
+ filetest => "-X",
dereferencing => '${} @{} %{} &{} *{}',
+ matching => '~~',
special => 'nomethod fallback =');
use warnings::register;
...
package main;
- $a = new SomeThing 57;
+ $a = SomeThing->new( 57 );
$b=5+$a;
...
if (overload::Overloaded $b) {...}
=head1 DESCRIPTION
+This pragma allows overloading of Perl's operators for a class.
+To overload built-in functions, see L<perlsub/Overriding Built-in Functions> instead.
+
=head2 Declaration of overloaded functions
The compilation directive
B<BUGS> Even in list context, the iterator is currently called only
once and with scalar context.
+=item * I<File tests>
+
+ "-X"
+
+This overload is used for all the filetest operators (C<-f>, C<-x> and
+so on: see L<perlfunc/-X> for the full list). Even though these are
+unary operators, the method will be called with a second argument which
+is a single letter indicating which test was performed. Note that the
+overload key is the literal string C<"-X">: you can't provide separate
+overloads for the different tests.
+
+Calling an overloaded filetest operator does not affect the stat value
+associated with the special filehandle C<_>. It still refers to the
+result of the last C<stat>, C<lstat> or unoverloaded filetest.
+
+If not overloaded, these operators will fall back to the default
+behaviour even without C<< fallback => 1 >>. This means that if the
+object is a blessed glob or blessed IO ref it will be treated as a
+filehandle, otherwise string overloading will be invoked and the result
+treated as a filename.
+
+This overload was introduced in perl 5.12.
+
+=item * I<Matching>
+
+The key C<"~~"> allows you to override the smart matching used by
+the switch construct. See L<feature>.
+
=item * I<Dereferencing>
'${}', '@{}', '%{}', '&{}', '*{}'.
=item * I<Special>
- "nomethod", "fallback", "=", "~~",
+ "nomethod", "fallback", "=".
see L<SPECIAL SYMBOLS FOR C<use overload>>.
func => 'atan2 cos sin exp abs log sqrt',
conversion => 'bool "" 0+',
iterators => '<>',
+ filetest => '-X',
dereferencing => '${} @{} %{} &{} *{}',
+ matching => '~~',
special => 'nomethod fallback ='
=head2 Inheritance and overloading
B<Note.> C<"fallback"> inheritance via @ISA is not carved in stone
yet, see L<"Inheritance and overloading">.
-=head2 Smart Match
-
-The key C<"~~"> allows you to override the smart matching used by
-the switch construct. See L<feature>.
-
=head2 Copy Constructor
The value for C<"="> is a reference to a function with three
one may need to I<explicitly unlink> other values which references the
same value:
- $a = new Data 23;
+ $a = Data->new(23);
...
$b = $a; # $b is "linked" to $a
...
Note that overloaded access makes this transparent:
- $a = new Data 23;
+ $a = Data->new(23);
$b = $a; # $b is "linked" to $a
$a += 4; # would unlink $b automagically
However, it would not make
- $a = new Data 23;
+ $a = Data->new(23);
$a = 4; # Now $a is a plain 4, not 'Data'
preserve "objectness" of $a. But Perl I<has> a way to make assignments
Use it as follows:
require two_face;
- my $seven = new two_face ("vii", 7);
+ 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/;
Now one can access an object using both the array and hash syntax:
- my $bar = new two_refs 3,4,5,6;
+ my $bar = two_refs->new(3,4,5,6);
$bar->[2] = 11;
$bar->{two} == 11 or die 'bad hash fetch';
provide any usual overloaded operators, instead it provides the L<Last
Resort> operator C<nomethod>. In this example the corresponding
subroutine returns an object which encapsulates operations done over
-the objects: C<new symbolic 3> contains C<['n', 3]>, C<2 + new
-symbolic 3> contains C<['+', 2, ['n', 3]]>.
+the objects: C<< symbolic->new(3) >> contains C<['n', 3]>, C<< 2 +
+symbolic->new(3) >> contains C<['+', 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 = new symbolic 1;
+ my $side = symbolic->new(1);
my $cnt = $iter;
while ($cnt--) {
Use this module like this:
require symbolic;
- my $iter = new symbolic 2; # 16-gon
- my $side = new symbolic 1;
+ my $iter = symbolic->new(2); # 16-gon
+ my $side = symbolic->new(1);
my $cnt = $iter;
while ($cnt) {
to the package C<symbolic>. After this change one can do
- my $a = new symbolic 3;
- my $b = new symbolic 4;
+ 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