It is very often useful to prevent people from accidentally violating encapsulation. It is usually a mistake to try to prevent people from intentionally violating encapsulation.

Caching to a global variable is very often extremely handy when writing unit tests. Nobody accidentally modifies a global variables in another package. Nobody on my team even does that intentionally in Production code.

And I've seen lots of really stupid things done to try to work around such attempts to prevent intentional violations of encapsulation. They are usually much worse than the behavior that was trying to be prevented.

Unlike the solution using state the my in an enclosing block allows you to include controlled access to the cache.

{
 my $_cache;
 sub withLongComputation {
  $_cache //= ...;
  ...
 }
 sub clearCache {
  undef $_cache;
 }
}
[download]

Jenda
Enoch was right!
Enjoy the last years of Rome.

An an alternative:

{
   use Scope::Guard;
   my $_cache;
   sub withLongComputation {
      $_cache //= ...;
      ...;
   }
   sub localClearCache {
      my $old = $_cache;
      undef $_cache;
      return guard { $_cache = $old };
   }
}

...;

withLongComputation();
withLongComputation();

{
   my $guard = localClearCache();
   # here, $_cache has been cleared
   
   withLongComputation();
}

# Because $guard has fallen out of scope,
# $_cache has been restored to its old value

withLongComputation();
[download]

use Moops; class Cow :rw { has name => (default => 'Ermintrude') }; say Cow->new->name