Regexp::Common and "multidimensional hash lookup disabled" (v5.36+)

[ibm1620]

Dear Monks,

I need to extract substrings delimited by balanced parentheses, and I installed Regexp::Common to see what it could do. Here is a test program that embeds an example from the doc (https://metacpan.org/pod/Regexp::Common).

#!/usr/bin/env perl
use v5.36;
use Regexp::Common;
 
while (<>) {
    /$RE{num}{real}/               and print q{a number};
    /$RE{quoted}/                  and print q{a ['"`] quoted string};
   m[$RE{delimited}{-delim=>'/'}]  and print q{a /.../ sequence};
    /$RE{balanced}{-parens=>'()'}/ and print q{balanced parentheses};
    /$RE{profanity}/               and print q{a #*@%-ing word};
}

Unfortunately, it won't compile:

Multidimensional hash lookup is disabled at /Users/chap/private/perl/r
+egcommon line 8, near "'/'}"

It seems that, at some point, it was permissible to write $foo{$bar, $frog}, which was understood by Perl to mean $foo{"$bar$;$frog"}, but this was later disabled (perl 5.33?). And I assume that {-delim=>'/'} is what's triggering the error, with '=>' being a fat comma.

Is Regexp::Common out of date? None of the 28 open issues seems to address this condition. Is there a way to make it work under v5.36 and beyond? Is there a successor to Regexp::Common?

(Incidentally, it seems from searching for "perl multidimensional hash" that most people take this to mean simply chaining keys, a la $thing{$x}{$y}{$z}, which of course is alive and well, as opposed to forming a "composite key" as in $thing{$x, $y, $z}).

Update 1: replaced literals with variables in examples of multidimensional hash lookups, per jwkrahn's comment below.

[choroba]

Does

$RE{balanced}{"-parens$;()"}

work instead?

[ibm1620]

Yes, it does. Thanks.

[kcott]

G'day ibm1620,

"Is there a way to make it work under v5.36 and beyond?"

A tedious fix in all of your scripts so that they work today:

use v5.36;
use feature 'multidimensional';
use Regexp::Common;

Update: What follows turned out to be incorrect information. This is explained in "Re^2: Regexp::Common and "multidimensional hash lookup disabled"". I have stricken the remainder of the original post but retained it in the spoiler.

<Reveal this spoiler or all in this thread>

[LanX]

Hi Ken

> permanent fix would be a bug report providing a patch that adds this statement near the start of Regexp::Common:

> use if $] >= 5.035, feature => 'multidimensional';

I doubt that's possible, because the problem happens outside the scope of that module, i.e. when using and calling it.

I think your "test code" is misleading, because the feature is activated for the remaining lexical scope, not the package alone.

Can't check till tomorrow tho...

[kcott]

G'day Rolf,

"Can't check till tomorrow tho..."

I waited a week as I wasn't entirely sure what you were getting at. I think this one might have slipped through your safety net. :-(

I did some digging today and identified the problem. I've explained it in 'Re^2: Regexp::Common and "multidimensional hash lookup disabled"'; and updated 'Re: Regexp::Common and "multidimensional hash lookup disabled"' in line with this.

Thanks anyway, your hint resulted in some bogus information being removed from PM. :-)

[kcott]

In "Re: Regexp::Common and "multidimensional hash lookup disabled"", I suggested that a patch for Regexp::Common could fix the problem. This was wrong.

The "source for Regexp::Common" starts with (line 3):

use 5.10.0;

This will use the feature bundle :5.10. See "feature: FEATURE BUNDLES" which includes:

:5.10     bareword_filehandles indirect
          multidimensional say state switch

So, the multidimensional feature is already loaded.

My test included:

...
package Regexp::Common;
use if $] >= 5.035, feature => 'multidimensional';

package main;
...

which seemed to fix the problem. However, rewriting that as:

...
package Regexp::Common {
    use if $] >= 5.035, feature => 'multidimensional';
}

package main;
...

and the problem returns:

Multidimensional hash lookup is disabled at ...

I'll be striking the incorrect information from the earlier post. It will be in a spoiler; I won't delete it.

[ibm1620]

Thanks, Ken.

What I couldn't understand was how Regexp::Common's tests were succeeding during installation, and when I invoked them standalone. Finally realized it was because the test scripts didn't have use v5.36; at the top!

My use of Regexp::Common should be rare enough that I can live with writing use feature 'multidimensional'; when I need to. It sounds like adding it to the module may be tricky. Too bad it'll take a bit of digging for others to discover, although searching for the error now turns up this thread as google's first hit. :-)

[jwkrahn]

It seems that, at some point, it was permissible to write $foo{bar, frog}, which was understood by Perl to mean $foo{'bar,frog'},

$foo{bar, frog} is seen by perl as two barewords separated by a comma, i.e. $foo{'bar', 'frog'}.

[ibm1620]

corrected, thanks.