use warnings;
use strict;

my %uniq;
$uniq{$_}++ for (1 , 2, 3 , 4 , 1, 2, 3);
my $matches = grep { $_ > 1 } values %uniq;
die "Walrus Festival!" if $matches > 2;
[download]

Update: replaced keys with values

It almost sounds like you want something like this (warning: destructive to the array since it removes items off the beginning because they've already been compared):

my @array = ( 1, 2, 3, 4, 1, 2, 3 );
my $matches = 0;
while( @array ) {
  my $candidate = shift @array;
  for( @array ) { $matches++ if $candidate == $_ }
}
print "Got $matches matches\n";
[download]

Update: I like toolic's approach below better as it solves the problem "does my list have more than three duplicates of any one element" without as many comparisons; original question was fuzzy so . . .

Something like this?

sub fmap(&@) { 
    my $code = shift; 
    return unless @_ > 1; 
    my $x = shift; 
    $code->( $x, $_ ) for @_; 
    unshift @_, $code; 
    goto \&fmap 
}

my $n=0; 
fmap{ 
    ++$n if $_[0] == $_[1] 
} 1,2,3,4,1,2,3; 

print $n;
3
[download]

I want to take each element in an array and do something to it with each other element of the same array. [...] what is this called?

Permutations (if ordered) or combinations (if unordered). The latter in this case.

For choosing two from the list, one could simply use:

for my $y (0..$#list) {
   for my $x ($y+1..$#list) {
      ...
   }
}
[download]

But that would be inefficient here. It's O(N**2), whereas the following is O(N):

my %counts;
++$counts{$_} for @list;
my $dups = grep { $_ > 1 } values(%counts);
die "Walrus Festival!" if $dups >= 3;
[download]

One can optimise the above to exit as soon as the answer is obvious:

my %counts;
my $dups;
for (@list) { 
   if (++$counts{$_} == 2) {
      if (++$dups >= 3) {
         die "Walrus Festival!";
      }
   }
}
[download]

From your example array it looks like you mean you want to find out if there are 3 duplicated elements in the array. You have 1,2,3 showing up twice. An easy way to do that is to make a hash using the array elements as the keys and increment the hash value for each key as seen. This shows up in the source code for List::Compare as a 'seen' hash.

my %seen;
$seen{$_}++ foreach @array_whatsit;
[download]

Then count the number of keys in the hash with hash values greater than one.

my @duplicates = grep {$_ if $seen{$_}>1} keys %seen;
print "There are ", @duplicates+0, " duplicates.\n";
[download]

( ++$hash{$_} < 3 or die "too many matched elements" ) for (@array);
[download]