Every single grep and map should be doing one and only one thing. You will want to chain them together, right-to-left, to make them do what you want.

@temp =
    map {
        "$_\n"
    } map {
        split
    } @file;
[download]

Read it from right to left.

1. I'm starting with @file
2. I take each element and apply split to it. (The default is to split $_ on whitespace.)
3. I take each element of the new list and add a newline to it.
4. Put this into @temp.

Remember - you're going to have more things in your group after the first map.

This isn't tricky, it just takes into account that the first map doing the split will create more elements and then the next map just appends newlines to everything it gets.

use strict;
use warnings;

my @tmp01 = ();
    
push @tmp01, map{ $_."\n"} split " " while <DATA>;

exit;

__DATA__
foo bar
   munch
bar
foo bar
[download]

The following variant of the above is how I would write it.

# SNIP #
my @temp = map { $_ . "\n" } map { split(/\s+/) } <DATA>
# SNIP #
[download]

It is functionally the same, I just find it easier to read, but then my views of readability don't always align with others.

Essentially, i'm trying to take the values in an array, split them on white space, append a newline, and then store it all in another array

I'd do it like this:

my @file = ("eddie van halen", "david lee roth", "alex van halen", "mi
+chael anthony");
my @stuff = map { "$_\n"; } map { split /\s+/, $_; } @file;
print @stuff;
[download]

edit: doh! dragon beat me to it (that's what I get for not reading responses first), but ah well at least I arrived at the exact same solution (I'm just overly explicit -- call it paranoia) so I guess it proves we are likely equally insane or something like that :)

If you want to remove things from that group, you use grep

Technically map takes either an expression or a block of code, not an anonymous sub.</pedant>

A little note on efficiency.

First create a file (win32):

    perl -wle"for ('00001'..'10000') { print join ' ', ($_) x 20; }" >
+ temp.tmp
[download]

Then get @temp in various ways and look at peak memory consumption.

  open my $fh, 'temp.tmp' or die $!;

  # Alternative 1: 40 984 K
  my @temp = map { "$_\n" } map { split ' ' } <$fh>;

  # Alternative 2: 29 076 K
  my @temp = map { split ' ' } <$fh>;
  $_ .= "\n" for @temp;

  # Alternative 3: 14 816 K
  local $_;
  my @temp;
  push @temp => map "$_\n", split ' ' while <$fh>;
[download]

Alternative 2 is less memory hungry (as well as faster) because Perl doesn't have to build up an extra list. Alternative 3 is even less memory hungry because it doesn't slurp the file before building up @temp. Of course, there could've been a fourth alternativ having alternativ 2's for loop, but I think the point is made already.

(I use ActivePerl v5.8.0 built for MSWin32-x86-multi-thread, build 806.)

Hope this helps,
ihb

We all have to have uses for our overly powerful pentium toaster units, don't we ? :)

No, seriously, thanks for the feedback, though I would hope the case 1 and case2 would have been equivalent, essentially map is going to create an array, and we are saying that assignment for an array is slower than a push, or are we instead saying that the blocks { } are the slowdown? Either way, it seems we can get more granularity from this test to learn more about the internals.

Anyhow, this all really matters when dealing with the size of input, usually memory is cheap and in surplus, so you just want speed ... yet not always...

As a last note, the bestest fastest is not always the best way, given that readability and maintainability is important. Hence you might have to add blocks later, or maybe blocks add clarity, and definitely the push appears hackish -- if not indicative of a bug somewhere. I wouldn't leave production code using that final push.

This feels very wrong to me.

When you have data in an array, generally there should be no "\n" in the data.

Once you are ready to output your data to the screen or to a file, then you might introduce newlines, either by using join, or by temporarily setting $" or by other similar means.

--
TTTATCGGTCGTTATATAGATGTTTGCA

I believe map in void-context was fixed a while back in Perl version-something-or-rather, some one else might remember when.

As for maps, don't forget the elegance of a simple for/foreach for aliasing .. often it is more readable if you don't need to capture an array but just need to mangle one.

$_++ for @array;
[download]

Is the same as:

@array = map { $_++ } @array;
[download]

And also this can be occasionally cool:

print for (
   "Henry the eighth I am I am\n",
   "Henry the eighth I am\n",
   "I got married to the window next door\n",
   "She's been married 7 times before\n"
);
[download]

So anyway, map is cool, it has many good places, but often a foreach (even if it is more code) can be just as cool, and often more readable. I'm currently in the process of simplifying a functionally-styled CLI interface to use more foreach and less map, because after going home and coming back in the morning (and not having my Mountain Dew yet), the foreach is easier to read.

But in your original example, yes, map seems to be the trick because the cardinality (err, size) of the list is changing and you don't want to mangle the original.