my %seen = map {$_ => undef} @proc_name1;
my @uniq = keys %seen;
[download]

That is usually written like this:

my %seen;
my @uniq = grep !$seen{$_}++, @proc_name1;
[download]

And if you want to localize the scope of the hash you could do it like this:

my @uniq = do {
    my %seen;
    grep !$seen{$_}++, @proc_name1;
    };
[download]

my %seen;
my @uniq = grep { ! $seen{$_} ++ } @arr;
[download]

but using a hash slice seems to be a bit faster. I should warn that I have a chequered history with benchmarks so take this with a pinch of salt.

use strict;
use warnings;

use Benchmark q{cmpthese};

my @arr = ( q{a} .. q{z} ) x 1000;

cmpthese(
   -10,
   {
       useGrep  => sub
          {
              my %seen;
              return grep { ! $seen{$_} ++ } @arr;
          },
       useSlice => sub
          {
              my %seen;
              @seen{@arr} = ();
              return keys %seen;
          },
   });
[download]

The output.

           Rate  useGrep useSlice
useGrep  13.0/s       --     -63%
useSlice 35.2/s     172%       --
[download]

If you need to preserve the order of the array then you should use the grep method.

I hope this is of interest.

Cheers,

JohnGG

Here's an even shorter way, if you don't want to use a variable at all:

my @uniq = keys %{{ map { $_ => undef } @proc_name1 }};
[download]

However, this is slower than the slice and grep methods, both.

           Rate   useRef  useGrep useSlice
useRef   74.3/s       --     -64%     -84%
useGrep   204/s     175%       --     -56%
useSlice  464/s     525%     127%       --
[download]

(Thanks to johngg for the tests in Re: to select unique characters).