These interpolate:

• "$var"
• qq{$var}

These do not:

• '$var'
• q{$var}

TL;DR: if you want interpolation, don't use single quotes!

OK, I see what you're asking. You want delayed evaluation - I'll update with a solution to that momentarily!

Update: OK, how about this...

use v5.10;
use strict;
use warnings;

sub delayed (&) {
    package delayed;
    use overload q[""] => sub { $_[0]->() }, fallback => 1;
    bless shift;
}

my $string = delayed {"Look $::person, no $::thing!"};

$::person = "Ma";
$::thing  = "stringy eval";

say $string;
[download]

Update II (about a week later): I've released String::Interpolate::Delayed using some of the ideas explored in this thread.

This is really cool! I think i'll put it on the wall in my office - to remember. Best regards, Karl

P.S.: I just bothered myself about this with eval and function interpolation :-(

«The Crux of the Biscuit is the Apostrophe»

For what it's worth, it does also work with lexical variables, but you need to declare them up-front...

use v5.10;
use strict;
use warnings;

sub delayed (&) {
    package delayed;
    use overload q[""] => sub { $_[0]->() }, fallback => 1;
    bless shift;
}

my ($person, $thing);
my $string = delayed {"Look $person, no $thing!"};

$person = "Ma";
$thing  = "stringy eval";

say $string;
[download]

Here's a version that eliminates the need to declare variables up-front, but does the interpolation manually using s///eg. It's pretty dodgy, and I wouldn't put it anywhere near production code, but it's quite cute as an example...

use v5.10;
use strict;
use warnings;

use PerlX::QuoteOperator delayed => {
    -emulate => 'q',
    -with    => sub ($) {
        package delayed;
        my $str = shift;
        use PadWalker;
        use overload q[""] => sub { $_[0]->() }, fallback => 1;
        my $get = sub {
            my $var = shift;
            my $my = PadWalker::peek_my(3);
            return $my->{$var} if exists $my->{$var};
            my $our = PadWalker::peek_our(3);
            return $our->{$var} if exists $our->{$var};
            die "No such variable: $var\n";
        };
        bless sub {
            my $_ = $str;
            s/(\$\w+)/${$get->($1)}/eg;
            s/(\@\w+)/join $", @{$get->($1)}/eg;
            return $_;
        };
    },
};

my $string = delayed "Look $person, no @thing!";
my $person = "Ma";
my @thing  = qw( stringy eval );

say $string;
[download]

It's cute, but the code that does the interpolation is pretty dodgy.

package Cow { use Moo; has name => (is => 'lazy', default => sub { 'Mooington' }) } say Cow->new->name

Correction, what is it that you think it is supposed to do? How is that different from what it does

... A cleaner solution?

String::Interpolate/ String::Interpolate::RE , String::Defer, Interpolation, Template,Text::Xslate...

#!perl
use strict;
use warnings;
$|++;
my $first;
my @sec;

print &compose, "\n";
$first = 'UNO';
print &compose,"\n";
push @sec, '1','2';
print &compose,"\n";
$sec[5] = 'sixt';
print &compose,"\n";
undef $first ;  @sec = ();
print &compose,"\n";



sub compose {
  my $it = 'First is '.
            ($first ? $first : 'not yet defined ').
            ' and the list is '.
            (@sec ? '('.(join ' ',map {$_||'UNDEFINED'}@sec ).')': ' e
+mpty');
  return $it;

}
__OUTPUT__
First is not yet defined  and the list is  empty
First is UNO and the list is  empty
First is UNO and the list is (1 2)
First is UNO and the list is (1 2 UNDEFINED UNDEFINED UNDEFINED sixt)
First is not yet defined  and the list is  empty
[download]