I prefer &$thingy over $thingy->().

Aren't these apples and oranges?

sub t {
    my $sub=shift;
    $sub->();
}
sub u {
    my $sub=shift;
    &$sub;
}
    
t(sub{print">@_<"},1,2,3,4,5);
u(sub{print">@_<"},1,2,3,4,5);
_END__
><
>1 2 3 4 5<
[download]

It's one character less (three less if you're not passing arguments), and it's more general.

More general? Im not sure I agree with that... And im not convinced about the one character less either. Id say that for the below its actually one character more. Especially given the above point that &{EXPR}() is the equivelent of EXPR->() and not &{EXPR}

do { sub { print 'foo' } }->();
( sub { print 'bar' } )->();
[download]

That's why I also prefer:$$hash_ref{key} = $$array_ref[1];

I class that notational style as a code smell. If I have to deal with code like that the first thing I do is switch it to use the infix dereference operator. And strangely I often find that the bug I was looking for just vanishes by doing so. IOW: this style is error prone and IMO a maintenance nightmare.

Are you saying that your code is littered with

&{do {
    # stuff here
    sub { ... };
}};
[download]

$$hash_ref{key} = $$array_ref[1];

Yes, I see that a lot in older code. The problem is that this syntax only works because of how tightly $ binds vs. {} or []. You're depending on the Perl parser always guessing correctly. Maybe I'm paranoid, but I prefer not making the parser guess my intention.

The official way of coding that is:

${$hash_ref}{key} = ${$array_ref}[1];
[download]

You may leave of the braces if the content of the block is a simple variable. Perhaps you find that obfuscated, but that's actually the same rule as the first (optional) argument of print. The file handle is passed as a block, and taken as the result, but if the block is a simple variable, you may leave off the braces. If that isn't obfuscated, why is the code I presented obfuscated? Or is it that you aren't used to it, and call anything you aren't used to obfuscated?

If you want to take a slice of a hash or an array, and all you have is a reference to it, how do you do it without being "obfuscated"? I write it as:

    @$hash_ref{$key1, $key2, $key3};
[download]

which follows naturally from accessing a single value:

    $$hash_ref{$key1};
[download]

But

    @hash_ref->{$key1, $key2, $key3};
[download]

doesn't work and nor does

    $hash_ref->{$key1, $key2, $key3};
[download]

And no, my code isn't littered with

    &{do {... sub {...}}};
[download]

{ Block returning a code reference }->(); doesn't work, but ( Block returning a code reference )->(); works, doesn't it?

Also &$thingy calls the subroutine with the same @_, so it's not the same as $thingy->(), this latter is really equivalent to &$thingy(). I think you probably thought of &$thingy() anyway, as that's what's one character less than $thingy->().