Confusion when defining a list of array refs as constant

In some Perl code I'm doing some low-level coding accessing Perl constants that are lists, like this:

> use constant LIST => ()

As Perl constants are actually implemented as functions, I'm trying to get the value via the symbol table as ${__PACKAGE__.'::'}{LIST}->().

The confusing part is that sometimes Perl dies with:

> Not a CODE reference at ...

Running a debugger test session I got the impression that the constant uses a different representation if the list has only one element:

  DB<18> use constant TEST => (['status', 1, undef],)

  DB<19> x ${__PACKAGE__ . '::'}{TEST}
0  REF(0x2871fc8)
   -> ARRAY(0x2a914f0)
         0  'status'
         1  1
         2  undef
  DB<20> x TEST
0  ARRAY(0x2a914f0)
   0  'status'
   1  1
   2  undef
  DB<21> use constant TEST2 => (['status', 1, undef], ['something', 2, undef])

  DB<22> x ${__PACKAGE__ . '::'}{TEST2}
0  *Auth::Verifier::TEST2
  DB<23> x TEST2
0  ARRAY(0x2a092d8)
   0  'status'
   1  1
   2  undef
1  ARRAY(0x2a91808)
   0  'something'
   1  2
   2  undef
  DB<24> x ${__PACKAGE__ . '::'}{TEST2}->()
0  ARRAY(0x2a092d8)
   0  'status'
   1  1
   2  undef
1  ARRAY(0x2a91808)
   0  'something'
   1  2
   2  undef
  DB<25> x ${__PACKAGE__ . '::'}{TEST}->()
Not a CODE reference at (eval 35)[/usr/lib/perl5/5.18.2/perl5db.pl:732] line 2.
  DB<26>

Is there a way to force constants to be functions?
I'm using an older Perl (perl5 (revision 5 version 18 subversion 2)).

Update

It seems that regular functions (compared to use constant) doe not have such "optimization" that https://stackoverflow.com/a/76407240/6607497 suggests:

  DB<22> sub f3 { ([1]) }

  DB<23> sub f4 { ([1],[2]) }

  DB<24> x ${main::}{f3}->()
0  ARRAY(0x1413670)
   0  1
  DB<25> x ${main::}{f4}->()
0  ARRAY(0x1413508)
   0  1
1  ARRAY(0x13f9720)
   0  2
  DB<26> x ${main::}{f3}
0  *main::f3
  DB<28> x ${main::}{f4}
0  *main::f4

Here all "constants" are actual functions.
also note that adding a () prototype does not change that (see "man perlsub" on constants for details).

• \&TEST will return a sub.
• &TEST() will call it as a sub.

So they are effectively subs. You're simply not seeing them in the symbol table as subs.

A while back, the symbol table was optimized to save space. I don't know all the details, but I believe symbols associated with a only one variable are replaced with a reference to that variable. Since most entries contains only a single variable (usually a sub), this saves a lot of memory. Code visiting navigating the symbol table will need to take these changes into consideration.

The magic what happens can be found in constant.pm:

# ...
        {
# ...
            if ($multiple || @_ == 1) {
                my $scalar = $multiple ? $constants->{$name} : $_[0];

# ...
                # The constant serves to optimise this entire block out on
                # 5.8 and earlier.
                if (_CAN_PCS && $symtab && !exists $symtab->{$name}) {
# ...
                    Internals::SvREADONLY($scalar, 1);
                    $symtab->{$name} = $scalar;
                    ++$flush_mro;
                } else {
                    *$full_name = sub () { $scalar };
                }
            } elsif (@_) {
                my @list = @_;
                *$full_name = sub () { @list };
            } else {
                *$full_name = sub () { };
            }
        }
# ...

So when there is only a single value, no function will be created, but the reference of the value will be used instead.

The reason ("Storing a reference to a constant value in a symbol table is equivalent to a full typeglob referencing a constant subroutine, but using about 400 bytes less memory.") is explained in Constant subroutines on metacpan.org as part of Perl 5.8.9 changes.

However it seems that "is equivalent" means the Perl interpreter handles the difference internally.