defining constant in other package

[LanX]

Hi

For a package which I'm coding I wanna offer to switch on debugging by a constant!

The idea is that the related code is not compiled if the flag is false (codefolding)¹ thus not causing performance lost if in non-debug mode.

Is there any way to tell use constant which namespace to use?

ATM I'm using something like

# --- user's code
package MyPackg; 
use constant DBG => 0;
 
package main;
 
...

MyPackg::func();
 
...
 
# --- my code
package MyPackg;
sub func {
   print "DEBUGGING" if DBG; # won't be compiled
}

Any nicer way to achieve this?

UPDATE: at least it can be simplified for the user with lexically scoped packages:

{
  package MyPackg; 
  use constant DBG => 0;
}

UPDATE: ¹) better phrased as "unreachable code removal"

[Anonymous Monk]

No there isn't, but a constant is merely

sub Ro:Sham::Bo::DEBUG(){ !!1 }
sub Ro:Sham::Bo::DEBUG(){ !!0 }
package Ro:Sham::Bo;
use constant DEBUG => !!$ENV{PERL_RO_SHAM_BO};

[Anonymous Monk]

*sigh* if using the ENV option it should be

package Ro:Sham::Bo;
use constant DEBUG => !!$ENV{PERL_RO_SHAM_BO_DEBUG};

[LanX]

Well but even when putting a sub-declaration into a BEGIN block codefoldinmg isn't effected!

 > perl -MO=Deparse tst.pl
sub BEGIN {
    sub MyPackg::DBG {
        0;
    }
    
}
our $a = 1;
package MyPackg;
print 'DEBUGGING' if DBG();  # <-- oops
print 'huhu';
tst.pl syntax OK

OK forget it this works, thanks!

BEGIN {
  sub MyPackg::Debug {!!0};
}
 
 
our $a=1;
 
package MyPackg;
 
use constant DBG => MyPackg::Debug;
 
print "DEBUGGING" if DBG; # won't be compiled
 
print "huhu";

 > perl -MO=Deparse tst.pl
sub BEGIN {
    sub MyPackg::Debug {
        0;
    }
    
}
our $a = 1;
package MyPackg;
sub BEGIN {
    require constant;
    do {
        'constant'->import('DBG', Debug())
    };
}
'???';
print 'huhu';
tst.pl syntax OK

[Corion]

Perl wants a constant (subroutine) to have an empty prototype before it eliminates code guarded by it:

BEGIN {
    sub MyPackg::DBG() {
        0;
    }
    
}
our $a = 1;
package MyPackg;
print 'DEBUGGING' if DBG();  # <-- oops
print 'huhu';

gives this output:

F:\>perl -MO=Deparse tmp.pl
sub MyPackg::DBG () { 0 }
sub BEGIN {

}
our $a = 1;
package MyPackg;
'???';
print 'huhu';
tmp.pl syntax OK

[jandrew]

Smart::Comments maybe?

To have your variable turned on and off in another package see $ENV{Smart_Comments}

[LanX]

Thanks, but no thanks. :)

Better no source filter in productive code!

Smart::Comments may be OK if the developper tests his own code, but in this case the user should have the option to ask for additional infos (like benchmarks).

[BillKSmith]

As a side issue, I would always prefer to see Readonly rather than constant. The resulting structure is syntactically a variable rather than a function. The biggest advantage is that it interpolates in a string the same as any other variable.

[LanX]

Readonly can be used for constant folding?

[BillKSmith]

I am not sure what you mean by "constant folding." Perl ensures that "variables" marked as readonly cannot be used as l-values. I doubt that they are special in any other way.