If they're merely strings, you can do this easily by using a lookup hash. (If not, you should still use a hash, you just need to mangle things to get unambiguous keys.)

my %in_b;
undef @in_b{ @b };

my @c = grep !exists $in_b{ $_ }, @a;
[download]

Note that in this form it may conflate values from @b you wanted to treat as separate (empty string vs undef f.ex).

Here's the hash way,

# given @a, @b
my @c = do {
    my %a;
    @a{@a} = ();   # slice of %a, values undef
    delete @a{@b}; # delete the @b slice
    keys %a;
};
[download]

In those cases I would write code much like yours or Aristotle's or revdiablo's.

I ended up doing something like this:

# given @a, @b
my %a;
@a{@a} = ();
delete @a{@b};
my @c = keys %a;
[download]

This code works just as well as my previous code with the exception that the new code is much faster. Thanks!

-Scott

I assume the code does what you need, but there are a few caveats that should be mentioned. This code will change the order of the values, and it will eliminate any duplicates. This may or may not be a problem, depending on what it's being used for.

Update: these caveats were noted, in Zaxo's original node, I just failed to notice. My apologies.

Any time you want to know if one value is in a set of others, you probably want a hash. Convert @b to a hash (with the values as keys), then loop on @a, checking if the values exist in %b. Here's an example:

    my @a = qw(one two three four);
    my @b = qw(two four);
    my %b;
    @b{ @b } = (1)x@b; # one of many ways to create the hash

    for (@a) {
      unless ($b{$_}) { print "$_ is not in \@b\n" }
    }
[download]

Hashes are fine in many cases. Algorithm::HowSimilar is an alternative approach.

use Algorithm::HowSimilar 'compare';
my ( $av_similarity,
     $sim_ary1_to_ary2,
     $sim_ary2_to_ary1,
     $ref_ary_matches,
     $ref_ary_in_ary1_but_not_ary2,
     $ref_ary_in_ary2_but_not_ary1
   ) = compare( [ 1,2,3,4 ], [ 3,4,5,6,7 ] );
[download]

See also perldoc -q difference.

use Set::Array;
...
my $set_a = Set::Array->new(@a);
my $set_b = Set::Array->new(@b);
my @c = $set_a->difference(@set_b);
[download]

    ## use hash search to find everyone in @a but not in @b.
    my %temphash = map { $_ => 1 } @b;
    my @c = grep { !$temphash{ $_ } } @a;
[download]

ther's a better way to use grep...

my @difference =  grep /^@a1/, @a2;

#example of sub...

my $difference = diff(\@a1,\@a2);

sub diff {
    my @diff =  grep /[^@{$_[0]}]/, @{$_1};
    return \@diff;
}

Marco (nemux)
Bye.

sorry ... is impossible to see in my previous message the -> [] 

then with square brackets visible is :

sub diff_2 {
    my @diff =  grep /[[^@{$_[0]]}]/, @{$_[1]};
    return \@diff;
}

Marco