The zivad sub gets one parameter 'mago' in the array @_, which is stores in my $animal as a result of the default use of shift. It is shifting the leftmost scalar in the array @_. The my $list variable does not store a list but a scalar, namely the value of the %list hash for the key $animal. then the scalar $list is returned and printed...

This should be clearer

my %hash = (
            pas => 'vau-vau',
            macak => 'mijau',
            krava => 'muuuuu',
            pile => 'pi-pi',
            mago => 'ia-ia'
            );
            
sub zivad {
           my $animal = shift;
           my $hash_value = $hash{$animal} || die  "no  animal";
           return $hash_value;
           }
print zivad('mago');
[download]

Not that I would use those variable names but they give you an idea of what the variables contain.

%list can be accessed anywhere after my in the snippet you posted, and that's just what your subroutine is doing.

This is what happens step-by-step

• the subroutine call zivad('mago') puts "mago" into @_ and starts running the code in the subroutine zivad.
• my $animal = shift takes the first element of @_ (which will be "mago") and puts it in to $animal.
• my $list = $list{$animal} || die  "no  animal" does a few things:
  • Looks up $animal in %list and returns the value associated with "mago" ("ia-ia").
  • If the animal wasn't in %list, the script will stop (die) with the "no animal" error message.
  • The value returned from %list is assigned to $list.
• return $list returns "ia-ia" to the print that displays it on the screen.

The explanations given are correct. To elaborate on nefigah's point you will often find data structures which logically belong inside a subroutine defined outside. That is because if it is defined inside the subroutine the variable has to be initialized every time the subroutine is called. Unfortunately you can't just stick the variable next to the subroutine as the variable must be initialized before the subroutine is called.

eval { print speak('sheep'), "\n"; };
print $@ if $@;

my %says = (
    sheep  => 'baa',
    monkey => 'foo',
);

eval { print speak('monkey'), "\n"; };
print $@ if $@;

sub speak {
    my $animal = shift;
    die unless defined $says{$animal};
    return $says{$animal};
}
__END__
Died at Perl-1.pl line 21.
foo
[download]

Perl 5.10 has state variables for just this purpose, they are initialized only on the first time a function is called.

use 5.010_000;

eval { say speak('sheep'); };
print $@ if $@;

eval { say speak('monkey'); };
print $@ if $@;

sub speak {
    my $animal = shift;
    state $says = {
        sheep  => 'baa',
        monkey => 'foo',
    };
    die unless defined $says->{$animal};
    return $says->{$animal};
}
__END__
baa
foo
[download]

If you have to do this in earlier versions then wrap the data structure and sub routine in a BEGIN block so the data is initialized during compilation.

BEGIN {
    my %says = (
        sheep  => 'baa',
        monkey => 'foo',
    );

    sub speak {
        my $animal = shift;
        die unless defined $says{$animal};
        return $says{$animal};
    }
}
[download]

{
    my $says;

    sub speak {
        my $animal = shift;
        $says |= initialize_says();
        die unless defined $says->{$animal};
        return $says->{$animal};
    }
}
[download]

sub speak {
    my $animal = shift;
    state $says = initialize_says();
    die unless defined $says->{$animal};
    return $says->{$animal};
}
[download]

You should note that your subroutine here didn't "load" any part of the %list hash into @_ at all; instead you are relying on the fact that somewhere out there is a hash called %list that works how you want it to. As you can imagine, this is not necessarily the safest way to code. You would be better off either making the hash in the subroutine itself (if it's the only thing that uses it) or passing the hash as a parameter (or an element of the hash as a parameter, depending on what is needed) to the sub. This way everything doesn't break if things get moved around or messed with.

Also, as Pancho pointed out, names are important, especially when you're a beginner to help understand what's going on. I imagine the line:

my $list = $list{$animal}

is quite confusing, because you are making a new scalar variable that has the same name ('list') as a hash that you are accessing an element of (meaning you have to use the $ in front of both). This is legal but confusing. Also confusing is that you are calling the scalar $list, when in fact it's not a list at all.

I'm not sure if this is more advice than you bargained for, but do keep it in mind; it will make what's going on more obvious!

Or perlintro

Writing subroutines
Writing subroutines is easy:

    sub log {
        my $logmessage = shift;
        print LOGFILE $logmessage;
    }

What's that "shift"? Well, the arguments to a subroutine are available
to us as a special array called @_ (see perlvar for more on that). The
default argument to the "shift" function just happens to be @_. So "my
$logmessage = shift;" shifts the first item off the list of arguments
and assigns it to $logmessage.

We can manipulate @_ in other ways too:

    my ($logmessage, $priority) = @_;       # common
    my $logmessage = $_[0];                 # uncommon, and ugly

Subroutines can also return values:

    sub square {
        my $num = shift;
        my $result = $num * $num;
        return $result;
    }

For more information on writing subroutines, see perlsub.
[download]