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 { ... } 

Этот длинный метод рука становится очень утомительным и ошибками при вычислении значения зависит от других расчетных значений.

Есть ли более умный/простой способ для «бара», чтобы контролировать атрибуты, которые он зависит от , и «foo» знает, кто на этом зависит? Также как я могу избежать установки строки через хэш доступ к членству?

Answer 1

Я думаю, что это вполне возможно, что вы делаете это тяжелее на себя, используя атрибуты неявного запоминания с ленивым, когда вы могли бы просто сделать запоминание явно делая ваш вся программа более прозрачной

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 2

Если вы правильно поняли, вы можете использовать triggers, чтобы очистить атрибуты, если они установлены. Вот пример:

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(...); 
    } 
); 

Таким образом, любые записи в foo через $obj->foo($newvalue) заставит bar быть очищены и заново на следующий доступ.

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, как было указано выше.

Как это сделать, это упражнение, оставленное читателю. Если бы у меня была подсказка, я постараюсь дать вам начало. К сожалению, все, что я могу вам посоветовать, это «Это работа для СС».