Re^2: inside-out objects using arrays?

[rvosa]

I was thinking the following, which would lead to undef array elements once $obj->DESTROY gets called. Still, I like it ;-)

package Outside::In;
use strict;
use warnings;
{
    my $obj_counter = 0;
    my @name;
    
    sub new {
        my $class = shift;
        my $instance_index = $obj_counter;
        my $self = sub { return $instance_index };
        bless $self, $class;
        $obj_counter++;
        return $self;
    }
    
    sub name {
        my $self = shift;
        $name[$self->()] = shift if @_;
        return $name[$self->()];
    }
    
    sub DESTROY {
        my $self = shift;
        delete $name[$self->()];
    }

}

package main;

my $obj1 = Outside::In->new;
my $obj2 = Outside::In->new;
$obj1->name('Bob');
$obj2->name('Fred');
print $obj1->name, "\n", $obj2->name, "\n";
print $obj1->();

[adrianh]

I was thinking the following, which would lead to undef array elements once $obj->DESTROY gets called. Still, I like it ;-)

The point borisz was making is that with a solution like this  @name always increases in length as objects are created and deleted, which will lead to you running out of memory in the long term.

[fishbot_v2]

You could avoid that problem by assigning the index to the first undef slot, rather than straight incrementing:

my $instance_index = List::Util::first { !defined $_ } @name;

You end up, though, with an O(n) constructor. But perhaps the savings in access make up for this.

[chromatic]

If you really want to save memory, you may want to avoid pinning your inside-out array at the high-water mark. Store a stack of reclaimed indices and push to it in the destructor and shift from it when generating the reference for a new object. Then you can shrink the array if necessary.

(When you ask "Wait, won't it stay at the high-water mark even if there were 1000 elements and are only two now?", I'll sigh and talk about compacting garbage collectors and double-indirection the other flaws in this scheme. Still, it's a fun idea.)

[ikegami]

Why not just convert @name to %name. You can keep using the numerical index. That changes the array into a sparse array. The time cost is quite minimal.

[rvosa]

I know, I was sort of making that point also. Then I started thinking about how to regain the empty slots, but as fishbot_v2 mentions, that's O(N). Conceivably, you might want to take that performance hit of you subsequently do lots (and lots and lots and lots) of lookups...