How can I delay variable interpolation in a regex to the point of use?

Question

For example, let's imagine that I have a set of variables and an array of regexes that interpolate those variables: ``` my ($var1, $var2, $var3); my @search_regexes=( qr/foo $var1/, qr/foo bar $var2/, qr/foo bar baz $var3/, ); ``` The above code will give us warnings telling us that `$var1`, `$var2` and `$var3` are not defined at the point of regex compilation for the regexes in `$search_regexes`. However, I want to delay variable interpolation in those regexes until the point they are actually used (or later (re)compiled once the variables have values): ``` # Later on we assign a value to $var1 and search for the first regex in $_ ... $var1='Hello'; if (/$search_regexes[0]/) { # Do something ... } ``` How would I go about restructuring the construct in the initial code sample to allow for this? As a bonus, I would like to compile each regex after a value is assigned to the respective variable(s) appearing in that regex in the same way that the `qr//` operator is doing now (but too ea…

Accepted Answer

I think if you wrap each regular expression in anonymous sub, you can do this sort of deferral:

```
my ($var1, $var2, $var3);
my @search_regexes=(
  sub { return qr/foo $var1/         },
  sub { return qr/foo bar $var2/     },
  sub { return qr/foo bar baz $var3/ },
);
```

Then when you are going to evaluate them you just 'call' the anonymous sub:

```
($var1, $var2, $var3) = qw(thunk this code);
if( $_ =~ $search_regexes[0]->() ) {
   # Do something
}
```

I know in Scheme this is called thunking I am not sure if it has a name in Perl. You can do something similar in Ruby with Proc objects

How can I delay variable interpolation in a regex to the point of use?

Solution

Problem