BEGIN {
    sub main_package_vars {
        foreach(@_) {
            eval "sub $_ {
                my \$p = shift;
                \$p->{$_} = \$_[0] if \@_;
                \$p->{$_};
            }"
        }
    }
}
[download]

Why do you put this in a BEGIN block? It serves no purpose, at least when Perl looks at it.

Also, why are you using string-eval, when the plain eval works just as well. Also see Class::Accessor.

    sub main_package_vars {
        foreach my $name (@_) {
            no strict 'refs'; *{ $name } = sub {
                my $p = shift;
                $p->{$name} = $_[0] if @_;
                $p->{$name};
            }"
        }
    }
[download]

In this next snippet from MyPackage, I don't understand why you use string-eval, and also why you try to execute the same statement twice:

BEGIN {
    eval "*package_vars2 = \*main::main_package_vars";
    *package_vars3 = \*main::main_package_vars;
}
[download]

The subroutine package_vars3 does not exist:

package_vars3( qw(one two three) );
[download]

What problem are you trying to solve? Do you want to have a hash using which you get/set variables?

Maybe an object based on a plain hash using AUTOLOAD is already enough? If you want control over what keys get stored, again, see Class::Accessor.</c>

The first 'main_package_vars' is in a BEGIN block because it is a duplicate of the one below it. I want to move the BEGIN block out of the package declaration and into the 'main' block.

Then I want to use the package_vars definition in 'main'. I.e. I started with a BEGIN block only in a package like this (which works, but doesn't work if I remove the BEGIN block as you seem(?) to be suggesting).

#!/usr/bin/perl  -w
use strict;
use feature ':5.10';

package MyPackage;
{
    BEGIN {
        sub package_vars {
            foreach(@_) {
                eval "sub $_ {
                    my \$p = shift;
                    \$p->{$_} = \$_[0] if \@_;
                    \$p->{$_};
                }"
            }
        }
    }

    package_vars( qw(one two three) );

    sub new {
        my $package=shift;
        my $parms=$_[0];
        
        my $this={};

        foreach(%$parms) {
            $this->{$_}=$parms->{$_};
        }

        bless $this, $package;
    }
}

package main;

my $p=new MyPackage({three => 3,});

$p->two(1);

printf "two=%d, three=%d\n",$p->two, $p->three;
[download]

Now I try moving the BEGIN block out of the package and into main (thus 'main_package_vars'), and import it's functionality into the local package.

That's the problem I'm trying to solve. How to have my subroutine definition for 'package_vars' in 'main', and use it from a package, like in this (which doesn't work because package_vars, isn't being 'called' in MyPackage, now that it's been moved to main).

#!/usr/bin/perl  -w
use strict;
use feature ':5.10';

BEGIN {
    sub package_vars {
        foreach(@_) {
            eval "sub $_ {
                my \$p = shift;
                \$p->{$_} = \$_[0] if \@_;
                \$p->{$_};
            }"
        }
    }
}


package MyPackage;
    *package_vars=\&main::package_vars;
{

    package_vars( qw(one two three) );

    sub new {
        my $package=shift;
        my $parms=$_[0];
        
        my $this={};

        foreach(%$parms) {
            $this->{$_}=$parms->{$_};
        }

        bless $this, $package;
    }
}

package main;

my $p=new MyPackage({three => 3,});

$p->two(1);

printf "two=%d, three=%d\n",$p->two, $p->three;
[download]

The first version I posted had samples of the routine package_vars in each location where I could try changing the line that says 'package_vars3( qw(one two three));' to a line without the '3', and, call the original working version, vs. attempts at trying some way to call the version of 'package_vars' that was moved to main.

Is that more clear?

Some of the steps you take are somewhat clear, but I'm really wondering about the goal you're trying to reach by these steps. To me, it really seems as if you're trying to duplicate the functionality of Class::Accessor. The usage of Class::Accessor would be:

package MyPackage;
use parent qw(Class::Accessor);
__PACKAGE__->mk_accessors(qw(two three));

package main;
use strict;
my $f = MyPackage->new({three => 3});
$f->two(1);
printf "two=%d, three=%d\n",$f->two, $f->three;
[download]

This seems to be your use case, so why reinvent the wheel?

Also, why are you using string-eval, when the plain eval works just as well.

Because it didn't work when I tried it. Perhaps your perl works differently?

#!/usr/bin/perl  -w
use strict;
use feature ':5.10';

package MyPackage;
{
    BEGIN {
        sub package_vars {
            foreach(@_) {
                eval sub $_ {
                    my \$p = shift;
                    \$p->{$_} = \$_[0] if \@_;
                    \$p->{$_};
                };
            }
        }
    }

    
package_vars( qw(one two three) );
    sub new {
        my $package=shift;
        my $parms=$_[0];
        
        my $this={};

        foreach(%$parms) {
            $this->{$_}=$parms->{$_};
        }

        bless $this, $package;
    }
}

package main;

my $p=new MyPackage({three => 3,});

$p->two(1);

printf "two=%d, three=%d\n",$p->two, $p->three;
[download]

I got: Illegal declaration of anonymous subroutine at pck0.pl line 10. What do you get?

Sorry - you don't even need "plain eval". Just assigning the anonymous subroutine to the glob is all that's needed and creates a named subroutine from the anonymous subroutine.

The reason your subroutines are not defined in your package 'MyPackage' is that your subroutines are being defined in package main, rather than in package MyPackage. Even though you use a reference to the subroutine main_package_vars that is defined in package MyPackage (i.e. package_vars3) the subroutine (main_package_vars) still runs in the context of package main and the subroutines it defines are defined in package main.

By using fully qualified names, you can create the subroutines in any package name space. One option is to use __PACKAGE__ to pass the name of your package to main_package_vars and use this to create fully qualified names.

You might also be interested to use Data::Dumper to inspect the namespace of your package.

Here is a modified version of one of your code samples that might help you understand what is happening:

#!/usr/bin/perl  -w
use strict;
use feature ':5.10';

BEGIN {
    sub package_vars {
        my $package = shift;
        foreach(@_) {
            eval "sub ${package}::$_ {
                my \$p = shift;
                \$p->{$_} = \$_[0] if \@_;
                \$p->{$_};
            }"
        }
    }
}




package MyPackage;
use Data::Dumper;

{

    main::package_vars( __PACKAGE__, qw(one two three) );
    print Dumper(\%MyPackage::);

    sub new {
        my $package=shift;
        my $parms=$_[0];
        
        my $this={};

        foreach(%$parms) {
            $this->{$_}=$parms->{$_};
        }

        bless $this, $package;
    }
}

package main;

my $p=new MyPackage({three => 3,});

$p->two(1);

printf "two=%d, three=%d\n",$p->two, $p->three;
[download]

That's exactly what I want to do -- thank you for your understanding my question! However ... (sigh),... how can I do it without explicitly passing "__PACKAGE_" at the point of call. How can I tell what package 'main_package_vars' is called invoked from w/o explicitly passing it the package name?

After reading your response, I tried some way of delaying the interpretation of '__PACKAGE__' to interpret it at expansion time, below, but I think I keep ending up with 'two' in main or in the packaged named '__PACKAGE__', which is no help! If you see what I mean...?

I.e., if I was using some package like Class::Accessor, I don't see, yet, how it is getting the current package name and putting the routines into the current package's name space, but this is definitely the direction I'm looking for...maybe I just need to play around with this idea a bit and I'll bump into it...(?)...

The ->import subroutine that is called from a use statement can find out the name of the calling package by using caller.