my @mergedkeys = keys %{{map {$_ => 1} @array1, @array2}};

However: assuming this code will have to be maintained, consider that what is slick today maybe wholly obscure next month. Rather than using this, I'd recommend using List::MoreUtils' uniq to accomplish this. Its intent will be much more obvious on casual inspection. As well, it will respect order, if that matters to your application.

On the topic of "eliminat[ing] the temporary hash", you can use scoping the get Perl to to the work for you. Just declare your temporary hash with my in a code block and it will go out of scope and be garbage collected once you exit the block. Something like:

TEMP_HASH_BLOCK: {
    my %temphash;
    @temphash{@array1} = ();
    delete @temphash{@array1};
    my @newarray = keys %temphash;
}
[download]

or use do (or a subroutine) if you need to export:

 my @newarray = do {
    my %temphash;
    @temphash{@array1} = ();
    delete @temphash{@array1};
    keys %temphash;
};
[download]

puterboy:

I don't know of a way to do so, but List::MoreUtils has a handy function uniq to handle the first case:

#!/usr/bin/perl
use strict;
use warnings;
use List::MoreUtils qw(uniq);
my @a = qw(alpha beta gamma);
my @b = qw(delta kappa gamma);
my @c = uniq(@a, @b);
print join(", ", @c), "\n";
[download]

You'll also find some interesting items in List::Util, Hash::Util and Scalar::Util.

But if you find the temporary a distraction and don't want to include a module for just that purpose, just hide it in a subroutine and go ahead and use the temporary in your subroutine. After all, a temporary isn't necessarily inefficient. So by writing a subroutine with a good name, you can make the code cleaner and self-documenting at the same time, as in the above example. I find that some code can be difficult to read when there's "too much action" happening in a statement, and you may find it difficult to maintain if the statement is too hard to create. So just relax, write a subroutine to do your dirty work, and use it--or include an appropriate module, where someone has already done the dirty work for you!

...roboticus

When your only tool is a hammer, all problems look like your thumb.

I use the following (from perlfaq4):

my %seen;
my @mergedkeys = grep !$seen{$_}++, @array1, @array2;
[download]

It's a bit of a doozie to understand, but it's just one of those patterns you keep seeing and you memorise.

Bonus: it preserves order.

As a thought for question #2, here is some Perl 5.10 code using the smart match operator (~~).

#!/usr/bin/perl -w
use strict;
use 5.10.0;

my @a = qw(alpha beta gamma zulu);
my @b = qw(delta alpha kappa gamma beta);

my @c = grep{!($_ ~~ @a)}@b;
print "@c";    #prints: delta kappa

# @c is @b after removing any element
# that was contained in @a
[download]

I would love to eliminate the temporary hash by using anonymous hashes.

We often get such questions, yet Perl provides a mechanism to hide away complex code: subs! Move your code info a sub, and you won't have temporaries lying around. (As mentioned, this has already been done for you as List::Util's uniq.)

my @mergedkeys = do {my %t; grep !$t{$_}++, @array1, @array2};
[download]

I think I first saw it used by John Orwant (perhaps in Mastering Algorithms with Perl), and later in the Perl Cookbook. I think it's also in the perlfaq. I must have used it a thousand programs.