Update: Version 2.0

use strict;

package MyTie;

my @TIED;

sub TIEHASH {
    my $type = shift;
    my $index = shift;

    return undef unless $TIED[$index];

    my $self;
    if ($TIED[$index]) {
        $self = $TIED[$index];
    } else {
        $TIED[$index] = $self = {};
        bless $self, ref($type) || $type;
    }

    $self->{HASH} = {};
    @{$self->{HASH}}{@_} = @{$self->{ARRAY}};
    $self->{ISTIED}{HASH} = 1;

    return $self;
}

sub TIEARRAY {
    my $type = shift;
    my $index = shift;

    my $self;
    if ($TIED[$index]) {
        $self = $TIED[$index];
    } else {
        $TIED[$index] = $self = {};
        bless $self, ref($type) || $type;
    }

    $self->{ARRAY} = [ @_ ];
    $self->{ISTIED}{ARRAY} = 1;

    return $self;
}

sub FETCH {
    my $self = shift;
    my $key = shift;

    return undef unless defined $key;

    if ($key =~ /\D/) {
        return undef unless $self->{ISTIED}{HASH};
        return $self->{HASH}{$key};
    } else {
        return undef unless $self->{ISTIED}{ARRAY};
        return $self->{ARRAY}[$key];
    }
}

sub STORE {
    my $self = shift;
    my $key = shift;

    return undef unless defined $key;

    if ($key =~ /\D/) {
        return undef unless $self->{ISTIED}{HASH};
        $self->{HASH}{$key} = shift;
    } else {
        return undef unless $self->{ISTIED}{ARRAY};
        $self->{ARRAY}[$key] = shift;
    }
}

sub FETCHSIZE {
    my $self = shift;

    return $#{$self->{ARRAY}};
}

1;

__END__
[download]

To create a MyTie, I used the following:

#!/usr/local/bin/perl

use strict;
use warnings;

use MyTie;

my $index = 0;

my @blah;
tie @blah, "MyTie", $index, (5, 4, 3, 2, 1);

my %blah;
tie %blah, 'MyTie', $index, qw(zero one two three four);

print "$blah[2]\n";
print "$blah{two}\n";
[download]

1. Have a package global of a list in MyTie.
2. Always construct the array first.
3. Make the first element in the list some $index in that global array.
4. pop that index off before putting it into $self->{ARRAY}.
5. When creating the HASH part, put a index => $index.

------
We are the carpenters and bricklayers of the Information Age.

Don't go borrowing trouble. For programmers, this means Worry only about what you need to implement.

Sounds to me like pseudohashes would be a perfect solution to this problem.

But I wouldn't use them as they're deprcated in 5.8 and will be removed in 5.10.

"The first rule of Perl club is you don't talk about Perl club."

Core module overload allows you to overload dereferencing. If you overload hash dereferencing only, you may have it. Something like this, perhaps:

{
    package TwoFaceRefs;
    use overload '%{}' => \&getByKey;

    my %idx = qw(name 2); # And probably some more :-)

    sub getByKey {
        # Likely faster to return a tied hash,
        # but you get the idea ...
        my $obj = shift;
        return {map{ $_ => $obj->[$idx{$_}] } keys %idx};
    }

    sub dsfmm {
        # Assuming we get an arrayref:
        my $obj = do_stuff_from_my_module();
        bless $obj, "TwoFaceRefs";
        return $obj;
    }
}

my $obj = TwoFaceRefs::dsfmm();
my $name = $obj->[2];
#
# or
#
my $name = $obj->{name};
[download]

Update: Comment and (a little) whitespace added.

Update 2: Oh, unless we make getByKey return a (properly) tied hash, assigning to the fields won't work:
$obj->{name} = "Sidhekin";
The original problem merely stated to access the fields, not setting them, but I just wanted to make it clear that this is one problem overloading (on its own) will not solve. (There is no problem overloading and tying together cannot solve. Well, okay. A few.)

The Sidhekin

use strict;
package FOO;
our($AUTOLOAD);
sub new {
        my $class=shift;
        my $self;
        $self={};   # Sometimes you feel like a hash
        $self=[]    # Sometimes you don't. 
             if (int rand 2 == 0);
        bless $self,$class;
}

sub AUTOLOAD {
        my($self,$value)=@_;
        my($attr)=($AUTOLOAD=~m/::(.*?)$/);
        return if ($attr=~/^[A-Z]+$/);

        if ($attr=~/^[_\d]+$/) {
                print "Called digit accessor\n";
        } else {
                print "Called non-digit accessor\n";
        }
}

package main;
my $t=new FOO;

$t->_45;   # "->45" won't make it through the parser
$t->name;
[download]

my $obj_array = do_stuff_from_my_module();
my $obj_hash = convert_masems_array_to_a_hash($obj_array);
#then the valid code options would be
my $name = $obj_array->[2]; # Assume name is the 3rd element
#
# OR!!!
#
my $name = $obj_hash->{ name };
[download]

Well, in that case I think it's easier to provide two functions, one which returns the array and one which returns the hash.

Another idea would be to provide some global way of configuring the module into either returning hashes or arrays.

-- Hofmator

I'm also looking at possibly tying a hash and an array together ... but that's also not looking good. *shrugs*

Update: Check out my second response...

------
We are the carpenters and bricklayers of the Information Age.

Don't go borrowing trouble. For programmers, this means Worry only about what you need to implement.

Both array assignment and hash assignment cause the RHS to be evaluated in list context. wantarray can't tell the difference between array and hash assignment.

my @arr = get_it();
my %hash = get_it();

sub get_it {
  if (defined wantarray) {
    print wantarray ? 'list' : 'scalar';
  } else {
    print 'void';
  }

  print " context\n";

  return;
}
[download]

This prints "list context" twice.

--
<http://www.dave.org.uk>

"The first rule of Perl club is you don't talk about Perl club."

At the base of it, hashes are lists. wantarray determines between scalars and hashes-or-lists.

------
We are the carpenters and bricklayers of the Information Age.

Don't go borrowing trouble. For programmers, this means Worry only about what you need to implement.

my $name= $obj->('name');
[download]

my @list= $obj->(qw/name address serial zip/);
[download]

I suppose an actual hash could do the same thing with a slice.

—John