在 Perl 中返回延迟计算的标量

Question

我正在尝试使用绑定标量向我们的代码库添加一些功能。

我们有一个指定返回标量的函数。我认为我可以通过在返回这些标量之前绑定这些标量来向系统添加一些功能，但看起来 FETCH 方法是在返回之前调用的，这会导致返回未绑定的标量。

有什么办法解决这个问题吗？

如果可能的话，我真的想保持子例程的接口（返回标量）完整。

use strict;
use warnings;
main();

sub GetThing{
    my $thing;
    tie $thing, 'mything', @_;
    return $thing;
}

sub main {
    my %m;
    $m{pre} = GetThing('Fred');
    print "1\n";
    print $m{pre};
    print "2\n";
    print $m{pre};
    print "3\n";
}


package mything;
require Tie::Scalar;

my @ISA = qw(Tie::StdScalar);

sub TIESCALAR {
    my $class  = shift;
    bless {
        name    => shift || 'noname',
    }, $class;
}

sub FETCH {
    my $self = shift;
    print "ACCESS ALERT!\n";
    return "    NAME: '$self->{name}'\n";
}

所需的输出：

1
ACCESS ALERT!
    NAME: 'Fred'
2
ACCESS ALERT!
    NAME: 'Fred'
3

我可以通过返回引用并在每次访问时取消引用来获得所需的输出，但这会破坏我们已建立的界面，并使我们的用户更加困惑。

——巴克

Answer 1

正如 DVK 所说，tie 适用于容器，因此对于返回值没有用。

为此，您可以使用重载。示例（未提供所有可能的重载操作；请参阅 http ://perldoc.perl.org/overload.html#Minimal-set-of-overloaded-operations）：

use strict;
use warnings;
main();

sub GetThing{
    my $thing;
    $thing = "mything"->new(@_);
    return $thing;
}

sub main {
    my %m;
    $m{pre} = GetThing('Fred');
    print "1\n";
    print $m{pre};
    print "2\n";
    print $m{pre};
    print "3\n";
}


package mything;
use overload 'fallback' => 1, '""' => 'FETCH';

sub new {
    my $class = shift;
    bless {
        name    => shift || 'noname',
    }, $class;
}

sub FETCH {
    my $self = shift;
    print "ACCESS ALERT!\n";
    return "    NAME: '$self->{name}'\n";
}

Answer 2

正如其他答案中提到的，tie 适用于容器，而不适用于值，因此无法将绑定变量分配给另一个变量并保留绑定属性。

由于分配已结束，您需要将容器传递到 GetThing 例程中。您可以通过参考来执行此操作，如下所示：

use strict;
use warnings;
main();

sub GetThing{
    tie ${$_[1]}, 'mything', $_[0];
}

sub main {
    my %m;
    GetThing('Fred' => \$m{pre});
    print "1\n";
    print $m{pre};
    print "2\n";
    print $m{pre};
    print "3\n";
}


package mything;
require Tie::Scalar;

my @ISA = qw(Tie::StdScalar);

sub TIESCALAR {
    my $class  = shift;
    bless {
        name    => shift || 'noname',
    }, $class;
}

sub FETCH {
    my $self = shift;
    print "ACCESS ALERT!\n";
    return "    NAME: '$self->{name}'\n";
}

这会产生正确的输出。

但是，如果要保留赋值，则需要使用重载，这适用于值（实际上是对象，但它们本身就是值）。如果没有关于您的预期目的的更多详细信息，很难给出完整的答案，但这将满足您规定的要求：

use strict;
use warnings;
main();

sub GetThing{
    return mything->new( shift );
}

sub main {
    my %m;
    $m{pre} = GetThing('Fred');
    print "1\n";
    print $m{pre};
    print "2\n";
    print $m{pre};
    print "3\n";
}


package mything;

sub new {
    my $class  = shift;
    bless {
        name    => shift || 'noname',
    }, $class;
}

use overload '""' => sub {   # '""' means to overload stringification
    my $self = shift;
    print "ACCESS ALERT!\n";
    return "    NAME: '$self->{name}'\n";
};

联系和重载都可能变得复杂，因此如果有任何不清楚的地方，请通读所有文档。

Answer 3

首先，执行您所提议的操作的确切方法在技术上似乎是不可能的：

1. 绑定变量具有绑定 附加到变量本身，而不是其值。

2. 在 Perl 中，子例程的返回值是按值返回的，这意味着您获取传递给 return 的值，访问它（在您的情况下，访问绑定变量并调用FETCH 在此过程中） - 然后复制该值！这意味着调用者得到的是标量 VALUE，而不是标量变量（绑定或未绑定）。

简而言之，您的困惑似乎源于将变量（程序符号表中的位置）和存储在这些变量中的值混合在一起。

---

第二，您不太清楚自己到底想要实现什么，因此很难提出如何实现您想要的目标。但是，假设根据您的描述，您想在子例程返回时调用某些方法（可能向其传递返回值），您可以这样做。

为此，您需要使用人们所说的 方面编程。在 Perl 中，政治上（和技术上）正确的方法是使用 Moose。

然而，你可以DIY它，基本上用包装方法替换原始方法。

Moose 和 DIY 方法的确切机制可以在以下 SO 问题的前两个答案中看到，所以我不会在这里复制/粘贴它们，希望你不介意：

用鸭子类型语言模拟静态类型的各个方面

Answer 4

如果您喜欢冒险，也可以使用 标量： :Defer 模块为标量变量提供了一种通用机制，可以延迟计算一次或每次访问时计算值。