Re: Arrow Operator Question

G'day sectokia,

[Note: $a (and $b) are special variables; it's best to only use these for their intended purposes to avoid unexpected side effects; I've replaced $a with $h in the code below. Also, '//undef' is completely superfluous: if the LHS is undef, use undef instead. :-)]

See Autovivification and Arrow Notation in perlref.

Perl will autovivify as needed. It requires 'c' to check for 'd', so that key is autovivified. The 'd' key either exists and has a value or it doesn't exist and the value is undef: no autovivification is needed here.

You can use exists() to check for 'c'; only attempting to get a value for 'd' if 'c' exists. That can become unwieldy when there are multiple levels of keys; if you think autovivification is a problem, simply allow it then delete() afterwards.

The following code has examples which demonstrate these points.

$ perl -E '
    use Data::Dump;

    {
        say "*** Autovivification";

        my $h = { b => {} };
        dd $h;

        my $f = $h->{b}{c};
        say $f // "undefined";
        dd $h;

        my $g = $h->{b}{c}{d};
        say $g // "undefined";
        dd $h;
    }

    {
        say "*** No autovivification";

        my $h = { b => {} };
        dd $h;

        my $f = $h->{b}{c};
        say $f // "undefined";
        dd $h;

        my $g = exists $h->{b}{c} ? $h->{b}{c}{d} : undef;
        say $g // "undefined";
        dd $h;
    }

    {
        say "*** Autovivify then delete";

        my $h = { b => {} };
        dd $h;

        my $f = $h->{b}{c}{x}{y}{z};
        say $f // "undefined";
        dd $h;
        delete $h->{b}{c};
        dd $h;
    }

'
[download]

Output:

*** Autovivification
{ b => {} }
undefined
{ b => {} }
undefined
{ b => { c => {} } }
*** No autovivification
{ b => {} }
undefined
{ b => {} }
undefined
{ b => {} }
*** Autovivify then delete
{ b => {} }
undefined
{ b => { c => { x => { y => {} } } } }
{ b => {} }
[download]

— Ken

Comment on Re: Arrow Operator Question Select or Download Code

Replies are listed 'Best First'.
Re^2: Arrow Operator Question by BillKSmith (Monsignor) on Mar 27, 2023 at 14:24 UTC
I prefer to implement kcott's idea this way. "Short circuit" operation of the `and` operator C style Logical And prevents unnecessary testing which would cause autovivification. `use strict; use warnings; use Data::Dumper; use Test::More tests=>2; my $h = { b => {} }; my $f = $h->{b}{c}{d} if exists($h->{b}{c}) and exists($h->{b}{c}{d}); is_deeply( $h, { b => {} }, 'no autovivification' ); is( $f, undef, 'no value assigned' );` [download] OUTPUT: `1..2 ok 1 - no autovivification ok 2 - no value assigned` [download] Bill	[reply] [d/l] [select]
Re^3: Arrow Operator Question by hv (Prior) on Mar 27, 2023 at 17:28 UTC
`my $f = $h->{b}{c}{d} if exists($h->{b}{c}) and exists($h->{b}{c}{d});` This is dangerous: the nature of `my $var = ... if ...` is predictable but very noninuitive (it acts something like a state variable). It has long been regarded as a bug that perl core would dearly love to fix, but cannot due to back-compat. I recommend always either splitting out the declaration from the assignment: `my $f; $f = $h->{b}{c}{d} if exists($h->{b}{c}) and exists($h->{b}{c}{d});` [download] .. or using `state` explicitly when that's what you actually intend: `use feature 'state'; # 'use 5.10' or later also gives this automatica +lly state $f = $h->{b}{c}{d} if exists($h->{b}{c}) and exists($h->{b}{c}{d +});` [download]	[reply] [d/l] [select]
Re^4: Arrow Operator Question by BillKSmith (Monsignor) on Mar 28, 2023 at 18:07 UTC
I was a bit surprised that my `my` did work as I intended. I choose to use it in the interest of conforming to the original code as much as possible. Thanks for the explanation. Bill	[reply] [d/l]
Re^3: Arrow Operator Question by kcott (Archbishop) on Mar 27, 2023 at 16:57 UTC
G'day Bill, That's certainly a valid way to go. Consider the following: $ perl -e ' use strict; use warnings; use Test::More tests => 8; my $h = { b => {} }; my ($f, $f2, $f3, $f4); $f = $h->{b}{c}{d} if exists($h->{b}{c}) and exists($h->{b}{c}{d}) +; is_deeply( $h, { b => {} }, "no autovivification" ); is( $f, undef, "no value assigned" ); $f2 = $h->{b}{c}{d} if exists $h->{b}{c}; is_deeply $h, { b => {} }, "f2: no autovivification"; is $f2, undef, "f2: no value assigned"; $f3 = $h->{b}{c}{d}{x}{y}{z} if exists $h->{b}{c} and exists $h->{b}{c}{d} and exists $h->{b}{c}{d}{x} and exists $h->{b}{c}{d}{x}{y}; is_deeply $h, { b => {} }, "f3: no autovivification"; is $f3, undef, "f3: no value assigned"; $f4 = $h->{b}{c}{d}{x}{y}{z}; delete $h->{b}{c}; is_deeply $h, { b => {} }, "f4: autovivification removed"; is $f4, undef, "f4: no value assigned"; ' [download] Update: The code above is a modification of the original. Something was niggling me about what I first wrote, but I couldn't see the problem. ++hv's response to your post alerted me to the issue. My first, less-than-good effort is in the spoiler below. Note that the output is unchanged. <Reveal this spoiler or all in this thread> Output: `1..8 ok 1 - no autovivification ok 2 - no value assigned ok 3 - f2: no autovivification ok 4 - f2: no value assigned ok 5 - f3: no autovivification ok 6 - f3: no value assigned ok 7 - f4: autovivification removed ok 8 - f4: no value assigned` [download] Short-circuiting is not actually needed in your example (see f2) Short-circuiting works but can be unwieldy with more complex data structures (see f3) Allowing autovivification then removing it results in cleaner, and easier to maintain, code (see f4) This option has potential drawbacks. Consider the case where `$h->{b}{c}{q}` existed and had a meaningful and required value but is removed by '`delete $h->{b}{c}`'. On second thoughts: this is probably a very bad idea (even though it does work in this specific test script). I think each has its merits and probably comes down to best choice on a case by case basis. — Ken	[reply] [d/l] [select]
Re^4: Arrow Operator Question by BillKSmith (Monsignor) on Mar 28, 2023 at 18:02 UTC
sectokia only showed us the fail case. I assume that his code worked as he expected in the pass case. I should have demonstrated that my code produced the same result in that case. `use strict; use warnings; use Data::Dumper; use Test::More tests=>2; my $h = { b => { c => { d => 'value' } } }; my $g = $h->{b}{c}{d} if exists($h->{b}{c}) and exists($h->{b}{c}{d}); my $f = $h->{b}{c}{d}//undef; # Original Code is( $g, $f, $f ); is_deeply( $h, { b => { c => { d => 'value' } } }, 'no change' );` [download] The difference between your various f's is not merely one of style, but one of requirements (which we really do not know). Bill	[reply] [d/l]
Re^2: Arrow Operator Question by sectokia (Pilgrim) on Mar 27, 2023 at 08:41 UTC
Thanks. The reason I had undef was the style I generally use is more like this: `if ($foo == ($bar->{c}{d}{e}//'moo')) { ... }`	[reply] [d/l]
Re^3: Arrow Operator Question by kcott (Archbishop) on Mar 27, 2023 at 10:14 UTC
"`if ($foo == ($bar->{c}{d}{e}//'moo')) { ... }`" You may have typed that in a hurry. While I do follow the gist of what you're saying, I do hope you're aware that '`==`' is used for numbers (e.g. `300`) and '`eq`' is used for strings (e.g. `"moo"`). See "perlop: Equality Operators" for more complete details. — Ken	[reply] [d/l] [select]


Perl-Sensitive Sunglasses
	PerlMonks