First of all, please avoid the word fields as it is very confusing in OO. (pseudo hashes, etc...) as they are not lexically scoped (don't use my with fields).

Second, I see no inheritance operator in your classSome::Package::Sub. It misses the line

use base qw(Some::Package);
[download]

sub new {
  my $proto     = shift;
  my $class     = ref($proto) || $proto;
  my %args      = @_;
  bless($self, $class);
  $self->init();

    foreach my $arg (keys(%args)) {
      $self->$arg($args{$arg});
    }
  }
[download]

sub init {
   my $self=shift;
   $self->{_permitted} = \%fields;
   #... and add the other fields also
  };
[download]

Well, that's all well and good, since it does solve the problem of making sure that the reference to %fields points to the one in the appropriate file, but it sort of recreates the original problem I was trying to solve.

The whole point of inheriting the constructor was that I had subclasses that were all using esentially the same code for a constructor, so why duplucate the code. If I made changes, I'd have to update each package, etc. Instead, inherit it. But that introduced the problem that started this thread.

Your solution creates an init method, which must now exist in the same file as the subclass, and thus much exist in the same file for each and every subclass. While it significantly reduces the amount of code that is reproduced in each module, it doesn't eliminate it entirely.

If I make init inheritable from the base clase though, then I run into the same problem again. The reference points to the hash in the wrong file. It seems to be a chicken and the egg problem. Perhaps file-scoped lexical isn't the right way to go, but then how else do I get the fields (a name I shall change now, thank you for the education) for each class set up if not through a file-scoped lexical?

## in Some::Package
sub _init_attribs {
   %$fields = %{+pop};
}

## in Some::Package::Sub
my %fields = map { $_ => 1 } qw( field_a anotherone );

sub new {
    my $self = shift;
    $self->_init_attibs(\%fields);
    $self->SUPER::new(@_);
}
[download]

_________
broquaint

update: changed code to DWOrsmoMeant

I think you need use base 'Some::Package' in your sub class...

HTH, Valerio

my $self      = {
    _permitted  => \%{$class::fields},
    %{$class::fields},
  };
[download]

If you then call Some::Package::Sub->new, it uses Some::Package::Sub::%fields, which I think is what you want.

Caveat: I have not tested the above code so, although the syntax checks OK, it might not work at all. But even then, it should give you an idea on how to proceed.

CU
Robartes-

%fields was defined as a lexical my variable, so you cannot access it from the symbol table (ie, %{"${class}::fields"}). Define the hash as an our global variable (or use vars qw/%fields/; globals) in both classes and you can do it. This uses a taste of polymorphism (not really true polymorphism) in the new constructor -- no matter what inherited class it was called from, it uses that class's %fields hash.

If you don't like bodging in the symbol table (won't work under strict), it might be smoother would be to have a fields accessor sub in each class that would simply return the %fields hash:

package SomePackage;
my %fields = ( name => undef ); ## can be a lexical

### here's a new simple accessor
sub fields { return %fields };

sub new {
    my $proto     = shift;
    my $class     = ref($proto) || $proto;
    my %args      = @_;

    ### added this line
    my %fields = $class->fields;

    my $self      = {
        _permitted  => \%fields,
        %fields,
    };
    bless($self, $class);
    foreach my $arg (keys(%args)) {
        $self->$arg($args{$arg});
    }
}

## ... elsewhere

package Some::Package::Sub;
use base 'Some::Package'; ### you needed this line before

my %fields = ( name => undef, required => undef );
sub fields { return %fields };
[download]

This uses true polymorphism by calling $class->fields. You can keep the %fields hash as a lexical within the classes as well.

blokhead

This is an example of the Strategy pattern.

package Some::Package;

sub new {
  my $proto     = shift;
  my $class     = ref($proto) || $proto;
  my %args      = @_;
  my $fields_hr = $class->fields;
  my $self      = bless {
    _permitted  => $fields_hr,
    %$fields_hr,
  }, $class;
  foreach my $arg ( keys %args ) {
    $self->$arg( $args{$arg} );
  }
  $self
}

sub AUTOLOAD {
  my $self = shift;
  my $type = ref($self) or croak "$self is not an object";
  my $name = $AUTOLOAD;
  $name =~ s/.*://;
  exists $self->{_permitted}->{$name} or
    croak "Can't access `$name' field in class $type";
  @_ and $self->{$name} = shift;
  $self->{$name}
}

# the base class also defines some field(s).
sub fields { return { name => undef } }


#
# A derived class need only define the fields, and any other
# class-specific data/behavior.
#

package Some::Package::Sub;
use base qw(Some::Package);

sub fields { return {
  name          => undef,
  needthis      => undef,
} }
[download]

our @isa = qw(Some::Package);
[download]

Make that:

our @ISA = qw(Some::Package);
[download]

...and it might work the way you expect it to. Perl is case-sensitive. :)

...must learn to check for typos before pressing submit... In the actual code, @ISA is correctly capitalized. Maybe next time, I'll just cut and paste the actual code and let the distracting extra cruft be damned.