Running that code with the second line alone works fine for me (Perl 5.6.1).

I suspect that your problem is that the use of shift in the map *destructively* processes the @foo array -- shift pulls the first element of the array out of @foo, so when you go to do the shift trick again, you're processing an empty array. You can see this if you add the following code after the first 'interleave':

my $foo_size = @foo;

print "\nThere are now $foo_size elements in \@foo\n";
[download]

In this case, warnings told you about something very important!

perl -e 'print "How sweet does a rose smell? "; chomp ($n = <STDIN>); 
+$rose = "smells sweet to degree $n"; *other_name = *rose; print "$oth
+er_name\n"'
[download]

Secondly, running your sample produces no warnings for me. It probably shouldn't. However if @foo and @bar don't have the same number of elements (specifically, if @foo is short) then you'll get enough undef values in the array to make up the difference.

Thirdly, did you really mean to print and do the assignment at the same time? Yeah, you'll get the return value from the assignment printed, but is that really what you wanted? (Tends to be ugly, that's all).

1) I will move the my declaration.
2) Yes @foo is shorter. My code should have read...

#!/usr/bin/perl
use warnings;
use strict;
my @foo = ( 1 , 3 , 5 , 7 );
my @bar = (0, 2 , 4 , 6 , 8 );
print STDOUT my @foobar = map { $_, shift @foo } @bar;
[download]

I'm assuming that this is my problem, no? I do get the proper result "012345678"...just with a warning.
3) I guess I have a talent for ugly... and warnings :-(

As for #2...no you don't get the proper results. What you're actually getting is: 012345678undef but of course undef doesn't print. :)

Watch this. It's your code with two small modifications:

use warnings;
use strict;
my @foo = ( 1 , 3 , 5 , 7 );
my @bar = (0, 2 , 4 , 6 , 8 );
my @foobar= map { $_, shift @foo } @bar;
print STDOUT join(',', @foobar);
[download]

When you run this, notice that the list is going to have a trailing ",". That's because join() knows there's an element after the 8 (undef!) and makes a slot for it. And notice the error changed, its now an uninit value in join.

#!/usr/bin/perl -w
use strict;
my @foo = ( 1 , 3 , 5 , 7 );
my @bar = ( 2 , 4 , 6 , 8 );
print STDOUT my @foobar = map { $_, shift @foo } @bar;
[download]

what if you try this:


#!/usr/bin/perl
use warnings;
use strict;
my @foo = ( 1 , 3 , 5 , 7 );
my @bar = ( 2 , 4 , 6 , 8 );
print STDOUT my @foobar = map { $_, shift @foo } @bar;
[download]

Um, that's exactly what I had (that is, "perl -w" is the same as "use warnings"). But as I and others have said, it's not usually a great idiom, as it's destructive to @foo. And you'll still have undefined values if @foo is shorter than @bar.

You should probably avoid destroying @foo during the merge: my @foobar= map { ($bar[$_],$foo[$_]) } 0..$#bar; or

use mapcar;
my @foobar= mapcar { @_ } \@bar, \@foo;
[download]

The only way I could produce the error was if @foo was a shorter array than @bar.

@foo = ( 1 , 3 , 5 , 7 );
@bar = ( 2 , 4 , 6 , 8 , 9);
print STDOUT my @foobar = map { ( $_, shift @foo ) } @bar;
[download]

Unfortunately, I don't know what you want to do if they are not the same size. So I'll guess:

@foo = ( 2 , 4 , 6 , 8 );
@bar = ( 1 , 3 , 5 , 7, 9);
$len = @foo;
print STDOUT my @foobar = (
        (map { ( $_, shift @foo ) } @bar[0 .. $len - 1]),
        @bar[$len .. $#bar]  );
[download]