You're pretty close, but you aren't doing any substitution. You want something more like this:

$pat = "cccv";
$pat =~ s/c/[^aeiou]/g;
$pat =~ s/v/[aeiou]/g;
if ($word =~ /($pat)/) {
  $yep++;
}
[download]

kelan

Perl6 Grammar Student

my %regexen = (
    v => qr/[aeiou]/i;
    c => qr/[a-z^aeiou]/i;
);

# This is inputted somehow.
my $pattern = 'cccv';

my $regex = join '', map { $regexen{$_} } split //, $pattern;

# Get @dictionary somehow.
foreach my $word (@dictionary)
{
    print "$word matches"
        if $word =~ /$pattern/;
}
[download]

------
We are the carpenters and bricklayers of the Information Age.

Don't go borrowing trouble. For programmers, this means Worry only about what you need to implement.

Please remember that I'm crufty and crochety. All opinions are purely mine and all code is untested, unless otherwise specified.

Just out of curiosity, when you join pre-compiled regexen as dragonchild did above, and stick the result into a variable, is the variable now treated like a pre-complied regex, or will it need to be recompiled again each time during the foreach loop?

Once you've got your regex that you will be using to determine if a vowel/consonant combo is valid in your dictionary file, I would either pre-compile it using:

my $regex = qr/$string/;

while (my $word = <DICT>) {
   chomp($word);
   if ($word =~ $regex) {
      $yep++;
   }
}
[download]

or use the /o modifier (which assures the compiler that you won't be changing the contents of $string, or at least tells it not to bother recompiling):

while (my $word = <DICT>) {
   chomp($word);
   if ($word =~ /$string/o) {
      $yep++;
   }
}
[download]

so that the regex won't be recompiled each time, as since there are variables in the regex, it forces a recompile, which will slow down your app quite a bit.

Just my two cents.

That seems like it would work, however, It will still not match the pattern. The regex doesn't seem to be working correctly using the code above. And I believe you need quotes around my $regex = "qr/$string/"; Like so. Lets say you have this:
my $regex = "/[aeiou][aeiou]/";
It tries to match the literal slash then bracket and so on..., not using it as a reg. ex. at all. I think it is taking the pattern to match literally, as in it is trying to match. If you leave off the quotes and you print the string, it isn't right.

qr// is its own operator, and will not work with double quotes around it. If your regex variable ($string, in this case) that you will be pre-compiling has slashes in it, then of course it will try to match the slashes. It is assumed that the only thing inside the qr// operator is the regular expression itself. The previous posts before mine didn't contain slashes in their variable, either.

perlre explains why this is not permitted, and how to make it permitted if you really want to do it...

$string =~ /$re/;

Before Perl knew how to execute interpolated
code within a pattern, this operation was com­
pletely safe from a security point of view,
although it could raise an exception from an
illegal pattern.  If you turn on the "use re
'eval'", though, it is no longer secure, so you
should only do so if you are also using taint
checking.  Better yet, use the carefully con­
strained evaluation within a Safe module.  See
perlsec for details about both these mechanisms.

perlre explains why this is not permitted

Actually, perlre explains why (?{ code }) is not permitted which is quite a different thing.

The original code worked exactly as expected for me with the addition of a closing ')' on the if statement. (The match fails to increment $yep because the 'v' in $word doesn't match the vowel pattern).

Using variable interpolation in a regex is not a 'weird idea' at all. It can be an excellent way to improve the readability of your code.

I don't get your answer. What does it have to do with the question?

Abigail