in reply to Re: Overloading different instances differently.
in thread Overloading different instances differently.

I could be wrong, but the memory problem doesn't seem to be unfixable.

The packages the OP is creating would be small (because all the methods are inherited). Also you could manually get rid of the package on destruction using something akin to this: 
package FOO;

sub asdf{shift ; reverse @_};

package main;

# need an object so that functions get bound at runtime
my $o = bless {}, 'FOO';

print $o->asdf(1..10); # ok

undef %FOO::;

print $o->asdf(1..10); # function cannot be found

[download]
If you were extremely memory concious, you could put each instance's fields in the new package (why use another hashref?)

If you wanted to be realy sneaky, you could have the object as a globref to it's own package and the decrement the refcount on the glob by one. When the instance goes out of scope, the glob's refcount drops to 0 and cleans itself up.

At least thats the way I understand packages. Please enlighten me if I'm wrong.

Udate: The code presented above doesn't work. Here's why: every time perl sees the name *Foo:: or %Foo:: in the source, it increments the ref count of it (similar in concept to closing over a value, but for globals). Therefore undef *Foo:: inadvertently creates another reference to the value it is trying to destruct.

Here's the code I used to come to that conclusion. 
use strict;
use Inline 'C';

$\ = "\n";

my $x;
BEGIN {
    my $n = 100;
    $x = eval 'sub {' . ('%Foo::;' x $n) . '}';
}

print refcount(*Foo::); # prints $n + 2

__END__
__C__
int refcount(SV* x) {
    return SvREFCNT(x);
}

[download]

Replies are listed 'Best First'.
Re^3: Overloading different instances differently.
by tilly (Archbishop) on Feb 23, 2008 at 03:48 UTC
    You are assuming that your code destroys everything in a package properly. Let's test that: 
    #! /usr/bin/perl -w
use strict;

my $s;

print "Creating functions\n";
my $x = TellDestroy->new(sub {print $s}, "variable sub");
*Foo::function = TellDestroy->new(sub {print $s}, "glob sub");

print "Clearing variable\n";
undef $x;

print "Clearing glob\n";
undef %Foo::;

print "Exiting\n";

package TellDestroy;
use Scalar::Util qw(refaddr);
my %function_name;

sub new {
  my ($class, $self, $name) = @_;
  $function_name{refaddr($self)} = $name;
  bless $self, $class;
}

sub DESTROY {
  my $self = shift;
  my $name = delete $function_name{ refaddr($self) };
  print STDERR "$name is going away\n";
}
__END__

    [download]
    produces the following output for me on Perl 5.8.6 under Linux: 
    Name "Foo::function" used only once: possible typo at check line 8.
Creating functions
Clearing variable
variable sub is going away
Clearing glob
Exiting
glob sub is going away

    [download]
    So the function survived to global destruction. I take that to mean that Perl doesn't clean up packages the way you wanted it to.
[reply]
[d/l]
[select]

      The long-time standard module Symbol to the rescue. Just change undef %Foo::; to delete_package('Foo');. 

      #! /usr/bin/perl -w
use strict;
use Symbol 'delete_package';

my $s;

print "Creating functions\n";
my $x = TellDestroy->new(sub {print $s}, "variable sub");
*Foo::function = TellDestroy->new(sub {print $s}, "glob sub");

print "Clearing variable\n";
undef $x;

print "Clearing glob\n";
delete_package('Foo');

print "Exiting\n";

package TellDestroy;
use Scalar::Util qw(refaddr);
my %function_name;

sub new {
  my ($class, $self, $name) = @_;
  $function_name{refaddr($self)} = $name;
  bless $self, $class;
}

sub DESTROY {
  my $self = shift;
  my $name = delete $function_name{ refaddr($self) };
  print STDERR "$name is going away\n";
}

__END__
Name "Foo::function" used only once: possible typo at ...
Creating functions
Clearing variable
variable sub is going away
Clearing glob
glob sub is going away
Exiting

      [download]

      lodin

[reply]
[d/l]
[select]

In Section Meditations