Here's how to do it without any eval at all. As a plus, you get compile-time syntax checking:

sub Instance_Var ($) {
    my $package=__PACKAGE__;
    my ($var)=@_;
    my $accessor_name = "$package\::$var";
    my $acc = sub {
        my $t = shift;
        $t->{$var}=$_[0] if @_;
        $t->{$var};
    };

    # Now install our anonymous subroutine as $package::$var
    no strict 'refs';
    *{ $accessor_name } = $acc;
}
[download]

You might also want to see Class::Accessor and any of the other Accessor modules. Maybe also Class::Data::Inheritable.

You have a string fragment of "my $t = shift;" in there. Double quotes interpolate variables like $t and $accessor. You declared my $accessor, but not $t.

You need to escape the sigils or use single quotes to avoid interpolating the $t.

Basically, you're trying to pass something like this to the eval:

        sub __PACKAGE__::WhatARGVsaid {
            my <undef>=shift;
            <undef>->{WhatARGVsaid}=__PACKAGE__::WhatARGVsaid if WhatA
+RGVsaid;
            <undef>->{WhatARGVsaid};
        }
[download]

um... But but as a 'sub', this works:

    sub proto {
        my $p=shift;
        $p->{proto}=$_[0] if @_;
        $p->{proto};
    }
[download]

I don't see what you mean by 'my $t=shift;' being a fragment. I have 'my $p=shift;'in the code above and it works fine. Pops first arg off and uses it as the reference, tests if there's any more params, and if so, assigns the 1st one to the named value, else just returns the named value.

oh!!!!

DOI!

Nevermind....

*sigh*...this really is one of those days.

(car sitting in drive-way won't start, tow-truck on way..., among OTHER things!)

Simple fix you escape the $ for $t and $_ using \ before dollar sign

my @vars = ('instance1','instance2',..);
foreach (@vars) {
    eval "sub $_ { 
             my \$self = shift; 
             if (@_) { 
                \$self->{$_} = shift;
             }
             return \$self->{$_};
          }";
}
[download]

if (@_) { 
    \$self->{$_} = shift;
    }
[download]

Arrays get interpolated too, so I think the code above – and likewise in OPed code – should be (note  \@_ vice  @_):

if (\@_) { 
    \$self->{$_} = shift;
    }
[download]

    eval('
        package '.$package.';
        sub '.$accessor.' {
            my $t=shift;
            $t->{'.$var.'}=$_[0] if @_;
            $t->{'.$var.'};
        }
    ')
[download]

I prefer sprintf.

    eval(sprintf(
        '
            package %s;
            sub %s {
                my $t=shift;
                $t->{%s}=$_[0] if @_;
                $t->{%s};
            }
        ',
        $package, $accessor, $var, $var
    ))
[download]

Note that I actually build the sub in the right package. That changes some of the meta information associated with the sub (e.g. its __PACKAGE__).

Update: Fixed copy and paste error.

i see that your question was answered. One additional pointer: use block eval rather than string eval. Instead of wrapping all that in double-quotes, you put it in a curlies block. It's easier to write and to read.

UPDATE: I stand corrected. Think-o

And totally useless. The OP is trying to generate code, not catch exceptions.

For better or worse eval handles two very different roles:
1. eval STRING is used to generate new code during run-time by evaluating the string during run-time.
2. eval BLOCK is used for exception handling and is not not evaluated during run-time.
No idea why something more obvious like "catch" was not used for eval blocks, but that oversight has certainly led to lots of confusion.

Elda Taluta; Sarks Sark; Ark Arks