map {print} @arr;
[download]

For that matter,

grep { print } @array;
[download]

Or even...

use List::MoreUtils qw<first>;
first { not print } @array;
[download]

I can imagine many newbies scratching their heads if they saw that one! But I told it to "not print" the array! ;-)

Update: of course, there's the venerable...

print shift @array while @array;
[download]

... which prints, but also dismantles an array.

my @r;@r = reverse @array and do { print pop @r while @r };
# Now I'm just being silly!
[download]

perl -E'sub Monkey::do{say$_,for@_,do{($monkey=[caller(0)]->[3])=~s{::}{ }and$monkey}}"Monkey say"->Monkey::do'

print shift @array while @array;
[download]

... which prints, but also dismantles an array.

Using that idiom inside an anonymous subroutine is non-destructive!

knoppix@Microknoppix:~$ perl -E '
> @arr = qw{ 11 22 33 44 };
> sub { say shift while @_ }->( @arr );
> say qq{@arr};'
11
22
33
44
11 22 33 44
knoppix@Microknoppix:~$
[download]

Cheers,

JohnGG

As long as you're permuting over the for and foreach synonyms, why not include
    foreach (my $x = 11;  $x < 33;  $x += 11) { print $x }

And for that matter, how about array references:
    my @array = (11, 22, 33, 44);
    my $array_ref = \@array;
    print for @array;
    print for @$array_ref;
etcetera.

Anonymous subroutine perhaps?

knoppix@Microknoppix:~$ perl -E '
> @arr = qw{ 11 22 33 44 };
> sub { say shift while @_ }->( @arr );'
11
22
33
44
knoppix@Microknoppix:~$
[download]

or

sub { print @_ }->($_) for @arr;
[download]

That also works but you are incurring the expense of creating and invoking the subroutine for each and every element of the array rather than just once. This might have an impact on performance.

Cheers,

JohnGG

I think this benchmark code confirms my point regarding the expense of continually creating and invoking anonymous subroutines.

use strict;
use warnings;

use Benchmark qw{ cmpthese };

my @arr = ( 1 .. 1e6 );

my $rcOneElement  = sub
   {
       my $aref = shift;
       sub { my $var = shift }->( $_ ) for @$aref;
   };

my $rcAllElements = sub
   {
       my $aref = shift;
       sub { my $var = shift while @_ }->( @$aref );
   };

cmpthese (
   -5,
   {
       OneElement  => sub { $rcOneElement->( \ @arr ) },
       AllElements => sub { $rcAllElements->( \ @arr ) },
   }
   );
[download]

The output.

              Rate  OneElement AllElements
OneElement  2.59/s          --        -58%
AllElements 6.16/s        138%          --
[download]

However, I am good at cocking up benchmarks so I could be deluding myself :-/

Cheers,

JohnGG

$p=japh;push@a,w();$s=j4;sub n{"8fbac6c6e252"};unshift@a,
"b4d6c7ea52a7";$k=crypt($s,$p);$o="aeafa7cfdbd58c";@h=
map{sprintf"%x",ord$_}split//,$k;push@a,$o;$a[3]=pop@a;
$a[2]=n();sub w{"bcb3d8dec8dd"}$x.=$_ for@a;@b=($x=~m/..?/g); 
push@z,@h until @z>@b;for(@b){push@japh,hex($_)-hex($z
[$n]);$n++;}say map{chr$_}@japh;
[download]

;)

my @arr = (11, 22, 33, 44);
open my $FH, '<', \("@arr");
print while <$FH>;
[download]

In more recent versions of Perl, you can use each():

my @arr = qw(a b c);
while ( my ( $i, $e ) = each @arr ){
    say "iter $i = $e";
}
[download]

{ local $" = " "; print "@arr'; }
print "@{[@arr]}";
print "@{[map{"$_"}@arr]}";
print $arr[-$_-1] for reverse 0..$#arr;
[download]

my @array = qw(foo bar baz);
system echo => $_ for @array;
[download]

And if you think the above is insane...

@array = qw(foo bar baz);

use File::Temp;
foreach my $string (@array)
{
    my $tmpfile = File::Temp->new;
    printf $tmpfile <<'HERE' => quotemeta($string);
{
    package Local::App::PrintString;
    use 5.010;
    sub run {
        say "%s";
    }
}
Local::App::PrintString->run(@ARGV)
    unless scalar caller;
HERE

    system $^X, $tmpfile->filename;
}
[download]