join @_;
[download]

Then the @_ is evaluated in scalar context as the separator, with an empty list of items to join.

So join and myjoin evaluate their arguments differently, and it's no surprise that they lead to difference in autovivification.

OK, but how to fix that and how can I avoid autovivification of the original hash?

return (join (@_)); Same result.

return join {@{\@_}) Same result.

my ($sep, @a) = @_;
return join($sep, @a);
[download]

More warnings, but same result (original hash modified, but shouldn't).

The problem is that the parameters being passed to the user subroutine are being evaluated as they are passed, so the autovivify has already been done before the subroutine receives them. Apparently, (some wild-assed guess here) the built in join has some magic to check for existence before trying to evaluate.

If you pass a hash reference and key value separately to your myjoin, you have a chance to check for existence before the key can be autovivified. It isn't as slick as the builtin, but it's not too bad.

use Data::Dumper;
sub mydump($) {
    print Data::Dumper->Dump( [ $_[0] ], ['*hash'] );
}

sub myjoin {
    return unless exists($_[1]->{$_[2]});
    return join $_[0], $_[1]->{$_[2]};
}

my %hash;
my $s1 = join( ':', @hash{qw(key)} );
mydump( \%hash );
my $s2 = myjoin( ':', \%hash, 'key' );
mydump( \%hash );
[download]

Yeah, that is clear :). My problem is the modification of the original hash without touching the hash itself... and it only happens with hash slices :(

Ah. Sorry, kind of glossed over the "slice" aspect there. All right, try this then.

use Data::Dumper;
sub mydump($) {
    print Data::Dumper->Dump( [ $_[0] ], ['*hash'] );
}

sub myjoin {
    my ($sep, $href, @keys) = @_;
    my @exists = grep { exists($href->{$_}) } @keys;
    return join $sep, @exists;
}

my %hash = (key1 => 'a');
my $s1 = join( ':', @hash{qw(key)} );
mydump( \%hash );
my $s2 = myjoin( ':', \%hash, qw/key1 key2 key3/ );
mydump( \%hash );
[download]

Autovivification happens in an lvalue context (a place where a variable might be modified, not just 'read'). Arguments to user subroutines can be modified (but usually aren't). Perl knows that the join built-in doesn't modify the arguments passed to it. Perl 5 does not provide a way for you to declare that a user subroutine refuses to modify any arguments, nor does Perl try to analyze subroutines to determine this and thus change how arguments are prepared to be passed in.

So don't put your slice into an lvalue context. Many ways to do that, including:

myjoin( @_= @hash{@keys} );
myjoin( my @x= @hash{@keys} );
myjoin( @{[ @hash{@keys} ]} );
[download]

myjoin( map $_, @hash{@keys} );
[download]

myjoin( map $hash{$_}, @keys );
[download]

Scratch that last:

>perl -E"sub {}->( map $_, @h{x} ); say exists($h{x}) || 0;
1
[download]

map aliases $_ to its operands, so its operands are lvalues. do{} creates copies.

If you use a hash slice in lvalue context, Perl must create the elements of the slice in case they will actually be modified.

>perl -E"1 for @h{x}; say exists($h{x}) || 0;
1

>perl -E"sub {}->( @h{x} ); say exists($h{x}) || 0;
1

>perl -E"my $r = \@h{x}; say exists($h{x}) || 0;
1
[download]

The for loop might assign to $_ with the intention of changing $h{x}, so a copy can't be used.

The sub might assign to $_[0] with the intention of changing $h{x}, so a copy can't be used.

$$r must refer to $h{x}, so a copy can't be used.

As for join, it's a builtin operator (just like ("+"), not a sub call. Perl knows it doesn't need for lvalues, so it provide any. That's not the case for subs, though. Perl has no idea if the sub will pass values back by reference, so it much create lvalues just in case.

>perl -E"1 for $h{x}; say exists($h{x}) || 0;
1

>perl -E"sub {}->( $h{x} ); say exists($h{x}) || 0;
0

>perl -E"\@h{x}; say exists($h{x}) || 0;
1
[download]

To avoid vivification of the hash elements, you must avoid using the hash slice in lvalue context. You can do that by making copies of the values returned by the slice.

>perl -E"sub {}->( @{[ @h{x} ]} );  say exists($h{x}) || 0;"
0

>perl -E"sub {}->( do { @h{x} } );  say exists($h{x}) || 0;"
0
[download]

etc.

Thank you very much, it clarifies it all :)

Same, even when prototypes removed.