map BLOCK LIST
    map EXPR,LIST
            Evaluates the BLOCK or EXPR for each element of LIST (locally
            setting "$_" to each element) and returns the list value
            composed of the results of each such evaluation. In scalar
            context, returns the total number of elements so generated.
            Evaluates BLOCK or EXPR in list context, so each element of LIST
            may produce zero, one, or more elements in the returned value.

                @chars = map(chr, @nums);

            translates a list of numbers to the corresponding characters.
            And

                %hash = map { getkey($_) => $_ } @array;

            is just a funny way to write

                %hash = ();
                foreach $_ (@array) {
                    $hash{getkey($_)} = $_;
                }

            Note that "$_" is an alias to the list value, so it can be used
            to modify the elements of the LIST. While this is useful and
            supported, it can cause bizarre results if the elements of LIST
            are not variables. Using a regular "foreach" loop for this
            purpose would be clearer in most cases. See also the grep entry
            elsewhere in this document for an array composed of those items
            of the original list for which the BLOCK or EXPR evaluates to
            true.

            "{" starts both hash references and blocks, so "map { ..." could
            be either the start of map BLOCK LIST or map EXPR, LIST. Because
            perl doesn't look ahead for the closing "}" it has to take a
            guess at which its dealing with based what it finds just after
            the "{". Usually it gets it right, but if it doesn't it won't
            realize something is wrong until it gets to the "}" and
            encounters the missing (or unexpected) comma. The syntax error
            will be reported close to the "}" but you'll need to change
            something near the "{" such as using a unary "+" to give perl
            some help:

                %hash = map {  "\L$_", 1  } @array  # perl guesses EXPR.  wrong
                %hash = map { +"\L$_", 1  } @array  # perl guesses BLOCK. right
                %hash = map { ("\L$_", 1) } @array  # this also works
                %hash = map {  lc($_), 1  } @array  # as does this.
                %hash = map +( lc($_), 1 ), @array  # this is EXPR and works!

                %hash = map  ( lc($_), 1 ), @array  # evaluates to (1, @array)

            or to force an anon hash constructor use "+{"

               @hashes = map +{ lc($_), 1 }, @array # EXPR, so needs , at end

            and you get list of anonymous hashes each with only 1 entry.