view release on metacpan or  search on metacpan

README  view on Meta::CPAN

NAME

    Array::Unique - Tie-able array that allows only unique values

SYNOPSIS

     use Array::Unique;
     tie @a, 'Array::Unique';
    
     Now use @a as a regular array.

DESCRIPTION

    This package lets you create an array which will allow only one
    occurrence of any value.

    In other words no matter how many times you put in 42 it will keep only
    the first occurrence and the rest will be dropped.

    You use the module via tie and once you tied your array to this module
    it will behave correctly.

    Uniqueness is checked with the 'eq' operator so among other things it
    is case sensitive.

    As a side effect the module does not allow undef as a value in the
    array.

EXAMPLES

     use Array::Unique;
     tie @a, 'Array::Unique';
    
     @a = qw(a b c a d e f);
     push @a, qw(x b z);
     print "@a\n";          # a b c d e f x z

DISCUSSION

    When you are collecting a list of items and you want to make sure there
    is only one occurrence of each item, you have several option:

    1) using an array and extracting the unique elements later

      You might use a regular array to hold this unique set of values and
      either remove duplicates on each update by that keeping the array
      always unique or remove duplicates just before you want to use the
      uniqueness feature of the array. In either case you might run a
      function you call @a = unique_value(@a);

      The problem with this approach is that you have to implement the
      unique_value function (see later) AND you have to make sure you don't
      forget to call it. I would say don't rely on remembering this.

      There is good discussion about it in the 1st edition of the Perl
      Cookbook of O'Reilly. I have copied the solutions here, you can see
      further discussion in the book.

      Extracting Unique Elements from a List (Section 4.6 in the Perl
      Cookbook 1st ed.)

      # Straightforward

       %seen = ();
       @uniq = ();
       foreach $item (@list) [
           unless ($seen{$item}) {
             # if we get here we have not seen it before
             $seen{$item} = 1;
             push (@uniq, $item);
          }
       } 

      # Faster

       %seen = ();
       foreach $item (@list) {
         push(@uniq, $item) unless $seen{$item}++;
       }

      # Faster but different

       %seen;
       foreach $item (@list) {
         $seen{$item}++;
       }
       @uniq = keys %seen;
      
       # Faster and even more different
       %seen;
       @uniq = grep {! $seen{$_}++} @list;

    2) using a hash

      Some people use the keys of a hash to keep the items and put an
      arbitrary value as the values of the hash:

      To build such a list:

       %unique = map { $_ => 1 } qw( one two one two three four! );

      To print it:

       print join ", ", sort keys %unique;

      To add values to it:

       $unique{$_}=1 foreach qw( one after the nine oh nine );

      To remove values:

       delete @unique{ qw(oh nine) };

      To check if a value is there:

       $unique{ $value };        # which is why I like to use "1" as my value

      (thanks to Gaal Yahas for the above examples)

      There are three drawbacks I see: