That's because the (scalar) operator of an op= imposes scalar context on the lists and so only the last element of each list is affected:

c:\@Work\Perl\monks>perl -wMstrict -le
"my ($x, $y, $z) = (30, 40, 50);
 ($x, $y, $z) += (3, 4, 5);
 print qq{$x, $y, $z};
"
Useless use of a constant in void context at -e line 1.
Useless use of a constant in void context at -e line 1.
Useless use of private variable in void context at -e line 1.
Useless use of private variable in void context at -e line 1.
30, 40, 55
[download]

Update: I'm not aware that you can do this with pure lists in Perl 5, but it can certainly be done with arrays:

c:\@Work\Perl\monks>perl -wMstrict -le
"my @ra = (30, 40, 50);
 my @rb = ( 3,  4,  5);
 ;;
 $ra[$_] += $rb[$_] for 0 .. $#ra;
 print qq{@ra};
"
33 44 55
[download]

c:\@Work\Perl\monks>perl -wMstrict -le
"use List::MoreUtils qw(pairwise);
 use vars qw($a $b);
 ;;
 my @ra = (30, 40, 50);
 my @rb = ( 3,  4,  5);
 ;;
 my @rc = pairwise { $a + $b } @ra, @rb;
 print qq{@rc};
"
33 44 55
[download]

c:\@Work\Perl\monks>perl -wMstrict -le
"use List::MoreUtils qw(pairwise);
 use vars qw($a $b);
 ;;
 my @ra = (30, 40, 50);
 my @rb = ( 3,  4,  5);
 ;;
 pairwise { $a += $b } @ra, @rb;
 print qq{@ra};
"
33 44 55
[download]

Exactly — they look analogous, but they are not. The List::MoreUtils tricks are interesting, but actually wrap a loop iterating over arrays instead of being a true "vectorized" modifying assignment. There is probably something in PDL for this if your program does that kind of processing, but for a simple case with a list of Perl scalars, you need to use multiple statements.

PDL is all about the "array programming", where you do an operation to the whole ndarray, and PDL just does that thing to everything in it. So for an ndarray, $pdl += 1 really would add 1 to all the elements in it.

This is an example of the array-programming concept known these days as "broadcasting", which PDL used to slightly-confusingly call "threading".

If you really needed this, it could be done with a little syntactic sugar

something like

L($x,$y,$z) += L(1,2,3);

the trick would be to let L() ( for "list" ) return an object with overload ed operators (in scalar context) performing the side-effect

Tho I'm not sure if the RHS needs to be packed into an object too, but I assume += is imposing scalar context.

A bit trickier than I originally thought. What I didn't expect was the need to use the :lvalue on both the listifier and constructor.

#!/usr/bin/perl
use warnings;
use strict;
use feature qw{ say };

{   package L;
    use overload
        '+=' => sub {
            my ($self, $inc) = @_;
            $_ += shift @$inc for @$self;
        };
    sub new :lvalue {
        bless $_[1], $_[0]
    }
}
sub L :lvalue { 'L'->new(\@_) }

my ($x, $y, $z) = (10, 20, 30);
L($x, $y, $z) += L(3, 2, 1);
say "$x $y $z";  # 13 22 31
[download]

You can use [3, 2, 1] on the RHS, as well.
map{substr$_->[0],$_->[1]||0,1}[\*||{},3],[[]],[ref qr-1,-,-1],[{}],[sub{}^*ARGV,3]

Hi

> A bit trickier than I originally thought.

I was about to update that one needs :lvalue and returning a tied scalar then.

Surprised you made it without tie , my last use case must have been different than. :)

update

> You can use [3, 2, 1] on the RHS, as well.

Nice! :)

> on both the listifier and constructor.

Genius!!! that's how you avoided using Tie::Scalar! :)

Cheers Rolf
_{(addicted to the Perl Programming Language :)
Wikisyntax for the Monastery}