sub format_add{
  my ($x, $y) = @_;
  my $ret = $x + $y;
  my $digs = length $x;
  sprintf("%0${digs}d", $ret );
}
[download]

  $a=0.5;    print ++$a; #prints 1.5
  $a='a0.5'; print ++$a; #prints a6 
     #(so ++ ignores the dot and squashes the 0)
  $a='2a';   print ++$a; #prints 3 
     #(because 2a in numeric context returns 2)
[download]

Apparently it is a beast to handle with care.

Jeroen
"We are not alone"(FZ)

Not that I approve of this, but you would need to overload binary + to recognise when it is called in void context. Otherwise my $y = $x + 1; would modify $x with chaos resulting. I don't think there is a way to do that in the manner of wantarray.

As an aside, $a and $b are already magical, representing package scope variables sacred to sort. Also be careful of numbers with leading zeros. They can be taken as octal and refuse to recognise '8' and '9'

Update: Rereading your question, I think I misunderstood what you want. Here is code without any overloading:

sub addsome {
    ++$_[0] for 1..$_[1];
}
[download]

Update2: The code works, but it's not very efficient. Now I understand that you want addition to act on alphanumeric strings according to the rules for ++ on non-numeric strings. I suspect you don't require modification in place. That makes my comment about void context useless, and suggests that overload of binary + is perfectly approporiate.

After Compline,
Zaxo

Not that I approve of this, but you would need to overload binary + to recognise when it is called in void context. Otherwise my $y = $x + 1; would modify $x with chaos resulting. I don't think there is a way to do that in the manner of wantarray

.

When you write a method that overrides a binary operation (like add), the method gets passed three arguments - the two operands and a third argument which tells you if the operands have been swapped (for code like 1 + $obj). If this third argument is undef then the original statement is in void context.

Blessed Be
The Pixel

Since that third argument is ... ah, erm... overloaded, is it possible to tell the difference between 1 - $obj and $obj - 1 if they are both in void context? Will the third param be undef even if the arguments have been swapped?

-Blake

Perhaps someone more familiar with overloading can point out the shortcomings of this quick hack. (other than not working for negative numbers, and the really poor algorithm of repeating $x++ 10 times for $x + 10)

#!/usr/bin/perl -wT
use strict;

package MagicalPlus;

use overload
        '""'       => sub { ${$_[0]} },
        '+'        => \&myadd,
        'fallback' => 1;

sub myadd {
  my $first = ${$_[0]};
  my $second = $_[1];
  $first++ while($second-->0);
  return addmagic($first);
}

sub addmagic {
        my $string = "".shift;
        my $self = \$string;
        bless($self, __PACKAGE__);
}

package main;

my $x = MagicalPlus::addmagic "006";      # create our magic var

for (1..10) {                             # watch it works its magic
  print "$x + $_ = ";
  $x = $x + $_;        # magical?
  print "$x\n";
}


=OUTPUT
006 + 1 = 007
007 + 2 = 009
009 + 3 = 012
012 + 4 = 016
016 + 5 = 021
021 + 6 = 027
027 + 7 = 034
034 + 8 = 042
042 + 9 = 051
051 + 10 = 061
[download]

-Blake

$a+1 is a very useful idiom to ensure that the value is numeric, while $a++ is magic.

Please explain what you want it for.

sub magic
{
    my ($v, $i) = @_;
    $v=substr($v,0,length($v)-1).chr(ord(substr($v,-1))+$i);
}

print magic('a',  1), ", ";
print magic('c', -1), ", ";
print magic('meep', 2);

# will print "c, a, meer"
[download]