@array = qw/Kitty Kate/;

%hash = (
    firstname => \$array[0],
    lastname  => \$array[1],
);

$$hash{firstname} = 'Murka';
is($array[0], 'Murka');
[download]

That is close, but not exactly what I want to do.

I did not put enough detail in my starting post.

I have an array of values, the first one of which indicates what sort of data is in the array. I also have a set of arrays that indicate what fieldnames should be associate with the array.

Think of the array as sometimes being name and address, and sometimes name and phone number. I want to read $ARRAY[0] and then decide how the hash will be created. What I tried to do that does not work is this:

@Address=qw(type firstname lastname streetaddress city zip);
@Phone=qw(type name phonenumber);
%Stuff;

sub ReadStuff{
if    ($@_[0]='addr') {%Stuff(@Address)=@_};
elsif ($@_[0]='phone'){%Stuff(@Phone)=@_};
...do something useful...
}


@data=(addr, bob, smith, 1234 main st, anytown, 20500);
&ReadStuff(@data);
@data=(phone, bob, smith, 212-555-1212)
&ReadStuff(@data)
[download]

But, of course, that does not work exactly like that, so I am trying to get close. Skip

But, of course, that does not work exactly like that

It would probably help if you used syntactically valid Perl code. If you did, you might be surprised to find that what you have works fine. Here I've gone through the trouble to port it for you:

#!/usr/bin/perl
use strict;    # safety checks
use warnings;  # useful hints
use Data::Dumper;

# notice the use of 'my' to declare a lexical scope
my @Address=qw(type firstname lastname streetaddress city zip);
my @Phone=qw(type name phonenumber);

sub ReadStuff {
    # instead of using funny global variables, scope the 
    # hash within the subroutine, and return a reference at
    # the end
    my %Stuff;

    # $_[0]       is the first element of the array @_
    # eq          is the string equality test
    # @h{@k} = @v is the syntax for hash slices
    if    ($_[0] eq 'addr')  { @Stuff{@Address} = @_ }
    elsif ($_[0] eq 'phone') { @Stuff{@Phone}   = @_ }

    # return a reference (as mentioned before)
    return \%Stuff;
}


# let's quote our list elements this time
my @data1 = ('addr', 'bob', 'smith', '1234 main st', 'anytown', '20500
+');
my $stuff1 = ReadStuff(@data1);

my @data2 = ('phone', 'bob', 'smith', '212-555-1212');
my $stuff2 = ReadStuff(@data2);

# dump the results from both runs
print Dumper $stuff1;
print Dumper $stuff2;
[download]

Update: while this code does work, it doesn't quite do what your original question asks. That said, what you have here is probably exactly what I would suggest -- that is, keep the data in one place, and a list of keys in the other to tie it together. Using the structures this code creates, you could, for example, do $Stuff1->{$Address[4]} to get the field from $Stuff1 that corresponds to the key at index 4 from @Address. (whew! try saying that 5 times fast!)

Maybe like this (without any error checking):

our @Address=qw(type firstname lastname streetaddress city zip);
our @Phone=qw(type name phonenumber);
our %Types = ( "addr" => \@Address,
               "phone" => \@Phone );
our %Stuff;

sub ReadStuff{
@Stuff{@{$Types{$_[0]}}} = @_;
#...do something useful...
}
[download]

-QM
--
Quantum Mechanics: The dreams stuff is made of

print "His name is $hash[firstname] $hash[lastname]\n;
[download]

print "His name is $hash{firstname} $hash{lastname}\n;
[download]

But anyway, your wish sounds pretty much up the alley of the pseudo hashes, which act like hashes but actually are arrays — and which are considered obsolete. The new interface is use fields, and even though my code still acts the same for perls 5.6.1 and 5.8.0, I do have doubts about its viability for the future.

Currently the hash with the array indices is in the array element with index 0; normal elements start at index 1. So I think it's not unlikely that the index might shift, if this element were to drop away. I really think you shouldn't actually be accessing the elements this way...

Anyway, take this at its face value: a nice experiment, but preferably don't use it in actual production code. BTW I'd really appreciate it if someone more knowledgable on the internals, and future of pseudo-hashes could shed some light on this.

p.s. I'm not actually sure I even call new in the proper way...

#!/usr/local/bin/perl -w
{
    package Record;
    use fields qw(firstname lastname address town zip);
    sub new {
        my $this = shift->fields::new;
        %$this = @_;
        return $this;
    }

}

my Record $data = new Record( firstname => 'Bob',
           lastname  => 'Smith',
           address   => '1234 Main St',
           town      => 'AnyTown',
           zip       => 20500);

use Data::Dumper;
print Dumper $data;

print "His name is $data->{firstname} $data->{lastname}\n";
print "His name is $data->[1] $data->[2]\n";
[download]

perldoc perltie