In refactoring some code, I opted for turning "warn/carp" calls into method calls "$self->carp". This way the objects could act by themselves (using CORE::warn/Carp::carp) or cooperate with others (via a closure).
sub carp { my $self = shift; my $on_warn = $self->on_warn; if ( $on_warn ) { $on_warn->(@_); } else { Carp::carp(@_); } }
It turned out that naming the method the same as a function was a bad idea (at least in the transition to the fully refactored code). The simple application used some simple hierarchies, and when I "fixed" the superclasses as in:
package Parent; sub carp { ... }
I found after some perplexity that in the children, code like that:
package Child; use base qw( Parent ); use Carp qw( carp ); ... $self->carp("message"); ...
emitted strange messages like:
Parent=HASH()message
because $self->carp("message")
resolved to Carp::carp( $self, "message" )
as Carp::carp
had been exported to Child
overriding the method I was expecting to inherit.
That's what we earn because methods are just subs.
then this problem will go away.use Carp qw();