Ok, Here goes a more complex example, wich shows it in more details:

use strict;
use warnings;
package Foo::Bar;

sub new {
        tie my @arr, 'Foo::Bar';
        return bless \@arr, 'Foo::Bar';
}

sub TIEARRAY {
    my $scalar = "A Scalar";
    return bless \$scalar, 'Foo::Bar';
}

sub FETCH {
    my ($self, $index) = @_;
    print 'FETCH ';
    if ($index == 0) {
        return $self->lalala0;
    } elsif ($index == 1) {
        return $self->lalala1;
    } else {
        return undef;
    }
}

sub STORE {
    my ($self, $index, $value) = @_;
    print 'STORE ';
    if ($index == 0) {
        return $self->lalala0($value);
    } elsif ($index == 1) {
        return $self->lalala1($value);
    } else {
        return undef;
    }
}

sub lalala {
    my $self = shift; 
    if (UNIVERSAL::isa($self,'ARRAY')) { $self = tied(@{$self}) };
    print "Lalala $self\n";
}

sub lalala0 {
    my $self = shift; 
    if (UNIVERSAL::isa($self,'ARRAY')) { $self = tied(@{$self}) };
    print "Lalala0 $self\n";
}

sub lalala1 {
    my $self = shift; 
    if (UNIVERSAL::isa($self,'ARRAY')) { $self = tied(@{$self}) };
    print "Lalala1 $self\n";
}

sub DESTROY {
    my $self = shift;
    if (UNIVERSAL::isa($self,'ARRAY')) {
        print "Destroying the array...\n";
    } else {
        print "Destroying the scalar...\n";
    }
}

package main;

my $a = Foo::Bar->new();
# The object inside is a SCALAR
$a->lalala();
$a->[0] = $a->[1];
$a->[1] = $a->[0];
[download]

UPDATE: Included the DESTROY method, to illustrate...

Thanks, that's cool!

Do I understand correctly that the lowercase methods can either be invoked on the scalar or the array (as both are blessed into the package), and therefore you sometimes have to retrieve the tied scalar from the array (if that happens to be the invocant)?

So, if you use, say, a $a->[0] construct, the STORE method is called on the array reference. STORE then invokes $a->lalala0 on the array, so the lalalao sub needs to retrieve the tied scalar from the invocant array.

Is that sort of how it works?

Exactly.

daniel