Your usage of map is fine - but it isn't for chomp.

    %hash = map { chomp; my ( $a, $b) = split / = /; $a => $b } <INF>;
[download]

should do. update: note that $_ is implicit for chomp and split.

I don't think you need $a and $b, split should do the job by itself:

my %hash = map {chomp; split / = /} <INT>;
[download]

all the best, andye

I shouldn't use ($a, $b) since these are special and for something else - but I adhered to the OP's code in order to not change too much... ;-)

You could forget the chomp and split and do it with a regexp.

use Data::Dumper;

my %h = map { /^([^=]+?)\s*=\s*(\S.*)/ } <DATA>;
print Dumper \%h;

__DATA__
a = fred
b = 1
ignorethis
c = ===
[download]

Output:

$VAR1 = { 
          'c' => '===',
          'a' => 'fred',
          'b' => '1'
        };
[download]

This works because the regexp evaluates to a list of the contents of the two captures. What's nice about this is that it elegantly handles values that have an equal sign in them. It also just plain skips over any line that doesn't fit the format.

Am I correct in thinking that this operates on DATA in slurp mode (i.e. reading all the lines in at once)? Or does this work like while (<X>) magic?

for(split(" ","tsuJ rehtonA lreP rekcaH")){print reverse . " "}print "\b.\n";

Yes, it will read the entire input before doing any work. That's true of the OP too, and the other map-based solutions I see posted.

I believe you are having a problem with chomp(). That being said, read up on chomp and modify your codez.

my %hash = map { chomp(my ($a, $b) = split(/ = /, $_)); $a => $b } @ar
+ray;
[download]

(Hint, lookup what chomp returns.)

Update: shmen beat me to it :(. I like the way he chomped, too -- better looking than those parens (in this scenario, anyway).

Update: Reworded my previous update.

my %h = do {
    local( @ARGV, $/ ) = ($file);
    <> =~ /^(.*?) = (.*)/gm
};
[download]

The "$" is useless.

In the spirit of the OP, here's a (shorter!) variation that uses map:

my %h = do {
    local @ARGV = $file;
    map /^(.*?) = (.*)/, <>
};
[download]

One should probably localize $^I when localizing @ARGV.

I hardly ever use map, I'm forcing myself to use it when dealing with whole arrays

Instead of forcing yourself to use map, you may be better off to not use it at all.

Forcing yourself to use a feature you normally avoid is a good way to learn about it, and that can't be bad. If nothing else... it'll help prepare you for when you need to maintain someone else's code.

Between the mind which plans and the hands which build, there must be a mediator... and this mediator must be the heart.