Moose: ¿Caducan los resultados en caché de los cálculos cuando cambian los valores de los atributos?

Question

En nuestras clases tenemos un patrón donde creamos un atributo para representar un valor calculado . Por razones obvias, queremos almacenar en caché el valor calculado y luego invalidar la caché cuando cambia uno de los valores subyacentes.

Así que actualmente tienen la siguiente:

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

Este método de la mano larga se está volviendo muy tedioso y propenso a errores cuando se calculan los valores dependen de otros valores calculados.

¿Existe alguna manera más inteligente/más simple para que 'bar' controle los atributos, depende de y de que 'foo' sepa quién depende de ello? ¿También cómo puedo evitar establecer la barra a través del acceso de miembro hash ?

Answer 1

Creo que es muy posible que usted está haciendo esto más difícil en sí mismo mediante el uso de un memoization implícita con perezoso, Atributos cuando uno podía hacer lo que el memoization explícita su todo el programa más transparente

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 
} 

Sede de Memoize de información y control de la caché interna CPAN, también recordar que un memoized la función no puede depender del estado del objeto. Por lo tanto, los argumentos se deben pasar explícitamente.

Answer 2

Si lo entiendo correctamente, puede usar triggers para borrar los atributos cuando uno está configurado. He aquí un ejemplo:

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

Por lo tanto, cualquier escritura a través de foo$obj->foo($newvalue) causarán bar que desea borrar, y se recrea en la siguiente acceso.

Answer 3

¿Funcionaría?

#!/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'); 

Salida:

$ perl test.pl 
update b 
update c 

Answer 4

No he hecho ningún hurgamiento en internos de Moose y el protocolo meta objeto, pero creo que este es un buen momento para hacerlo.

desea modificar la generación de código para que cuando se especifica un atributo como

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

la fase de generación de código crea código para los foo y bar atributos según lo especificado anteriormente.

Cómo hacer esto es un ejercicio dejado al lector. Si tuviera una pista, trataría de comenzar. Lamentablemente, todo lo que puedo aconsejarte es "Este es un trabajo para el MOP".