constants wont optimize

patcat88 has asked for the wisdom of the Perl Monks concerning the following question:

under perl 5.12.2, with deparse, I see constants that are not being optimized. There is also an issue with "if(func)" vs "if(func())".

No parentheses, with module. this works.

BEGIN {
     package mod;
     $VERSION = 1;
     package main;
}

BEGIN {
     if (scalar(%mod::)
         && $mod::VERSION
         ) {eval " sub haveMod () { return 1; }"
            ;}
     else {eval "sub haveMod () { return 0; }"
           ;}
     sub checkMod () {
          if(haveMod)
          {return "goodMod";}
          else {return "badMod";}
     }
}
print checkMod;
[download]

C:\Documents and Settings\Owner\Desktop>perl -MO=Deparse,  consttest.p
+l & perl c
onsttest.pl
BEGIN { $^W = 1; }
sub BEGIN {
    package mod;
    $VERSION = 1;
}
sub BEGIN {
    if (scalar %mod:: and $mod::VERSION) {
        eval ' sub haveMod () { return 1; }';
    }
    else {
        eval 'sub haveMod () { return 0; }';
    }
}
sub checkMod () {
    do {
        return 'goodMod'
    };
}
print checkMod;
consttest.pl syntax OK
goodMod
C:\Documents and Settings\Owner\Desktop>
[download]

No module, no parentheses. This totally doesn't work. I got goodMod instead of badMod.

#!/usr/bin/perl -w
#COMMENTED OUT
#BEGIN {
#     package mod;
#     $VERSION = 1;
#     package main;
#}

BEGIN {
     if (scalar(%mod::)
         && $mod::VERSION
         ) {
          eval " sub haveMod () { return 1; }"
            ;}
     else {
          eval "sub haveMod () { return 0; }"
           ;}
     sub checkMod () {
          if(haveMod)
          {return "goodMod";}
          else {return "badMod";}
     }
}
print checkMod;
[download]

C:\Documents and Settings\Owner\Desktop>perl -MO=Deparse,  consttest.p
+l & perl c
onsttest.pl
BEGIN { $^W = 1; }
sub BEGIN {
    if (scalar %{'mod::'} and $mod::VERSION) {
        eval ' sub haveMod () { return 1; }';
    }
    else {
        eval 'sub haveMod () { return 0; }';
    }
}
sub checkMod () {
    do {
        return 'goodMod'
    };
}
print checkMod;
consttest.pl syntax OK
goodMod
C:\Documents and Settings\Owner\Desktop>
[download]

With parentheses, with module. This works, but didn't optimize.

#!/usr/bin/perl -w
BEGIN {
     package mod;
     $VERSION = 1;
     package main;
}

BEGIN {
     if (scalar(%mod::)
         && $mod::VERSION
         ) {
          eval " sub haveMod () { return 1; }"
            ;}
     else {
          eval "sub haveMod () { return 0; }"
           ;}
     sub checkMod () {
          #NOTE THE PARENTHESES
          if(haveMod())
          {return "goodMod";}
          else {return "badMod";}
     }
}
print checkMod;
[download]

C:\Documents and Settings\Owner\Desktop>perl -MO=Deparse,  consttest.p
+l & perl c
onsttest.pl
BEGIN { $^W = 1; }
sub BEGIN {
    package mod;
    $VERSION = 1;
}
sub BEGIN {
    if (scalar %mod:: and $mod::VERSION) {
        eval ' sub haveMod () { return 1; }';
    }
    else {
        eval 'sub haveMod () { return 0; }';
    }
}
sub checkMod () {
    if (haveMod) {
        return 'goodMod';
    }
    else {
        return 'badMod';
    }
}
print checkMod;
consttest.pl syntax OK
goodMod
C:\Documents and Settings\Owner\Desktop>
[download]

With parenthesis, no module, this works didn't optimize.

C:\Documents and Settings\Owner\Desktop>cat consttest.pl & echo: & ech
+o: & echo:
 & perl -MO=Deparse,  consttest.pl & perl consttest.pl
#!/usr/bin/perl -w
#BEGIN {
#     package mod;
#     $VERSION = 1;
#     package main;
#}

BEGIN {
     if (scalar(%mod::)
         && $mod::VERSION
         ) {
          eval " sub haveMod () { return 1; }"
            ;}
     else {
          eval "sub haveMod () { return 0; }"
           ;}
     sub checkMod () {
          if(haveMod())
          {return "goodMod";}
          else {return "badMod";}
     }
}
print checkMod;


BEGIN { $^W = 1; }
sub BEGIN {
    if (scalar %{'mod::'} and $mod::VERSION) {
        eval ' sub haveMod () { return 1; }';
    }
    else {
        eval 'sub haveMod () { return 0; }';
    }
}
sub checkMod () {
    if (haveMod) {
        return 'goodMod';
    }
    else {
        return 'badMod';
    }
}
print checkMod;
consttest.pl syntax OK
badMod
C:\Documents and Settings\Owner\Desktop>
[download]

A not, no parenthesis, wrong result.

C:\Documents and Settings\Owner\Desktop>cat consttest.pl & echo: & ech
+o: & echo:
 & perl -MO=Deparse,  consttest.pl & perl consttest.pl
#!/usr/bin/perl -w
#BEGIN {
#     package mod;
#     $VERSION = 1;
#     package main;
#}

BEGIN {
     if (scalar(%mod::)
         && $mod::VERSION
         ) {
          eval " sub haveMod () { return 1; }"
            ;}
     else {
          eval "sub haveMod () { return 0; }"
           ;}
     sub checkMod () {
          if(! haveMod)
          {return "badMod";}
          else {return "goodMod";}
     }
}
print checkMod;


BEGIN { $^W = 1; }
sub BEGIN {
    if (scalar %{'mod::'} and $mod::VERSION) {
        eval ' sub haveMod () { return 1; }';
    }
    else {
        eval 'sub haveMod () { return 0; }';
    }
}
sub checkMod () {
    if (not 'haveMod') {
        return 'badMod';
    }
    else {
        return 'goodMod';
    }
}
print checkMod;
consttest.pl syntax OK
goodMod
C:\Documents and Settings\Owner\Desktop>
[download]

So how do you do compile time constant folding with perl? Conditionally eval large complicated subroutines such as checkMod() in my example? And why does "if(func)" seem to check if the function is defined, and optimizes, rather than run it?

Comment on constants wont optimize Select or Download Code

Replies are listed 'Best First'.
Re: constants wont optimize by Juerd (Abbot) on Jul 09, 2011 at 23:54 UTC
Drop the "return" keyword: `juerd@lanova:~$ perl -MO=Deparse -e'BEGIN { eval "sub foo () { return +42; }" } print foo;' sub BEGIN { eval 'sub foo () { return 42; }'; } print foo; -e syntax OK juerd@lanova:~$ perl -MO=Deparse -e'BEGIN { eval "sub foo () { 42 }" } + print foo;' sub BEGIN { eval 'sub foo () { 42 }'; } print 42; -e syntax OK` [download] Also, there's a better way than using eval. You can assign a code reference to a glob: `glob = sub () { value };` [download] `juerd@lanova:~$ perl -MO=Deparse -e'BEGIN { foo = sub () { 42 } } pri +nt foo;' sub BEGIN { *foo = sub () { 42 } ; } print 42; -e syntax OK` [download] Juerd	[reply] [d/l] [select]
Re^2: constants wont optimize by patcat88 (Deacon) on Jul 10, 2011 at 17:06 UTC
I think I found a solution, but I dont know why it works. The fix is to throw another BEGIN around the part that sets the constant. I would like to know why it works. C:\Documents and Settings\Owner\Desktop>cat consttest.pl & echo: & ech +o: & echo: & perl -MO=Deparse, consttest.pl & perl consttest.pl #!/usr/bin/perl -w #BEGIN { # package mod; # $VERSION = 1; # package main; #} BEGIN { BEGIN { if (scalar(%mod::) && $mod::VERSION ) { eval " sub haveMod () { 1; }" ;} else { eval "sub haveMod () { 0; }" ;} } sub checkMod () { if(haveMod()) {return "goodMod";} else {return "badMod";} } } print checkMod; BEGIN { $^W = 1; } sub BEGIN { sub BEGIN { sub checkMod () { do { return 'badMod' }; } } if (scalar %{'mod::'} and $mod::VERSION) { eval ' sub haveMod () { 1; }'; } else { eval 'sub haveMod () { 0; }'; } } print checkMod; consttest.pl syntax OK badMod C:\Documents and Settings\Owner\Desktop> [download] Getting rid of the returns doesn't fix the problem, the return is always implied. Last statement of a subroutine is the return result in Perl. C:\Documents and Settings\Owner\Desktop>cat consttest.pl & echo: & ech +o: & echo: & perl -MO=Deparse, consttest.pl & perl consttest.pl #!/usr/bin/perl -w #BEGIN { # package mod; # $VERSION = 1; # package main; #} BEGIN { if (scalar(%mod::) && $mod::VERSION ) { eval " sub haveMod () { 1; }" ;} else { eval "sub haveMod () { 0; }" ;} sub checkMod () { if(haveMod()) {return "goodMod";} else {return "badMod";} } } print checkMod; BEGIN { $^W = 1; } sub BEGIN { if (scalar %{'mod::'} and $mod::VERSION) { eval ' sub haveMod () { 1; }'; } else { eval 'sub haveMod () { 0; }'; } } sub checkMod () { if (haveMod) { return 'goodMod'; } else { return 'badMod'; } } print checkMod; consttest.pl syntax OK badMod C:\Documents and Settings\Owner\Desktop> [download]	[reply] [d/l] [select]
Re^3: constants wont optimize by chromatic (Archbishop) on Jul 11, 2011 at 05:13 UTC
The fix is to throw another BEGIN around the part that sets the constant. I would like to know why it works. eval is a runtime operation. Sub declaration is a compile time operation. `BEGIN` does nothing to change that unless you use a `BEGIN` to perform the runtime eval before the compile time declaration occurs. All of the operations within a single `BEGIN` block occur, with respect to each other, in the order they would occur if not for the `BEGIN` block.	[reply] [d/l] [select]
Re: constants wont optimize by ikegami (Patriarch) on Jul 10, 2011 at 02:40 UTC
It's much much simpler than that: `use constant haveMod => $mod::VERSION; print haveMod ? "goodMod" : "badMod";` [download]	[reply] [d/l]
Re^2: constants wont optimize by patcat88 (Deacon) on Jul 10, 2011 at 18:09 UTC
I am trying to NOT use constant. `use if eval { require mod; 1 }, qw' constant haveMod 1 ';` can't get very complicated, cosmetically, For example, during running/compiling of the require of a use for a PM, probing the capabilities of the current OS/perl installation, including, calling XSUBs, setting the constant subs, then defining the subs that rely on those constant subs and having the perl compiler delete the subroutine branches for never to be used code path. I looked through the source of constant.pm, its doing something black magic, "mro::method_changed_in($classname)" and Internals::SvREADONLY to make its constant subs. Not the public Constant Functions way.	[reply] [d/l]
Re^3: constants wont optimize by ikegami (Patriarch) on Jul 10, 2011 at 18:12 UTC
Actually, as you've found out, your way is the complicated one. Simple: `use constant haveMod => eval { require mod; };` [download] And for the non-trivial: `my $haveMod; BEGIN { ...[ something complicated ]... $haveMod = ...; } use constant haveMod => $haveMod;` [download] or even `BEGIN { ...[ something complicated ]... require constant; import constant haveMod => ...; }` [download] PS - require always returns true, so the "1" is redundant.	[reply] [d/l] [select]
Re: [DUP] Re^3: constants wont optimize by patcat88 (Deacon) on Jul 10, 2011 at 20:58 UTC
Re^5: constants wont optimize by ikegami (Patriarch) on Jul 10, 2011 at 21:35 UTC
Re: constants wont optimize by Somni (Friar) on Jul 10, 2011 at 00:13 UTC
Ah, Juerd's comment about return explains why I was unable to replicate your problem with any version of perl I have. I automatically corrected it when writing my test code. Anyways, in case someone is interested, here's the test code. I've modified it to show the problem with return; it won't work on Windows as is, you'll have to remove the `2>/dev/null`. #!/usr/bin/perl -w use strict; { my $const_return = 'BEGIN { eval "sub HAS () { return 1 }" }'; my $const_noreturn = 'BEGIN { eval "sub HAS () { 1 }" }'; my $const_use = 'use constant; BEGIN { constant->import( HAS +=> 1 ) }'; my $paren = 'print HAS;'; my $noparen = 'print HAS();'; print( 'return, with parens ', run($const_return, $paren ), +"\n", 'return, without parens ', run($const_return, $noparen), +"\n", 'noreturn, with parens ', run($const_noreturn, $paren ), +"\n", 'noreturn, without parens ', run($const_noreturn, $noparen), +"\n", 'use, with parens ', run($const_use, $paren ), +"\n", 'use, without parens ', run($const_use, $noparen), +"\n", ); } sub run { my($code) = join ' ', @_; my @normal = qx{perl -wle \Q$code\E }; my @deparse = qx{perl -MO=Deparse -wle \Q$code\E 2>/dev/null}; chomp(my $normal_output = $normal[-1]); chomp(my $deparse_output = $deparse[-1]); return join ' ', $normal_output, $deparse_output; } [download] And some example output, with 5.12.2: `> px 5.12.2 ./constant-folding.pl return, with parens 1 print HAS; return, without parens 1 print HAS; noreturn, with parens 1 print 1; noreturn, without parens 1 print 1; use, with parens 1 print 1; use, without parens 1 print 1;` [download]	[reply] [d/l] [select]
Re^2: constants wont optimize by Marshall (Canon) on Jul 10, 2011 at 04:20 UTC
on Windows as is, you'll have to remove the 2>/dev/null On Windows the equivalent of the Unix /dev/null device, the "bit bucket", is the "file" called NUL. Note one 'L'. 2>NUL is same as 2>/dev/null on Unix. The case of the name NUL can be anything, nUl, etc. This name is reserved by Windows in all directories - you cannot make a file called NUL. ">type NUL" prints nothing instead of printing "file not found".	[reply]
Re^3: constants wont optimize by Anonymous Monk on Jul 10, 2011 at 04:29 UTC
`$ perl -MFile::Spec -le " print File::Spec->devnull" nul` [download] perlport - Writing portable Perl	[reply] [d/l]
Re: constants wont optimize by Anonymous Monk on Jul 10, 2011 at 01:26 UTC
`use if eval { require mod; 1 }, qw' constant haveMod 1 '; use if not exist $INC{'mod.pm'}, qw' constant haveMod 0 '; use Module::Loaded qw' is_loaded '; use constant haveMod => !! is_loaded('mod');` [download]	[reply] [d/l]


Perl-Sensitive Sunglasses
	PerlMonks