# This code has been run through a basic smoke-test.

package My::Error::String;

use overload
    '""' => \&stringify,
    '0+' => \&boolify,
        fallback => 1;

sub new {
    my $class = shift;
    my $error = shift;

    bless \$error, $class;
}

sub stringify {
    my $self = shift;
    return $$self;
}

sub boolify {
    return;
}
[download]

Then, when you want to use it, you'd do something like:

use My::Error::String;

sub func_with_error {
    if ($have_error) {
        return My::Error::String->new( "Have an error somewhere ..." )
+;
    }
}
[download]

Note that if you don't have an error, this code is assuming you will not return an object. (Just want to make clear the reason why boolify always returns false.)

Just off the top of my head, I would do something like this:

package Result;

use overload 'bool' => \&as_bool, '""' => \&stringify;

sub new
{
  if ($_[0] eq __PACKAGE__)
  {
    shift;
  }

  my $self = {
    as_bool => $_[0],
    string  => $_[1],
  };
  bless $self, __PACKAGE__;
  $self;
}

sub as_bool
{
  my $self = shift;
  $self->{as_bool};
}

sub stringify
{
  my $self = shift;
  $self->{string};
}

1;
[download]

Then you can use it like this:

require Result;
sub complex_function {
  # ...
  if ($error_message)
  {
    return Result->new(undef, $error_message);
  }
  return Result->new(1);
}
[download]

With this, the caller wouldn't change much at all:

unless (my $r = complex_function())
{
  print "Error received: $r\n";
}
[download]

Hope that helps. (Completely untested ;->) Also, the way it is now, Result is not a class you can easily derive from ... I leave that as an excersise for other monks ;->