package TestSequence;
sub define { # set value anywhere in motley hash and
             # return it for conformity with '='
             # parameters: reference, key(s)..., value
             # the recursion simply walks down the list
             # of keys
    my $self = shift;
    my $key = shift
    my $value = shift;
    if ( @_ ) { # need to go lower down the tree
        if (( ref( $self ) eq 'HASH' )
           ||(ref($self) eq 'TestSequence')) {
            defined $self -> { $key }
                or $self -> { $key }{ $value } = undef();
            return define( $self -> { $key }, $value, @_ );
        }
        if ( ref( $self ) eq 'ARRAY' ) {
            defined $self -> [ $key ]
                or $self ->[ $key ] = undef();
            return define( $self -> [ $key ], $value, @_ );
        }
        die 'not a classmember nor a hash nor array reference';
    }
    if ( ref( $self ) eq 'HASH' ) {
        return $self -> {$key} = $value;
    }
    return $self -> [$key] = $value;
}

sub prune { # prune the tree where specified by the key list
    my $self = shift;
    my $key = shift;
    if ( @_ ) {
        if (( ref( $self ) eq 'HASH' )
           ||(ref( $self ) eq 'TestSequence')) {
               return prune( $self -> { $key }, @_ );
        }
        else {
            return prune( $self -> [$key], @_ );
        }
    }
    if (( ref( $self ) eq 'HASH' )
       ||( ref( $self ) eq 'TestSequence' )) {
        return delete $self -> { $key );
    }
    return delete $self -> [$key];
}

sub new { # just to clarify...
    my $self = shift;
    $self = {};
    return bless $self;
}

##</code><code>##

my $sq = TestSequence -> new();
$sq -> define( 'BB', undef() );
for (my $i = 0; $i < 1000000; $i++ ) {
    my %hash;
    # fill the hash, then later...
    $sq -> { BB }[ $i ] = \%hash;
}
# do something useful with $sq, then later...
$sq -> prune( 'BB' );