Ah Contextual::Return. I've had some interesting results with it in the past, as well as interesting feedback. It seems I went with Want in that case, though I don't have the foggiest clue what I was working on back then. But what do you think either module would get me, versus the basic approach (below)? I'm not sure how that would actually get me an overloaded result as you (I think) suggest, just a return based on different contexts?

        wantarray ? (_special_to_string($arg), $arg)
                  :  _special_to_string($arg);
[download]

Remembering both string and special are both scalars (strings, in fact), how (in high level terms at least) would you tackle this with either C::R or Want?

OK I think I misread / elided some of your OP where you said that both values were strings. In that case C::R probably isn't what you're wanting, unless you wanted to return a magical hashref that had both values that stringified to the string bit (disclaimer I've never really used C::R in anger, just aware of it's presence).

use Contextual::Return;

sub blahblah {
  ## ...
  return (
    STR { _special_to_string( $retval ); }
    HASHREF { +{ special => $retval, string => _special_to_string( $re
+tval ) }; }
  );
}

my $foo = blahblah( @some_args );
say "Foo: $foo";
say "Special from foo: ", $foo->{special};
[download]

There's also Object::Result which is a variation on the theme which is aimed at making it "easier" to return an instance with arbitrary methods; I believe it's mentioned/recommended in the updated PBP course, for whatever that's worth.

After thinking over it a bit more I think I'd lean towards just a hashref, maybe Object::Result; and eschew overloading or other magic. If you name the slot with the plain string well you probably win in clarity what you lose in extra typing (say $result->{message}).

Then again I drove 900+ miles this weekend so take that with a large grain of salt.</handwaving>

The cake is a lie.
The cake is a lie.
The cake is a lie.

$obj->string / $obj->special was what I originally went with, and I may still do. I came here hoping for some hints on possibly simplifying it, though, as string is the 95% case. I rate the odds of the programmer forgetting to write my $special = $obj->method->special at least as high as forgetting to write my (undef, $special) = $obj->method</p>. Since both are strings (and strings are indeed the best option), both would silently use the "wrong" value if forgotten. <c>wantarray might actually be slightly superior, in that the two calling options look very different and errors would hence be easy to spot:

my $string = $obj->method;              # vs. my $string  = $obj->meth
+od->string;
my (undef, $special) = $obj->method;    # vs. my $special = $obj->meth
+od->special;
[download]

I'll give it some more thought though. Thanks for the input.