From perlop (under Assignment Operators):

    Assignment operators work as in C. That is,

        $a += 2;

    is equivalent to

        $a = $a + 2;

    although without duplicating any side effects that
    dereferencing the lvalue might trigger
[download]

It's that last part, about avoiding dereferencing side effects, that comes into play here.

When you do:

    $baseball{yankees} = $baseball{yankees} . $baseball{mets};
[download]

you are incurring a side effect of dereferencing $baseball{yankees}, namely testing for definedness, which you won't incur when you use the assignment operator:

    $baseball{yankees} .= $baseball{mets}
[download]

Its not clear to me what the "avoiding dereferencing side effects" part of the documentation means exactly, however I feel pretty confident in saying that it isnt relevent here. When you do

$hash{key}.=$str;
[download]

there is no dereferencing going on. With

$hash->{key}.=$str;
[download]

there is, however it happens before the .= operator is involved, so it doesnt explain the special casing behaviour of .= and other mutator operators. It turns out that the documentation of this behaviour is not to be found in perlop, but rather in perlsyn (in the section Declarations):

Operators such as ++, --, +=, -=, and .=, that operate on undefined le
+ft values such as:

    my $a;
    $a++;

are also always exempt from such warnings.
[download]

Hope this clears things up for you.

---
$world=~s/war/peace/g