Re: More efficient return of values from sub

[tlm]

This is a very generic problem, and every solution I can think of is one variant or another of caching. The only issue is to decide how to implement this caching. Memoization gives this task to the routine itself. E.g.:

{
  my %cache;
  sub heavy_lifting {
    my $arg = shift;
    return
      defined $cache{ $arg } ? $cache{ $arg }
                             : $cache{ $arg } = grunt($arg);
}

(BTW, I recently posted a simple example of memoization here.) Or if the routine is an object method, the caching could be done by each instance:

sub heavy_lifting {
  my $self = shift;
  my $arg = shift;
  return defined $self->{ _heavy } ? $self->{ _heavy }
                                   : $self->{ _heavy } = $self->grunt(
+ $arg );
}

Or as dragonchild says, you can let the calling code worry about caching the results. Caching is everywhere, in many guises. It is at the heart of three popular sorting optimization techniques, the Orcish Maneuver, the Schwartzian Transform, and the Guttman-Rosler Transform, for example (although one doesn't usually associate these techniques with caching per se). And of course it is done constantly by your computer's memory hardware, but that's getting away from Perl. Etc., etc. This barely scratches the surface on the uses and strategies for caching. There are entire modules devoted to various forms of caching (e.g. the very useful Cache::FileCache, and of course Memoize).