Here's my take...

By definition, keys in hashes are always unique. So, if you're after lists of unique things, a hash is what you want. Since you want a unique list inside a hash, you want a hash of hashes. Something like this may do:

use Data::Dumper;

my $first_level_key = 1;
my @second_level_keys = (2,3,4,5,6,2,7,8);
my %hash;

$hash{$first_level_key}{$_}++
  for @second_level_keys;

print Dumper \%hash;
[download]

You said you wanted to insert "in order". If order is important, you could sort the keys before processing them if they're numeric, as they were in your example. If you do want strictly ordered hashes, there are modules on CPAN that can do this (disclaimer, I haven't used any of them). Just google for them.

Hmm I see. What I have now is:

my %edges= ();

while (<STREAM>) {
my($node1, $node2) = split;
push( @{$edges{$node1}}, $node2);

}
Now, if the sequence is:
1,2
1,3
1,4
1,2
1,5

2 will be pushed again right? I want to avoid that.
Thanks!

Oh! You keep talking about avoiding duplicates in a hash, but your problem is actually with avoiding duplicates in an array.

A common idiom to weed out duplicates is: (from perlfaq4)

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

To insert at the same time, that would be

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

Plug it in and get:

my %edges;
while (<STREAM>) {
   my($node1, $node2) = split;
   my %seen;
   @{$edges{$node1}} = grep !$seen{$_}++, @{$edges{$node1}}, $node2;
}
[download]

A faster (but more memory hungry) version would be:

my %edges;
my %seen;
while (<STREAM>) {
   my($node1, $node2) = split;
   next if !$seen{$node1}{$node2}++;
   push @{$edges{$node1}}, $node2;
}
[download]

Something like this may do what you want:

use warnings;
use strict;

use Data::Dumper;


my %edges;  # created empty

while (<DATA>) {

    my ($node1, $node2) = split;

    # nothing to do if node1 already has a node2 in its array.
    next if exists $edges{$node1}{present}{$node2};

    # node2 not already there: push it, mark it present.
    push @{ $edges{$node1}{array} }, $node2;
    $edges{$node1}{present}{$node2} = 1;

    }

# transform hash to final structure.
for my $node (keys %edges) {  # for each node1 of hash...
    # presence flags no longer needed: eliminate them.
    delete $edges{$node}{present};
    # associate each node1 directly with its node2 array ref.
    $edges{$node} = delete $edges{$node}{array};
    }

# see what we got.
print Dumper \%edges;

__DATA__
1 2
1 3
1 4
1 2
1 5
2 1
1 2
2 2
1 6
2 3
1 2
2 2
[download]

Output:

>perl uniq_hash_value_1.pl
$VAR1 = {
          '1' => [
                   '2',
                   '3',
                   '4',
                   '5',
                   '6'
                 ],
          '2' => [
                   '1',
                   '2',
                   '3'
                 ]
        };
[download]

[ Ignore this post and see Re^5: Tie::Hash::MultiValue Unique question instead ]

$hash{$_} = 1 for 2,3,4,5,6,2,7,8;
[download]

and

$hash{$_} = 1 for 2,3,4,5,6,7,8;
[download]

produce the same result, so your request doesn't make much sense.