Moose: Abgelaufene Ergebnisse von Berechnungen im Cache, wenn sich Attributwerte ändern?

Question

In unseren Klassen haben wir ein Muster, wo wir ein Attribut erstellen, um einen berechneten Wert darzustellen. Aus offensichtlichen Gründen möchten wir den berechneten Wert zwischen zwischenspeichern und dann den Cache ungültig machen, wenn sich einer der zugrunde liegenden Werte ändert.

So haben wir zur Zeit die:

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

Diese lange Hand-Methode ist immer sehr mühsam und fehleranfällig, wenn Werte berechnet auf anderen berechneten Werten abhängen.

Gibt es eine klügere/einfachere Möglichkeit für 'bar', die Attribute zu überwachen, die davon abhängen, vs 'foo' wissen, wer ist davon abhängig? Wie kann ich auch vermeiden, Bar über Hash Mitglied Zugriff einstellen?

Answer 1

Ich denke, es ist durchaus möglich, dass Sie auf dich selbst diesen härter machen durch eine Attribut implizite memoization mit faul verwenden, wenn Sie nur die memoization explizit machen könnten machen Ihre ganzes Programm transparenter

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 
} 

See cpan die Memoize für Informationen und die Steuerung des internen Cache, auch daran denken, dass ein memoized Funktion kann nicht vom Zustand des Objekts abhängig sein. Daher müssen die Argumente explizit übergeben werden.

Answer 2

Wenn ich Sie richtig verstanden habe, können Sie triggers verwenden, um Attribute zu löschen, wenn eine gesetzt ist. Hier ein Beispiel:

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

Also, alle Schreibvorgänge auf foo über $obj->foo($newvalue) verursacht bar gelöscht werden, und beim nächsten Zugriff neu erstellt.

Answer 3

Würde das funktionieren?

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

Ausgang:

$ perl test.pl 
update b 
update c 

Answer 4

Ich habe in den Moose-Interna und dem Meta-Objekt-Protokoll nicht herumgestochert, aber ich denke, das ist ein guter Zeitpunkt, es zu tun.

Sie möchten die Codegenerierung patchen, so dass, wenn Sie ein Attribut als

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

der Phasencodegenerierung angeben erzeugt Code für die foo und bar Attribute wie Sie oben angegeben.

Wie dies zu tun ist eine Übung für den Leser. Wenn ich eine Ahnung hätte, würde ich versuchen, dir einen Anfang zu geben. Leider kann ich Ihnen nur empfehlen: "Dies ist ein Job für das MOP".