The 1st pass through map allows "user" and "smtp". ("fetch" would be skipped.)
The 2nd pass through map allows "user" and "smtp". ("forward" would be skipped.)
The 3rd pass through map allows "smtp". ("user" is skipped.)
The 4th pass through map allows "user". ("smtp" is skipped.)

One solution (Set arithmetic using a hash):

sub create_list {
   my %dbs = map { $_ => 1 } qw/fetch forward user smtp/;
   delete @dbs{@_};
   return keys %dbs;
}
[download]

Another solution (Set arithmetic using a superposition):

use Quantum::Superpositions;

sub create_list {
   my $dbs  = any qw/fetch forward user smtp/;
   my $skip = all @_;
   return eigenstates( $dbs ne $skip );
}
[download]

Another solution (Set arithmetic using sets [seemed appropriate at the time]):

use Set::Scalar qw( );

sub create_list {
   my $dbs  = Set::Scalar->new( qw/fetch forward user smtp/ );
   my $skip = Set::Scalar->new( @_ );
   return ($dbs - $skip)->members();
}
[download]

Update: Added second and third snippet.

Thank you for your explanation.

My Perl book says, that delete deletes a key value pair. But it doesn't tell me why I have to use @dbs{@_} instead of $dbs{@_} (which apparently does nothing) or %dbs{@_} (which throws a failure) to get the thing working. Can you explain? :)

$ means you're working with one element.
@ means you're working with multiple elements.

@hash{@list}
is a hash slice. It amounts to
map { $hash{$_} } @list
but can be used as an lvalue.

$hash{@list}
is the same as
$hash{join($;, @list}}
It's a means of doing Hash of Hashes without actually using Hash of Hashes. It's generally unused.

You should really be thinking "hash" when you want to check if an item is in a set:

sub create_list {
   my @skip_dbs = @_;

   # declare the hash
   my %skippables;

   # populate the hash with the skippables
   $skippables{$_}++ for @skip_dbs;

   my @dbs = qw/fetch forward user smtp/;

   # return a list of each element of @dbs
   # that isn't in the skippables hash
   return grep { ! $skippables{$_} } @dbs;
}

my @list = create_list("user", "smtp");
print "@list";
[download]

Thanks all for your answers and especially the explanation of ikegami.

But what does the ++ after $skippables{$_} do?

# populate the hash with the skippables
$skippables{$_}++ for @skip_dbs;
[download]

It's the increment operator.

When dealing with numbers (or undef),
$a++
means
$a = $a + 1
except it won't issue a warning if $a is undefined.

sub create_list
{
    my @skip_dbs = @_;

    # declare the hash
    my %skippables;

    # populate the hash with the skippables
    foreach my $skip_db (@skip_dbs)
    {
        $skippables{$skip_db} = 1;
    }

    my @dbs = qw/fetch forward user smtp/;

    # create a list of each element of @dbs
    # that isn't in the skippables hash
    my @good_dbs;

    foreach my $db (@dbs)
    {
        unless (exists $skippables{$db})
        {
            push @good_dbs, $db
        }
    }
    return @good_dbs;
}

my @list = create_list("user", "smtp");
print "@list";
[download]

#!/usr/bin/perl -wl

use strict;

sub create_list {
   my @skip_dbs = @_;

   my %hash;
   @hash{qw/fetch forward user smtp/} = undef;
   delete @hash{@skip_dbs};
   
   return keys %hash
}

my @list = create_list("user", "smtp");
print "@list";
[download]

If the skiplist is small enough, I'd chose something like $skip_rule = join("|", @skip_dbs); $skip_rule = qr{^(?:$skip_rule)$}; and then return grep {$_ !~ $skip_rule} @dbs. If the skip list is huge, that might not be such a good idea.

qr{...} is quotish so you could do $" = q{|}; $skip_rule = qr{^(?:@skip_dbs)$};, probably localising the change of $" inside a small code block.

Cheers,

JohnGG

sub subtract {
   my ($whole_ref, $banned_ref) = @_;
   my %is_banned = map { $_ => 1 } @$banned_ref;
   return grep { ! $is_banned{$_} } @$whole_ref;
}

my @surviving = subtract([qw(fetch forward user smtp)], [qw(user smtp)
+]);
[download]

my @b1 = (); push @b1, $_, 1 for @b; my %b = @b1;
my @c = grep !$b{$_}, @a;
[download]

throop

This is a set operation (set difference), not a list operation.

This is a set operation (set difference), not a list operation.

Sure it is a set operation. As is uniq, or even max. You could want to do the same operation to hashkeys, or to a CSV string. But the most common way that the set-difference problem shows up is as the set difference between two lists.

If not List::MoreUtils, I'm still surprised it isn't in one of the common modules.

throop

List::Compare works for this problem:

use strict;
use warnings;
use List::Compare;

my @dbs = qw(fetch forward user smtp);
my @skip_dbs = qw(user smtp);

my $lc = List::Compare->new(\@dbs, \@skip_dbs);

my @list = $lc->get_unique;

print @list;
[download]

Cheers,

Brent


-- Yeah, I'm a Delt.