Home/ Questions/Q 871953
In Process

The Archive Base Latest Questions

Editorial Team
  • 0
Asked: 2026-05-15T10:42:53+00:00

Putting a precompiled regex inside two different hashes referenced in a list: my @list

  • 0

Putting a precompiled regex inside two different hashes referenced in a list:

my @list = ();

my $regex = qr/ABC/;

push @list, { 'one' => $regex };
push @list, { 'two' => $regex };

use Data::Dumper;
print Dumper(\@list);

I’d expect:

$VAR1 = [
      {
        'one' => qr/(?-xism:ABC)/
      },
      {
        'two' => qr/(?-xism:ABC)/
      }
    ];

But instead we get a circular reference:

$VAR1 = [
      {
        'one' => qr/(?-xism:ABC)/
      },
      {
        'two' => $VAR1->[0]{'one'}
      }
    ];

This will happen with indefinitely nested hash references and shallowly copied $regex.

I’m assuming the basic reason is that precompiled regexes are actually references, and references inside the same list structure are compacted as an optimization (\$scalar behaves the same way). I don’t entirely see the utility of doing this (presumably a reference to a reference has the same memory footprint), but maybe there’s a reason based on the internal representation

Is this the correct behavior? Can I stop it from happening? Aside from probably making GC more difficult, these circular structures create pretty serious headaches. For example, iterating over a list of queries that may sometimes contain the same regular expression will crash the MongoDB driver with a nasty segfault (see https://rt.cpan.org/Public/Bug/Display.html?id=58500)

Share

Leave an answer

You must login to add an answer.

Need An Account,

1 Answer

  1. Editorial Team

    This is the expected behavior.

    Your reference isn’t really circular; you have two separate items that point to the same thing. Data::Dumper is printing a human-readable, Perl-parsable representation of your data structures in memory, and what it really means is that both $list[0]->{one} and $list[1]->{two} point to the same thing.

    Perl uses reference-counting garbage collection, and while it can get into trouble with circular data structures, this data structure presents no particular problem.

    • 0