#!/usr/bin/perl

BEGIN { use strict; use warnings; }

package Utils;

sub new {
  # discard my class...
    shift(@_);

  # ...and invoke LowUtils::new as though
  # it were called by our caller.
  LowUtils::new ( 'LowUtils', @_ );
}

sub get_numlines {
  my $self = shift;
  return scalar @{$self->{FILEDATA}};
}

sub DESTROY {
  print "\tthis is the Utils destructor\n";
}

1; # end package Utils

package LowUtils;
@LowUtils::ISA = qw ( Utils ) ;

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

  $self->{FILENAME} = $args{file};
  $self->{FILEDATA} = [];

  bless $self, $class;

  $self->init;
  return $self;
}


sub init {
  my $self= shift(@_);
  my %args= @_;

  open DAT, $self->{FILENAME} or return undef;
  @{$self->{FILEDATA}} = <DAT>;
  close DAT;

  return $self;
}

sub DESTROY {
  print "\tthis is the LowUtils destructor\n";
}

1; # end package LowUtils


my $utils = Utils->new ( file => $0 );
print 'Utils:    lines = ', $utils->get_numlines, "\n";
undef $utils;

my $low = LowUtils->new ( file => $0 );
print 'LowUtils: lines = ', $low->get_numlines, "\n";
undef $low;

exit;
[download]

Utils:    lines = 72
        this is the LowUtils destructor
LowUtils: lines = 72
        this is the LowUtils destructor

I arrived at this solution after deciding that it probably wouldn't be smart to set @Utils::ISA to refer back to LowUtils. My questions:

• This works now - can I expect it to work through future versions of Perl?
  
• Is this an okay way to do it, or is there a better way? Or should I not be doing this at all?
  
• Along the lines of 'should I not be doing this' - what mishmash am I potentially introducing into my module? I tossed in two DESTROY methods to make sure that Utils::DESTROY doesn't get called on objects invoked with Utils->new() - can anyone think of anything that I'm missing?
  

blyman
setenv EXINIT 'set noai ts=2'