Well, no. In both cases, you're fetching a scalar. In the second case, it's a reference to an array. I tried this expression: "($proc->{'/var'})[0]", and it's still getting a scalar, probably because that's all you ever get out of a hash.

To do what you want to do, you're going to have to explicitly tell the object what you want. Here are some ideas:

• Have two separate classes, one that returns an array ref, and one that returns scalars.
• Use some flag in the key that's fetched. For example, "$proc->{'/var'}" is the scalar and "$proc->{'/var/'}" is the array ref. You have to be careful that the flag is not something that could exist in a real filename. All that comes to my mind is "\000" and the slash.
• An ugly toggle before each call.

By the way, what you're doing reminds me of Path::Class, though it's not exactly the same thing.

Update: Another thought for you: ditch the hash interface completely. Then you can say "$proc->get_x('/var')" and "$proc->get_y('/var')" and anything else you want.

Even if you can figure out how to get the behavior you want (which, IMHO, is counter-intuitive) using a tied interface is still going to limit you to the point where you will probably eventually turn it into an object interface anyway. That being said, it sounds like you are reinventing Path::Class, so you might want to take a look at that...

use Path::Class qw( dir file );
my $root = dir( '/' );

my $spool = $root->subdir( 'var', 'spool' );

my $line = ($spool->slurp)[0];
my @names = $spool->children;
[download]

use strict;
use warnings;
use Tie_hash ;
use Tie_array ;

  my %hash;
  my @arr ;
  tie %hash, 'Tie_hash' ;
  tie @arr,  'Tie_array' ;
  $hash{'key'} = \@arr ;
  print $hash{'key'}->[0] ;
  untie %hash;
  untie @arr ;

  package Tie_Array;

    use strict;
    use warnings;

    sub TIEARRAY {
       my $obj = [ "hi" ] ;
       return bless $obj, shift ;
    }

    sub FETCH {
      my ( $self, $key) = @_ ;
      return $self->[$key] ;
    }
    sub STORE {}
    sub DESTROY {}

   package Tie_hash;

    use strict;
    use warnings;

    sub TIEHASH {
      return bless {}, shift ;
    }

    sub FETCH {
      my ( $self, $key) = @_ ;
      return $self->{$key} ;
    }

    sub STORE {
      my ( $self, $key, $val ) = @_ ;
      $self->{$key} = $val ;
    }

    sub DESTROY {    }
[download]

You can probably use overload to overload the use of your objects(!) as arrayrefs and hashrefs. See the cookbook section on "Two-face references" for an example.

However, your (whole) array context will need to look like this:

@names = @{$root->{'var'}->{'spool'}};   # List of files/dirs
[download]

(Which to my mind is a plus; having a hash element lookup return a list is at best just too surprising and at worst downright abuse of syntax. YMMV.)

BUGS
* Doesn't work from inside a tie-handler.

Consider this:

   %fs = (
     dir1 => [ 'file1','file2','file3' ],
     dir2 => [ 'file4','file5','file6' ],
   ); 

   $contents = $fs{dir1};
   $file     = $fd{dir1}[0];
[download]

I would expect $contents to contain an array-ref, and $file to contain a scalar string. If I wanted an array returned instead, I would write:

   @contents = @{$fs{dir1}};
[download]

Clint