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?

You still have tied($arr_ref) to get your scalar reference

Indeed I do. Mmmmm, I can work with that. Thanks!

This more or less does the trick:

package TwoFaced;
use strict;
my $instance_counter = 0;
my $instance_array   = [];

sub new {
    my $class = shift;
    my @array;
    tie @array, $class, @_;
    return bless \@array, $class;
}

sub method {
    print "Method call\n";
    return;
}

sub TIEARRAY {
    my ( $class, @args ) = @_; 
    my $self = $instance_counter++;      
    return bless \$self, $class;
}

sub FETCH {
    my ( $self, $i ) = @_;
    return $instance_array->[ $$self ]->[$i];
}

sub STORE {
    my ( $self, $i, $val ) = @_;
    if ( not $val eq 'a' ) {
        $instance_array->[ $$self ]->[$i] = $val;
        return $self;
    }
    else {
        die "Illegal value: $val\n";
    }
}

sub FETCHSIZE {
    my ( $self ) = @_;
    return scalar @{ $instance_array->[ $$self ] };
}

sub DESTROY {
    print "Contents at death:\n";
    print "\t", $_, "\n" for @{ $instance_array->[ $$_[0] ] };
}

package main;
my $t = new TwoFaced;
print "it's an array!\n" if UNIVERSAL::isa($t, 'ARRAY'); # prints "it'
+s an array!";

$t->[0] = 'b';
print ${ tied @$t }, $t->[0]; # prints "0b"
print $t->method;             # prints "Method call"
$t->[0] = 'a';                # dies "Illegal value: a"
# prints "Contents at death: ..." during object destruction
[download]

...except the destructor is called twice. I presume this is for the @array and the tied object respectively?