package overload;
+our $VERSION = '1.00';
+
$overload::hint_bits = 0x20000;
sub nil {}
binary => "& | ^",
unary => "neg ! ~",
mutators => '++ --',
- func => "atan2 cos sin exp abs log sqrt",
+ func => "atan2 cos sin exp abs log sqrt int",
conversion => 'bool "" 0+',
iterators => '<>',
dereferencing => '${} @{} %{} &{} *{}',
=back
-B<Warning.> Due to the presense of assignment versions of operations,
+B<Warning.> Due to the presence of assignment versions of operations,
routines which may be called in assignment context may create
self-referential structures. Currently Perl will not free self-referential
structures until cycles are C<explicitly> broken. You may get problems
=item * I<Transcendental functions>
- "atan2", "cos", "sin", "exp", "abs", "log", "sqrt",
+ "atan2", "cos", "sin", "exp", "abs", "log", "sqrt", "int"
If C<abs> is unavailable, it can be autogenerated using methods
for "E<lt>" or "E<lt>=E<gt>" combined with either unary minus or subtraction.
+Note that traditionally the Perl function L<int> rounds to 0, thus for
+floating-point-like types one should follow the same semantic. If
+C<int> is unavailable, it can be autogenerated using the overloading of
+C<0+>.
+
=item * I<Boolean, string and numeric conversion>
"bool", "\"\"", "0+",
On the other hand, anyone who has used algebraic notation knows the
expressive power of the arithmetic metaphor. Overloading works hard
to enable this metaphor while preserving the Perlian way as far as
-possible. Since it is not not possible to freely mix two contradicting
+possible. Since it is not possible to freely mix two contradicting
metaphors, overloading allows the arithmetic way to write things I<as
far as all the mutators are called via overloaded access only>. The
way it is done is described in L<Copy Constructor>.
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,
-would would lead to a memory leak.
+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<implemented> as a
hash itself, the only problem one has to circumvent is how to access
-this I<actual> hash (as opposed to the I<virtual> exhibited by
+this I<actual> hash (as opposed to the I<virtual> hash exhibited by the
overloaded dereference operator). Here is one possible fetching routine:
sub access_hash {
$out;
}
-To move creation of the tied hash on each access, one may an extra
+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;
$a->[$key];
}
-Now if $baz is overloaded like this, then C<$bar> is a reference to a
+Now if $baz is overloaded like this, then C<$baz> is a reference to a
reference to the intermediate array, which keeps a reference to an
actual array, and the access hash. The tie()ing object for the access
-hash is also a reference to a reference to the actual array, so
+hash is a reference to a reference to the actual array, so
=over
I<components> $a and $b of an object. In the above subroutine
C<"[$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 C<.>, if not present, it will
+will look for an overloaded operator C<.>; if not present, it will
look for an overloaded operator C<"">. Thus it is enough to use
use overload nomethod => \&wrap, '""' => \&str;
and one can inspect the value in debugger using all the possible
methods.
-Something is is still amiss: consider the loop variable $cnt of the
+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 C<symbolic>, since then the loop will not terminate.
(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
+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]} );
way to know that the implementation of C<'+='> does not mutate
the argument, compare L<Copy Constructor>).
-To implement a copy constructor, add C<'=' => \&cpy> to C<use overload>
+To implement a copy constructor, add C<< '=' => \&cpy >> to C<use overload>
line, and code (this code assumes that mutators change things one level
deep only, so recursive copying is not needed):
https://perl5.git.perl.org / perl5.git / blobdiff