Indeed, injunjoel managed to point out some rather cool uses of autovivification in The Uniqueness of hashes.. ;-)

Thy careless writing, brother, doth bring pain unto mine eyes, for verily thou mixest the high and low modes of address, like unto a novice that mistaketh his sigils, as "@foo[0]" &c. Wherefore I commend unto thee that when thou wouldst chastise thy brethren so, thou shouldst say instead "How thou discreditest thyself", or "how ye discredit yourself".

I think I agree with your point, though. Autovivification is one of those features that's both a strength and a weakness of Perl. A strength, because it's a very practical feature that makes life a bit easier for you and me; a weakness, because people who suffer from a surfeit of the wrong sort of laziness use it as an example of how Perl is "too hard".

Whoops! :-) Thanks for the correction. (And ++ for style :-)

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

Even the Perl people call autovivication - specifically when using exists - surprising behaviour:

exists

Near the bottom:
"This surprising autovivification in what does not at first--or even second--glance appear to be an lvalue context may be fixed in a future release."

I would not expect something that just returns true or false to modify the data that is passed to it. I know that people are going to say that it is not modifying the data passed to it - because you are actually dereferencing the hash elements in the CALL to exists() - not within exists itself. However, there must be some way to prevent it from happening when calling exists(). If any one of the lower hash keys does not exist in the hash being tested, then obviously the one you're testing for does not, and exists() should just return false.

It's not that hard.

Either, instead of exists, use Data::Diver (by tye):

$ perl -Mstrict -MData::Diver=Dive -MData::Dumper -wE '
my $h; $h->{foo}->{bar}->{baz} = "qux";
say Dumper $h;
say Dive( $h, qw/ foo bar baz / ) ? 1 : 0;
say Dive( $h, qw/ foo NOT baz / ) ? 1 : 0;
say Dumper $h;
'
$VAR1 = {
          'foo' => {
                     'bar' => {
                                'baz' => 'qux'
                              }
                   }
        };

1
0
$VAR1 = {
          'foo' => {
                     'bar' => {
                                'baz' => 'qux'
                              }
                   }
        };
[download]

Or, if you want to use exists, just test for each level that you are not sure exists before going any deeper:

$ perl -Mstrict -MData::Dumper -wE '
my $h; $h->{foo}->{bar}->{baz} = "qux";
say Dumper $h;
say( (exists $h->{foo}->{bar}->{baz}) ? 1 : 0 );
say( (exists $h->{foo}->{NOT} && exists $h->{foo}->{NOT}->{baz}) ? 1 :
+ 0 );
say Dumper $h;
'
$VAR1 = {
          'foo' => {
                     'bar' => {
                                'baz' => 'qux'
                              }
                   }
        };

1
0
$VAR1 = {
          'foo' => {
                     'bar' => {
                                'baz' => 'qux'
                              }
                   }
        };
[download]



The way forward always starts with a minimal test.