Moose：属性值更改时缓存的计算结果会过期吗？

Question

在我们的类中，我们有一个模式，我们创建一个属性来表示 计算值。出于显而易见的原因，我们想要缓存计算值 然后当基础值之一发生变化时使缓存失效。

所以我们目前有这样的情况：

package FooBar;
use Moose;

has 'foo' => (
        accessor => {
            'foo' => sub {
                my $self = shift;
                if (@_ > 0) {
                    # writer
                    $self->{foo} = $_[0];

      # reset fields that are dependant on me
      $self->{bar} = undef;
                }
                # reader part;
                return $self->{foo};
            }
        }
    );

has 'bar' => (
        accessor => {
            'bar' => sub {
                my $self = shift;
                if (@_ > 0) {
                    # writer
                    $self->{bar} = $_[0];
                }
                # reader part;
                $self->{bar} = calculate_bar($self->foo, $self->baz) 
                        if (not defined($self->{bar}));
                return $self->{bar};
            }
        }
    );

sub calculate_bar { ... }

这种长手方法在计算值时变得非常乏味且容易出错 取决于其他计算值。

是否有更智能/更简单的方法让“bar”监控它所依赖的属性 与让“foo”知道谁依赖它？另外我怎样才能避免通过哈希设置栏 会员访问？

Answer 1

如果我理解正确，您可以使用 触发器 设置属性后清除属性。这是一个示例：

has 'foo' => (
    is      => 'rw',
    trigger => sub{
        my ($self) = @_;
        $self->clear_bar;
    }
);

has 'bar' => (
    is      => 'rw',
    clearer => 'clear_bar',
    lazy    => 1,
    default => sub{
        my ($self) = @_;
        return calculate_bar( ... );
    }
);

因此，任何通过 $obj->foo($newvalue) 对 foo 的写入都会导致 bar 被清除，并且下次访问时重新创建。

Answer 2

我认为你很可能通过使用带有惰性的属性隐式记忆来让自己变得更加困难，而你可以使记忆显式使你的整个程序更加透明

has [qw/foo bar baz/] => ( isa => 'Value', is => 'rw' );

use Memoize;
memoize('_memoize_this');

sub old_lazy_attr {
    my $self = shift;
    _memoize_this( $self->attr1, $self->attr2, $self->attr3 );
}

sub _memoize_this {
    my @args = @_;
    # complex stuff
    return $result
}

请参阅cpan的Memoize 用于内部缓存的信息和控制，还要记住 Memoized 函数不能依赖于对象的状态。因此参数必须显式传递。

Answer 3

这行得通吗？

#!/usr/bin/perl

package Test;

use Modern::Perl;
use Moose;

has a => (is => 'rw', isa => 'Str', trigger => \&change_a);
has b => (is => 'rw', isa => 'Str', trigger => \&change_b);
has c => (is => 'rw', isa => 'Str');

sub change_a
{
    my $self = shift;
    say 'update b';
    $self->b($self->a . ', bar');
}   

sub change_b
{
    my $self = shift;
    say 'update c';
}   

package main;

my $test = Test->new->a('Foo');

输出：

$ perl test.pl
update b
update c

Answer 4

我还没有对 Moose 内部结构和元对象协议进行任何研究，但我认为现在是这样做的好时机。

您想要修补代码生成，以便在指定属性作为

has 'foo' => ();
has 'bar' => ( 
    depends_on => [qw( foo )],
    lazy => \&calculate_bar,
);

代码生成阶段时，为上面指定的 foo 和 bar 属性创建代码。

如何做到这一点是留给读者的练习。如果我有线索，我会尝试给你一个开始。不幸的是，我只能建议你“这是 MOP 的工作”。