"Thanks Ken."

You're welcome.

"I am using strawberry version."

Strawberry provides many versions of Perl. It's the version of Perl that was important here. You can find that with the "perl -v" command.

As an example, you can see that I'm currently using version 5.28:

$ perl -v

This is perl 5, version 28, subversion 0 (v5.28.0) built for darwin-th
+read-multi-2level
...
[download]

Which means I can write:

$ perl -E 'my $href = { key => 42 }; my %h = $href->%*; say $h{key}'
42
[download]

G'day Ken,

Can you please share for the genuinely curious what you find advantageous about writing:

my %h = $href->%*;
[download]

vs. either of

my %h = %$href;
my %h = %{$href};
[download]

both of which are shorter and show the eye with the first character, rather than the penultimate, what the product is going to be?


The way forward always starts with a minimal test.

The example I showed with $href->%* was highly simplistic. It was intended to show that, with 5.28, I could use the new syntax and didn't need to include a 'use feature' statement.

When dealing with simple references, I would typically use @$aref, %$href, and so on, rather than $aref->@*, $href->%*, etc.

When working with complex data structures, that simple reference becomes a series of keys and indexes read from left-to-right. Adding a postfix dereference continues that left-to-right progression: you don't need to scan back to the beginning of the expression to determine what dereferencing is being used. Consider these two:

$href->{$key1}[$i]{$key2}->%*;
%{$href->{$key1}[$i]{$key2}};
[download]

Of course, they're only short, example variable names. In production code, I'd be using meaningful variable names:

$meaningful_href->{$meaningful_outer_key}[$meaningful_index]{$meaningf
+ul_inner_key}->%*;
%{$meaningful_href->{$meaningful_outer_key}[$meaningful_index]{$meanin
+gful_inner_key}};
[download]

Here, the benefit of not having to scan back to the beginning of the expression becomes more obvious.

Except for the simple references, like %$href, there's only one additional character when using the postfix syntax: I wouldn't consider that to be a reason to use, or not use, it.

When whatever is being dereferenced is more complicated than a simple reference, I would recommend adding the braces (e.g. prefer @{$complex_ref} over @$complex_ref). Even when @$complex_ref seems completely transparent to the author, it might easily be less obvious to the next maintainer.

Using postfix dereferencing, in the contexts I've described above, is my personal preference for the reasons given. I would recommend its use to others for the same reasons. I certainly wouldn't suggest anyone must use it.

In "Re^3: nodelocked vs floating", I did point out that it took me "a little while to get used to": if you're considering giving it a try, you might also want to give it a little while also.

Finally, some practical notes on usage:

• I've been writing Perl code for $work for about 25 years and, in all that time, I've never been in a position to write code requiring a Perl version greater than 5.16: so I've never used postfix dereferencing in any actual production code. Consider your clients' resources before adding a use 5.018; (or later version) to your code.
• For CPAN code, unless there was some other overriding reason to require 5.18 or later — for example, there may be a need to support a particular Unicode version — I wouldn't recommend postfix dereferencing here.
• I have used postfix dereferencing extensively in my own personal code. I'm very happy with it.

— Ken