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]

*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]

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]

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.

It's much much simpler than that:

use constant haveMod => $mod::VERSION;

print haveMod ? "goodMod" : "badMod";
[download]

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.

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.

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]

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".

$ perl -MFile::Spec -le " print File::Spec->devnull"
nul
[download]

perlport - Writing portable Perl

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]