use overload '*' => sub {
    my $div = int(${$_[0]} / ${$_[1]});
    my $mod = ${$_[0]} % ${$_[1]};
    return ($div, $mod);
};
[download]

This still generates "30" for 90/30, regardless of context ... it's as if overloaded operators are allways called in some sort of bizarro scalar context where lists are evaluated as their last element instead of their length...

package mod;
use strict;
use overload '*' => sub {
    return ('yakko', 'wakko', 'dot');
};
sub new {
   my ($class,$val) = @_;
   return bless \$val, $class;
}
package main;
use strict;
my $i = mod->new(90);
my $j = mod->new(60);

my @x = $i * $j;
my $x = $i * $j;
print "@x\n";
print "$x\n";
__END__
dot
dot
[download]

Update: My bad, I totally spaced out on the fact that lists in scalar context evaluate to the last element... i was thinking of it just like an array.

The problem isn't with wantarray

I didn't mean to give the impression that I think the bug is in wantarray(). :-) I doubt that is the case. It is more likely that the overloaded sub is always called in a scalar context.

Whether this is a bug or not I cannot say. In a way it makes sense because non-overloaded arithmetic operators are unaffected by context:

    @a = 1 + 2;
    $a = 1 + 2;
[download]

However, it would be nice if the context was seen by the overloaded operator so that code like jeffa's would work. Also, in relation to overloaded <>, which should have a scalar and list context, it does seem to be a bug.

It's as if overloaded operators are always called in some sort of bizarro scalar context where lists are evaluated as their last element

The fact that the last element is returned is consistent with the observation that the overloaded operators are always called in a scalar context since this is what happens when a list is assigned to a scalar:

    $x = (1,2,3);
    print $x;     # prints 3
[download]

--
John.