If you want to have other references automatically become undefined, perhaps you can use Scalar::Utils weaken() method to convert them to weak references.

Perhaps easier is just to set the object to some state that signals it's not "relevant", or just remove if from the list.

Phil

Interesting question.

I wonder if you could do something with weaken from Scalar::Util for this. You could have the object itself keep a strong reference to itself, and then all other references would have to be weak. Then the object could drop itself at will.

The problem is that a copy of a weak reference is not weak, so you can't just weaken yourself in the constructor and pass that out. The rest of the code would have to be disciplined enough to weaken every new object and every copy of an object's reference.

Update: I've been fooling around with this a little bit thinking that I could use overload, but it hasn't worked. The problem is that you can't really overload '=' so that the object returns a weakened reference to itself. The best I've come up with is to have a somewhat different constructor.

package Weakling;

use Scalar::Util qw( weaken );

sub new {
    die 'Call as Weakling->new(my $new_weakling)'
        if ( defined wantarray or scalar @_ < 2 );

    my $self = {};
    $self->{self} = $self;
    bless $self, 'Weakling';

    $_[1] = $self;
    weaken $_[1];

    return;
}

sub suicide { delete $_[0]->{self} }

package main;

use Scalar::Util qw( isweak );
use Test::More 'no_plan';

Weakling->new(my $weakling);
isa_ok( $weakling, 'Weakling' );
ok( isweak $weakling, 'got a weak object' );

$weakling->suicide();
ok( ! defined $weakling, 'weakling killed itself' );

Weakling->new($weakling);
isa_ok( $weakling, 'Weakling' );
ok( isweak $weakling, 'got a weak object' );

TODO: { local $TODO = "Can't overload '='";

my $w2 = $weakling;
ok( isweak $w2, 'copy of weakling is weak' );
}
[download]

...but of course this won't work for you if you already have lots of construction in the traditional my $n = Obj->new() style.

   @objects = grep { $_->is_relevant } @objects;
[download]

I think that latter case (keeping other references around, so having to have them weak) is pretty unusual, though. Would you mind giving us a little more detail about your problem?

If that's not good enough, make all references to objects other than the list's reference be to a delegate object that looks up the real object via the list with each access.

What you're trying to do here is definitely possible, though I'm not sure it's advisable. The key is that you can't use the standard my $self = shift; boilerplate in that method, because that makes a copy of the caller's reference, rather than operating on it directly (this is usually a good thing). Rather, it would need to look something like the below:

sub method_which_may_suicide {
    my ($self,@arglist) = @_;
    if (_should_suicide(@arglist) ) {
        undef $_[0];
    }
}
[download]

Note that this will only destroy the reference in the immediate calling code—if you call this from another method that uses the my $self = shift; trick, it will not propagate the change to whoever called that method. And again, <symbolic hand-washing>I'm not advising you to do this, but it's there if you want it</symbolic hand-washing>. :-)

  foreach (@GLOBAL_OBJECT_LIST) {
    $_->{backref} = \$_;
  }
[download]

  undef ${ $_->{backref} };
[download]

  @GLOBAL_OBJECT_LIST = grep { $_ != $self } @GLOBAL_OBJECT_LIST;
[download]