Perl: dispatch hashes and shared variables - perl

Question

I have a module with a set of functions implemented as a dispatch hash with a helper function thus:
my $functions = {
'f1' => sub {
my %args = #_;
## process data ...
return $answer;
},
[etc.]
};
sub do_function {
my $fn = shift;
return $functions->{$fn}(#_);
}
This is used by some scripts that process tab-delimited data; the column being examined is converted by the appropriate subroutine. When processing a value in a column, I pass a hash of data to the sub, and it generates a scalar, the new value for the column.
Currently the subs are called thus:
my $new_value = do_function( 'f1', data => $data, errs => $errs );
and the variables in the arguments are all declared as 'my' - my $data, my $errs, etc.. Is it possible to update other values in the arguments that are passed into the subs without having to return them? i.e. instead of having to do this:
... in $functions->{f1}:
my %args = #_;
## process data ...
## alter $args{errs}
$args{errs}->{type_one_error}++;
## ...
return { answer => $answer, errs => $args{errs} };
...
## call the function, get the response, update the errs
my $return_data = do_function( 'f1', data => $data, errs => $errs );
my $new_value = $return_data->{answer};
$errs = $return_data->{errs}; ## this has been altered by sub 'f1'
I could do this:
my $new_value = do_function( 'f1', data => $data, errs => $errs );
## no need to update $errs, it has been magically updated already!

Answer 1

You can pass reference to value and update it inside of subroutine.
For example:
sub update {
my ($ref_to_value) = #_;
$$ref_to_value = "New message";
return "Ok";
}
my $message = "Old message";
my $retval = update(\$message);
print "Return value: '$retval'\nMessage: '$message'\n";
And as far as I can see from your code snippets, $errs is already reference to hash.
So, actually, all you have to do - just comment out line $errs = $return_data->{errs}; and try
If I get your code right, $errs gets updated. And then you should just change your return value to $answer and do:
my $new_value = do_function( 'f1', data => $data, errs => $errs );

Answer 2

first change your definition of do_function to:
sub do_function {
my $fn = shift;
goto &{$functions->{$fn}}
}
that is the proper way to dispatch to a new subroutine. this form of goto replaces the currently executing subroutine with the new coderef, passing #_ unchanged, and removing do_function from the call stack (so caller works right). you probably want some error checking in there too, to make sure that $fn is a valid name.
inside your function, you can simply modify cells of #_ directly, and you do not need to pass anything by reference (since perl already did that for you).
sub add1 {$_[0]++}
my $x = 1;
add1 $x;
say $x; # 2
to support key => value arguments without passing by reference you could write it this way:
in $functions->{f1}:
my %args;
while (#_) {
$args{$_} = /errs/ ? \shift : shift for shift
}
## process data ...
## alter ${$args{errs}}
## ...
HOWEVER since in your case $errs is a hash reference, you don't need to do any extra work. all references are passed by reference automatically. in your existing code, all you have to do is modify a key of $args{errs} (as you are doing right now) and it will modify every reference to that hash.
if you wanted a function local hash, you need to make a copy of the hash*:
my %errs = %{$args{errs}};
where %errs is private, and once you are done, you can push any values you want to make public into $args{errs} with $args{errs}{...} = ...;. but be sure not to replace $args{errs} with the copy (as in $args{errs} = \%errs) since that will break the connection to the caller's error hash. if you want to copy all the new values in, you could use one of:
%{$args{errs}} = %errs; # replace all keys
#{$args{errs}}{keys %errs} = values %errs; # replace keys in %errs
... and $args{errs}{$_} = $errs{$_} for keys %errs; # conditional replace
*or localize some/all of the keys