Essentially, what appears within the tie function must have a sigil. That means that tie expects an actual hash, not a hashref. The {...} anonymous hash constructor returns a hashref, which doesn't work. For example:

tie( %hash, 'Class' );
[download]

...is valid, but ...

tie( { anon => 'hash' }, 'Class' );
[download]

...is not valid. However, you can tie the nested portions of nested datastructures like this:

my $href = {};
tie( %{$href}, 'Class' );
[download]

...or even...

my( %hash ) = ( 'this' => {},
             'that' => {} );
tie( %{$hash{'this'}}, 'Class' );
[download]

Also note, definately it is not doing what you expect if you do this:

my( %hash ) = tie( %otherhash, 'Class' );
[download]

...because tie doesn't return the tied hash, it returns the tied object's instance reference. Since you're assigning the object's reference to %hash, you'll stringify the object ref and turn it into a hash key in %hash with undef as the value. So don't do that. In other words, this does work:

my $obj = tie( %hash, 'Class' );
$obj->DESTROY;
[download]

In other words, this does work:

my $obj = tie( %hash, 'Class' );
$obj->DESTROY;
[download]

It works except that you'd never, ever write code to call ->DESTROY because that's only ever called by perl when it is actually destroying something. ->DESTROY doesn't provoke a cleanup - its only something that happens during cleanup.

You are correct, sir.
I was demonstrating that the return value of tie is an object reference that could be treated as such. My choice of DESTROY in the example was to use a method I knew should exist regardless of the class to which the variable is tied, that is common in any old ordinary class, and that people familiar with OO would visually recognize as a method call. But you're absolutely right about letting Perl call DESTROY().




Dave

('a' => 1) is a list, not a hash.
%{{'a' => 1}} is an anonymous hash.

tie(%{{'a' => 1}}, 'class');
seems to work, but it was a simple test.

use strict;
use warnings;
use Tie::IxHash;
use Data::Dumper;

my %big_hash = (
   'part_1' => tie_me_up(first => 1, second => 2, third => 3),
   'part_2' => tie_me_up(foo => 1, bar => 2, baz => 3),
   'part_3' => tie_me_up(oranges => 1, apples => 2, lemons => 3),
);

print Dumper(\%big_hash);

sub tie_me_up
{
    tie my %temp, 'Tie::IxHash';
    %temp = @_;
    return \%temp;
}
[download]

$VAR1 = {
          'part_2' => {
                        'foo' => '1',
                        'bar' => '2',
                        'baz' => '3'
                      },
          'part_3' => {
                        'oranges' => '1',
                        'apples' => '2',
                        'lemons' => '3'
                      },
          'part_1' => {
                        'first' => '1',
                        'second' => '2',
                        'third' => '3'
                      }
        };
[download]

Interesting note, trying things from earlier responses, i tried running this:

use strict;
use warnings;
use Tie::IxHash;
use Data::Dumper;

{
    my $blah = tie( %{{ 'a' => 1 }}, 'Tie::IxHash');

    print Dumper($blah);
}
[download]

$VAR1 = bless( [
                 {},
                 [],
                 [],
                 0
               ], 'Tie::IxHash' );
[download]