There is no duplicate key at compile-time — the list is only created and assigned to the hash at run-time — so the answer to your literal question is "no".

However, it is possible to write an opcode checker that detects the posted code pattern at compile-time. (For example, module autovivification uses an opcode checker to not only examine opcodes, but to replace them.) This approach would probably be better to add a *run-time* warning.

A better approach to detecting the situation at compile-time would be to write a Perl::Critic rule to look for the code pattern you posted.

Hi Ikegami, Thanks for your quick response.

I've tried using Perl::Critic (http://perlcritic.com/), but it is not throwing up any warning with respect to the re-occurrence of the hash key. Correct me if I'm doing something wrong in using Perl::Critic

I didn't say a rule already existed to check this. Quite the opposite, I assumed there wasn't one and told you you'd have to actually write the rule.

The problem is that your %hash is valid as Perl will just store the last value for key "one". Perhaps this would work with Hash::MultiValue? I am thinking of something like this:

use strict;
use warnings;
use Hash::MultiValue;
use 5.012;

my $mhash = Hash::MultiValue->new(
        "one" => "3",
        "two" => "2",
        "two" => "1"
);

die "Duplicate key detected for \%hash" if grep { my @a = $mhash->get_
+all($_); @a > 1 } $mhash->keys;

print "We're good!";
[download]

I have not used it in anger myself but it would seem as though it would work for what you want!

What about tie?

#!/usr/bin/perl

{
    package AssignOnce;

    use strict;
    use warnings;

    use Carp ();
    use Tie::Hash;
    use parent -norequire => 'Tie::StdHash'; # why, oh why, is Tie::St
+dHash hidden in Tie::Hash?

    sub STORE
    {
        my ($self,$key,$value)=@_;
        if (exists $self->{$key}) {
            Carp::carp("Overwriting hash key '$key', old value: '$self
+->{$key}', new value: '$value'");
        }
        $self->SUPER::STORE($key,$value);
    }
}

use strict;
use warnings;
use Data::Dumper;

our %h;
tie %h,'AssignOnce';
%h=(
    one => 1,
    two => 2,
    one => 3,
);

print Dumper(\%h);
[download]

Result:

Overwriting hash key 'one', old value: '1', new value: '3' at tie.pl l
+ine 29
$VAR1 = {
          'one' => 3,
          'two' => 2
        };
[download]

Alexander

sub no_dup_keys {
    die "Odd number of elements" if @_ % 2;

    my %h;
    while ( my ( $key, $new_val ) = splice @_, 0, 2 ) {
        if ( exists $h{$key} ) {
            warn "Duplicate key: $key, old_value: $h{$key},"
               . " new_value: $new_val\n ";
            next; # Remove for rolling overlay.
        }
        $h{$key} = $new_val;
    }

    return %h;
}

my %hash;
BEGIN{
    %hash = no_dup_keys(
        "one" => "1",
        "two" => "2",
        "one" => "3",
    );
}
[download]

Hi TJPride,

Thanks for your response

It is a manually generated .pm file by the people who are not very much familiar with perl syntax. Hence I suspect that there might be a good chance of mistyping an existing key.

In this case we are not looking for eliminating the duplicated hash keys, rather we are looking for updating .pm file properly with a new key for the duplicated one's.

So we need to know if some key is duplicated

As I know writing a small validating perl script will do this , but I was thinking if there is any approach available in perl by default or addon.

It is a manually generated .pm file by the people who are not very much familiar with perl syntax. Hence I suspect that there might be a good chance of mistyping an existing key.

You could get those people into assigning not to %hash, but to @hash, i.e. an array instead. Later in the program, you check @hash whether a "key" occurs twice, before assigning to %hash.
-- 
Ronald Fischer <ynnor@mm.st>

To implement rovf's suggestion:

use Data::Dumper;
use strict;
use warnings;

my %hash;

assignWithDupes([
    "one" => "1",
    "two" => "2",
    "one" => "3",
    "three" => "4",
    "two" => "5",
    "one" => "6",
],
\%hash);

print Dumper(\%hash);

sub assignWithDupes {
    my ($arr, $hash) = @_;
    my ($i, $j, $key, $val);
    
    for ($i = 0; $i < $#$arr; $i += 2) {
        $key = $arr->[$i];
        $val = $arr->[$i+1];
        
        if (!defined $hash->{$key}) {
            $hash->{$key} = $val;
            next;
        }

        for ($j = 2; defined $hash->{"${key}_$j"}; $j++) {}
        $hash->{"${key}_$j"} = $val;
    }
}
[download]

Output (modified to put it in order):

$VAR1 = {
          'one' => '1',
          'one_2' => '3',
          'one_3' => '6'
          'two' => '2',
          'two_2' => '5',
          'three' => '4',
        };
[download]

As you can see, successive instances of the same key are assigned to _2, _3, etc.

If you want checking like that, then the way to do it is to read the data like it came from an external file, build the hash and report errors as the data is processed.

There are many formulations of how to do this. I present one below.

#!/usr/bin/perl -w
use strict;
use Data::Dumper;

my $hash_data = <<END; #this is a "here is" string
one 1
two 2
one 3
END

my %seen;
my %hash = 
    map{ 
          my ($text, $number) = split;
          warn "\"$text\" has been re-defined!\n" if $seen{$text}++;
          ($text,$number);
       }split (/\n/, $hash_data);

print Dumper \%hash;

__END__
Prints:
"one" has been re-defined!
$VAR1 = {
          'one' => '3',
          'two' => '2'
        };
[download]

Hi Marshall,

Thanks for your response.

You are right in saying that the re-definition of a key with a new value is perfectly fine.

But this leads to a anomaly called RD (Re-Definition). The RD means re-defining a variable with a new value without using it's initial value (They say to use your later value as initial one than initializing the variable to something else and changing the variable's value without using it's initial value). The coding guide lines say to identify such cases and rectify the same.

This is one of the reason why I'm thinking of getting a warning or error from standard perl or any of it's additional packages (like use strict,warnings)

use strict;
use warnings;

my %hash = ("one" => "1",
          "two" => "2",
          "one" => "3",
        );

foreach my $key ( keys %hash ) {
    print $key, " => ", $hash{$key}, "\n";
}
[download]

one => 3
two => 2
[download]

%hash = EXPR;
[download]

does something like

my @anon = LIST;
%hash = ();
while (@anon) {
   my $k = shift(@anon);
   my $v = shift(@anon);
   $hash{$k} = $v;
}
[download]

So if you have two values for the same key, the latter prevails.

(There's no actual @anon created; the stack is used.)