for my $i (0..$#scores) { print $scores[$i], "\n"; }

for my $score (@scores) { print $score, "\n"; }

Or even print for @scores; (after perl -l or $/ = "\n";; or just say for @scores; in Perl 5.10 or later after use feature 'say';).

It may not be worth mentioning, but the test $i <= $#scores should probably be considered an excessive use of the special variable $#foo. Because of its complexity (it's an lvalue, among other things), there can be performance implications in repeatedly accessing or setting it. In this case it's moot, since the reasonable way to access the array's elements is to iterate over each element or each index (the latter results in it being used only wants). But don't avoid a sensible construct out of hand without considering benchmarks and input from Monks past and present -- it's likely niggling points like this will have no significance in a larger program that hasn't been profiled.

The sigil to use is the type being returned.

$foo             # Scalar
$foo[$i]         # Array element, a scalar
$foo{$k}         # Hash element, a scalar

@foo             # Array contents, a list of scalar values
@foo[$i, $j]     # Array slice, a list of scalar values
@foo{$k1, $k2}   # Hash slice, a list of scalar values

%foo             # Hash contents, a list of key-value pairs
[download]

$foo[EXPR] and @foo[EXPR] differ in the context in which EXPR is evaluated, and they differ in the number of scalars they can return.

The sigil to use is the type being returned

Actually, it isn't. Here are some counter examples:

@foo             # Number of elements of the array.
@foo             # A reference to the array.
@foo[$i, $j]     # Last element of slice.
@foo{$k1, $k2}   # Last element of slice.

%foo             # A reference to the hash.
%foo             # True/false.
%foo             # String with ratio of filled buckets and buckets.
[download]

The sigil can influence what is returned, but foremost, it's the context that will determine what is returned. In particular, in scalar context, a scalar will always be returned.

The counter examples fall into two categories: scalar context, where nothing but a scalar can be returned, and where rules are used to make the variable an lvalue.

Let diagnostics explain:

$ echo 'Scalar value @scores[$i] better written as $scores[$i]' | spla
+in
Scalar value @scores[$i] better written as $scores[$i] (#1)
    (W syntax) You've used an array slice (indicated by @) to select a
    single element of an array.  Generally it's better to ask for a sc
+alar
    value (indicated by $).  The difference is that $foo[&bar] always
    behaves like a scalar, both when assigning to it and when evaluati
+ng its
    argument, while @foo[&bar] behaves like a list when you assign to 
+it,
    and provides a list context to its subscript, which can do weird t
+hings
    if you're expecting only one subscript.
    
    On the other hand, if you were actually hoping to treat the array
    element as a list, you need to look into how references work, beca
+use
    Perl will not magically convert between scalars and lists for you.
+  See
    perlref.
[download]

Perl 5 is stricter - it insists on Scalars being represented by the "$" sigil - in your case, printing ONE score item is a scalar, so perl (5) expects a "$".

Perl 5 is stricter - it insists on Scalars being represented by the "$" sigil - in your case, printing ONE score item is a scalar, so perl (5) expects a "$".

Partially right. In this case, a one element list is printed.

I find the warning highly annoying. It's a case where Perl knows what I mean, does what I mean, and still thinks it's Python, insisting in one true way of doing things. Despite it being the syntax of the future.

With foreach is faster foreach (@scores ){ print $_."\n"; }