I'm not at all sure this is the kind of solution you want, (and I'm not entirely certain it even works like I think it does) but it was a lot of fun to tinker with it. :-)

use Data::Dumper;

# Trying to guarantee this:
#$self->{db}->{offer}->{product_id}->{name}

# We start with a fully formed hashref
$self->{db}->{offer}->{product_id}->{name} = 1;
# and undef somewhere in the middle
undef $self->{db};

# Show the structure just to prove it is too short
print Dumper $self;

my $Last = $self;
for (['db',{}], ['offer',{}], ['product_id',&func], ['name',42]){
  defined $Last->{$_->[0]} or $Last->{$_->[0]} = $_->[1];
  $Last = $Last->{$_->[0]};
}

print Dumper $self;

# func() is the default for key 'product_id' above
sub func{
  {}
}
[download]

$VAR1 = {
          'db' => undef
        };
$VAR1 = {
          'db' => {
                    'offer' => {
                                 'product_id' => {
                                                   'name' => 42
                                                 }
                               }
                  }
        };
[download]

Russ
Brainbench 'Most Valuable Professional' for Perl

package TableMap::Undef;
use strict;

use overload
  "0+" => sub { return undef },
  "bool" = sub { return undef };

sub new{
  my $a={};
  my $x=shift;
  bltess ($a,ref($x)||$x);
  tie(%$a,"TableMap::Undef::TIE");
  return $a;
};

sub AUTOLOAD { return new TableMap::Undef; };

sub DESTROY {};

package TableMap::Undef::TIE;
use strict;

sub TIEHASH {
  my $a={};
  my $x=shift;
  bless ($a,ref($x)||$x);
  return $x;
};

sub FETCH { return new TableMap::Undef; };
[download]

my $x=$s->{db} && $LAST->{users} && $LAST->{$user_id_1} && $LAST->limi
+ts && $LAST->{$user_id_2};
[download]

The following seems to have worked, but for calling on methods, you're probably still stuck (i didn't try, though, so it might work too). Just an example:

my %foo = ( 'bar' => {'baz' => 1} );
print $foo{'baz'}->{'bar'} || 'oops';
[download]

which prints 'oops' because there is no 'bar' in %foo.

Update I misunderstood the question I think, but I tested this below and it still followed the same principle:

my %foo = ( 'bar' => undef );
print $foo{'bar'}->{'baz'} || "oops";
[download]

No warnings under -w or use strict.

local $_ = "0A72656B636148206C72655020726568746F6E41207473754A";
while(s/..$//) { print chr(hex($&)) }
[download]

I got error, not a simple warning, and that's the problem... "Cannot use an undefined value as a hash reference..."

I maybe barking up the wrong tree, but I think I got your error. It took a bit of rooting around. Normally if the scalar is just a normal hash it should autovivify. Here is an autovivification example:

my $foo = { };
$foo->{a}->{b}->{c}->{d} = 1;
use Data::Dumper;
print Data::Dumper->Dump([$foo],['foo']);
[download]

Results:

$foo = {
         'a' => {
                  'b' => {
                           'c' => {
                                    'd' => 1
                                  }
                         }
                }
       };
[download]

All those keys were undef, but now they were created just by asking for them.

I got your error only when I tried to turn an undef into a hash reference explicitly:print %{$foo->{a}->{d}} So maybe making it into a two step process:

my $bar = $foo->{a}->{d};
print %$bar if $bar;
[download]

that might take care of your errors. If I totally missed your problem, sorry.

I often have the same problem with objetcs, stuff like: $elt->first_child->text in an XML tree, which crashes if $elt has no first child. In that case I would like to get just undef, but I still want to be able to test $elt->first_child and have it return a false value when there is no first_child.

As a good monk the nicest solution would be to bless something false!

A false value lessed into the appropriate object class would work just fine.

Of course you can't do that! Traces of Larry's religious faith I guess...

So the next solution I see is to create a new pragma, something like use default_undef_methods which would just default methods on undef objects to undef. I'll get to it as soon as I've got a minute!

Would that solve your problem?