Don't do that. Don't mix $hashvar with $hashref.

Also don't call subs with a leading '&', it might have unexpected behaviour.

Update: Here is a small script that does what you want, by constructing a new copy of the data structure instead of deleting items:

use strict;
use warnings;
use Data::Dumper;
use Scalar::Util qw(reftype);
my $hashvar = {
               emp => {},
               hemp => {
                        splay => {},
                        hay   => {
                                  go => 1,
                                  ho => {},
                                  },
                        tay   => [],
                        may   => [ 'way' ],
                       },
               };

sub clean {
    my $ref = shift;
    return $ref unless ref $ref;

    if (reftype($ref) eq 'HASH'){
        my %result;
        for (keys %$ref){
            my $tmp = clean($ref->{$_});
            $result{$_} = $tmp if (defined $tmp);
        }
        if (keys %result){
            return \%result;
        } else {
            return;
        }
    }
    elsif (reftype($ref) eq 'ARRAY'){
        return @$ref ? $ref : undef;
    }

}

print Dumper($hashvar, clean($hashvar));
__END__
$VAR1 = {
          'hemp' => {
                      'may' => [
                                 'way'
                               ],
                      'tay' => [],
                      'hay' => {
                                 'ho' => {},
                                 'go' => 1
                               },
                      'splay' => {}
                    },
          'emp' => {}
        };
$VAR2 = {
          'hemp' => {
                      'may' => $VAR1->{'hemp'}{'may'},
                      'hay' => {
                                 'go' => 1
                               }
                    }
        };
[download]

I'm too tired to tell if it really works, so check it yourself ;-)

Thanks for the tips. Fixed it now. And don't worry, I always use () with & so as not to get strange behavior. Just like being able to quickly distinguish between my routines and perl's.

And don't worry, I always use () with & so as not to get strange behavior.

& also disables prototypes.

use strict;
use warnings;

sub my_splice(\@$;$@) {
   my ($array, $start, $length, @insert) = @_;
   return splice(@$array, $start, $length, @insert);
}

{
   my @array = qw( a b c );
   splice(@array, 1, 1, qw( d e ));
   print(@array, "\n");   # adec
}

{
   my @array = qw( a b c );
   my_splice(@array, 1, 1, qw( d e ));
   print(@array, "\n");   # adec
}

{
   my @array = qw( a b c );
   &my_splice(@array, 1, 1, qw( d e ));
   print(@array, "\n");  # Can't use string ("a") as an ARRAY ref whil
+e "strict refs" in use at !.pl line 6.
}
[download]

Now, you could argue that prototypes should be avoided, but they are used by many modules.

but $hashVar is global. Why should HashClean recreate it? If you want a new instance of $hashVar every time you enter HashClean then $hashVar needs to be local to HashClean.

It seems that what you are trying to do is recursively traverse a mixed hash and array structure and clean it up. Maybe the following will help:

use strict;
use warnings;

sub clean {
    my $ref = shift;
    
    if ('HASH' eq ref $ref) {
        clean ($ref->{$_}), $ref->{$_} = undef for keys %$ref;
    } elsif ('ARRAY' eq ref $ref) {
        clean ($_), $_ = undef for @$ref;
    }
}


my $hashvar = {
    emp => {},
    hemp =>
        {splay => {}, hay => {go => 1, ho => {},}, tay => [], may => [
+'way'],},
        };

clean ($hashvar);
$hashvar = undef;
[download]

Update: rereading the OP I see that deleting the whole structure is not quite what you want, but the code above should still be a good starting point for getting to where you want to go. In fact the following may just do the trick:

use strict;
use warnings;
use Data::Dump::Streamer;

sub clean {
    my $ref = $_[0];
    
    if ('HASH' eq ref $ref) {
        clean ($ref->{$_}) and delete $ref->{$_} for keys %$ref;
        return ! keys %$ref;
    } elsif ('ARRAY' eq ref $ref) {
        clean ($ref->[$_]) and delete $ref->[$_] for reverse 0 .. $#$r
+ef;
        return ! @$ref;
    } else {
        return ! defined $ref;
    }
}


my $hashvar = {
    emp => {},
    hemp =>
        {splay => {}, hay => {go => 1, ho => {},}, tay => [], may => [
+'way'],},
        };

clean ($hashvar);
Dump ($hashvar);
[download]

prints:

$HASH1 = { hemp => {
           hay => { go => 1 },
           may => [ 'way' ]
         } };
[download]

Tip for the future - show what you expect as well as what you get.

Don't you think it cleans too much? ;-)

cosmicperl wants to delete pairs from hashes where the values are empty hash or array refs. After your sub runs, $hashvar looks like this:

$hashvar = {
          'hemp' => undef,
          'emp' => undef
        };
[download]

No need for recursion to achieve that, perl's garbage collector does the rest when you just delete the hash values ;-)

I noticed that that was not what OP was after on re-reading the node (cf my update). My initial assumption was that OP needed to forcibly delete each node in the structure to get around leaks due to circular references or some such.

---

Perl is environmentally friendly - it saves trees

Thanks for your update. Looks a lot neater than my code (which did work when I sorted out the variable names). And yes I did want all the info, just not the empty hashes and arrays. I'll make sure to post what output I want in the future.

Lyle