मूस: विशेषता मान बदलते समय गणना के कैश किए गए परिणाम समाप्त हो रहे हैं?

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

मुझे लगता है कि यह भी संभव है कि आप अपने आप पर यह कठिन बना रहे हैं एक गुण, आलसी के साथ अंतर्निहित Memoization का उपयोग करके जब तुम सिर्फ कर सकता है Memoization स्पष्ट करने के बाद अपना पूरे कार्यक्रम को अधिक पारदर्शी

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

तो, $obj->foo($newvalue) के माध्यम से foo के लिए किसी भी लेखन का कारण होगा 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

मैंने मूस आंतरिक और मेटा ऑब्जेक्ट प्रोटोकॉल में चारों ओर कोई पोकिंग नहीं किया है, लेकिन मुझे लगता है कि यह करने का यह अच्छा समय है।

तुम इतनी है कि जब आप के रूप में

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

के रूप में आप ऊपर निर्दिष्ट कोड पीढ़ी चरण foo और bar विशेषताओं के लिए कोड बनाता है एक विशेषता निर्दिष्ट कोड पीढ़ी पैच करने के लिए चाहते हैं।

यह कैसे करें पाठक को एक अभ्यास छोड़ दिया जाता है। अगर मुझे कोई सुराग था, तो मैं आपको एक शुरुआत देने की कोशिश करता था। दुर्भाग्य से, मैं आपको सलाह दे सकता हूं कि "यह एमओपी के लिए एक नौकरी है"।