Christopher,

Okay, this is a weird one actually.

Basically (as best I can tell) what is happening here is that the anon-class being created in BUILD is going out of scope and so being garbage collected (we actually remove the entire package in the DESTROY call). Then when you call ->meta later on and add a methods to it, it is actually creating a new metaclass for what is now an empty package ("Class::MOP::Class::__ANON__::SERIAL::2") and adding the methods to that. The reason the $chris instance is not able to call the is_fun method is because Perl's built in method caching is still looking at the original Class::MOP::Class::__ANON__::SERIAL::2 package (which was cleared in the DESTROY) and not at the newly created version of Class::MOP::Class::__ANON__::SERIAL::2.

If you replace the BUILD code with this:

    my $meta = $self->meta->create_anon_class(
        superclasses => [__PACKAGE__],
        methods      => $methods,
    );
    print $meta;
    $meta->rebless_instance($self);

It will print something like:

    Moose::Meta::Class=HASH(0x18ff694)

And then replace the test code  with this:

    my $meta = $chris->meta;
$meta->add_method( "is_fun", sub { print $_[0]->name . " is fun"; } );

    print $meta->get_method_list;
    print $meta->superclasses;
print Class::MOP::Class::__ANON__::SERIAL::2->can('is_fun') ? 'true' : 'false';
    print $chris->can('is_fun') ? 'true' : 'false';
    print $meta;
    print $meta->name;
    print $chris->dump;

    $chris->is_fun; # FAIL!

You get the following:

    is_fun

    true
    false
    Moose::Meta::Class=HASH(0x18ff778)
    Class::MOP::Class::__ANON__::SERIAL::2
    $VAR1 = bless( {
                 'name' => 'Chris',
                 'occupation' => 'Regular Programmer'
               }, 'Class::MOP::Class::__ANON__::SERIAL::2' );
Can't locate object method "is_fun" via package "Class::MOP::Class::__ANON__::SERIAL::2" at foo.pl line 107.

The first line is the method_list, so we know that add_method succeeded. The second line, which is empty, is the superclasses. It should be 'person_2', but it is nothing, which indicates that this is a new version of the Class::MOP::Class::__ANON__::SERIAL::2 package. The third line shows that Class::MOP::Class::__ANON__::SERIAL::2 does indeed have the methods, but as the forth line indicates, the version of the package that $chris was blessed into disagrees. The 5th line shows that it is indeed a different metaclass (see the output of "print $meta" from the BUILD). The 6th line shows that the $meta is indeed connected to the Class::MOP::Class::__ANON__::SERIAL::2 package though, and the 7th line confirms that $chris is also blessed into it too.

Is this a bug? I am not sure, it seems that everything is doing what is expected of it, just that in this case that "correct" behavior is producing surprising results. While I normally all for minimizing surprises, this case is a little out on the edge already. If you simply do this in your BUILD method:

    my $meta = $self->meta->create_anon_class(
        superclasses => [__PACKAGE__],
        methods      => $methods,
    );
    $meta->rebless_instance($self);
    $meta->add_method('meta' => sub { $meta });

Everything just works as expected, since the $meta is now closed over and therefore is not garbage collected. I would not want this to be the default behavior though since this would break the garbage collection of the anon-classes. We have a special case when you create an instance using an anon class that will stash the $meta to assure it won't go out of scope until the instance itself goes out of scope. Perhaps the best solution is to do the same with rebless_instance as well. I am going to look into it right now.

- Stevan


On Mar 27, 2008, at 11:39 PM, Christopher Brown wrote:
Stevan,

Thanks for the quick reply.  Please find a test case that fails.

System: Linux 2.6.20-2931.fc7 #1 SMP Mon Aug 13 10:12:37 EDT 2007 i686 i686 i386 GNU/Linux
Perl: v5.10.0 built for i686-linux-thread-multi-64int-ld

I think that what is most interesting is that the meta->add_method does not report that it is failing, so I suspect that the method is installed somewhere, but I don't know where or how to find it.

I think that the ability to create instance based attribute is powerful and common and useful in all sorts of situation. If I could have a vote I would suggest that it be easier to create and instance class. The create_anon_class()->rebless( $self ) is not the prettiest syntax. I think that it would be useful to have a standard mechanism to accomplish this.

$self->make_instance_class;
$self->meta->make_instance_class;

Or something like that.

( I have been taken notes as I learn Moose over the past several weeks. If you would like me to share my thoughts, I would be happy to send them to you privately or the list. In no way, should they be taken as harsh criticism. I still think that Moose is the best thing to happen to Perl in a long time. )

Best Wishes,

Chris



__TEST CASE:__

use feature 'say';

# PACKAGE: person_1
#   simple object with two attributes
package person_1;
use Moose;

    has name => (
        is      => 'ro'     ,
        isa     => 'Str'    ,
        required=> 1
    );

    has occupation => (
        is      => 'rw'     ,
        isa     => 'Str'    ,
        required=> 0        ,
    );


# PACKAGE: person_2
#   same as person_1 except it also has a BUILD method that
#   dynamically installs a method 'is_cool' based on occupation
#   type.  ( I know this can be a lazy attribute.  This is just
#   for illustration purposes.  The lazy attribute doesn't work
#   when you want instance based methods though. )
package person_2;
use Moose;

    has name => (
        is      => 'ro'     ,
        isa     => 'Str'    ,
        required=> 1
    );

    has occupation => (
        is      => 'rw'     ,
        isa     => 'Str'    ,
        required=> 0        ,
    );

sub BUILD {

    my $self = shift;

    my $methods = {};

    if ( $self->occupation eq 'Moose Programmer' ) {

        $methods->{is_cool} =
            sub {  say $_[0]->name . " is really cool."; } ;

    } else {

        $methods->{is_cool} =
            sub { say $_[0]->name . " is only kinda cool.\n" } ;

    }

    $self->meta->create_anon_class(
                   superclasses => [__PACKAGE__],
                   methods      => $methods,
    )->rebless_instance($self);

}

# ---------------------------------------------------------
# PACKAGE: main
#
package main;
my $steve =  person_1->new( {
    name        => 'Stevan'             ,
    occupation  => 'Moose Programmer'   ,
} );


my $chris = person_2->new( {
    name        => 'Chris'              ,
    occupation  => 'Regular Programmer' ,
} );


# Let's now add a method to Steve
$steve->meta->add_method( "is_fun", sub { say $_[1]->name . " is fun"; } );
$steve->is_fun;  # Stevan is fun.

# Let's try the same thing with Chris. Remember Chris has been reblessed $chris->meta->add_method( "is_fun", sub { say $_[0]->name . " is fun"; } );
$chris->is_fun;  # FAIL!

# Can't locate object method "is_fun" via package "Class::MOP::Class::__ANON__::SERIAL::2" (perhaps you forgot to load "Class::MOP::Class::__ANON__::SERIAL::2"?) at test.pl line 90.



On Thu, Mar 27, 2008 at 6:47 PM, Stevan Little <[EMAIL PROTECTED]> wrote:
Christopher,

I am not sure I am understanding the error you are describing. Could you write up a small failing test for me?

Thanks,

- Stevan


On Mar 27, 2008, at 3:09 PM, Christopher Brown wrote:
Paul and Stevan,

Sorry for the late reply.  Thanks for both answers.  Stevan, I am rely
impressed with the rapidity of which you and the other Moose members
respond. I am also impressed with you presenting a working prototype of my problem in as little time and code as you did. It is really a testament to
Moose's power.

In the end, I went with the solution that Paul offered.  That is, *
create_anon_class()->rebless_instance*. And, I have used this recipe a half-dozen or times since. It is really powerful technique for installing instance methods. I did run into a snag with reblessing instances. It seems that I cannot access the meta object after reblessing. I am not so
sure why I have the following work on the reblessed object:

$self->meta->add_method( 'test', sub { say "Hello World" } ); # $self
is the reblessed self.

Interestingly enough, the method does not produce an error.

As I am discovering with Moose, there is probably a real simple and elegant
solutions of which has eluded me.  As always, your help is greatly
appreciated.

Best,

Chris






On Thu, Mar 20, 2008 at 8:22 AM, Paul Driver <[EMAIL PROTECTED]>
wrote:

Chris,

If you want to add generated methods to the class, it's
__PACKAGE__->meta->add_method(foobar => sub { print "Foo, bar! \n" }); I don't think you want to do this in BUILD though - just at class compile time. I do this a lot when I have a bunch of similar methods and don't want
to repeat myself.

If you want to add methods to a particular instance ONLY, the thing to do
is to create an anonymous subclass and rebless your instance to that
subclass, and add the methods to the subclass.

Some example code - at BUILD time, add a method named $word that does say
$word for every word passed into the constructor.

---

use feature q(say);
package Speaker;
use Moose;

has words => (
      is => 'ro',
      isa => 'ArrayRef[Str]',
      predicate => 'has_words',
);

# All Speakers know how to say bar
sub bar {
      say 'bar';
}

sub BUILD {
      my ($self, $args) = @_;
      if ($self->has_words) {
              my %methods = map {
                      my $word = $_;
                      ($word => sub { say $word})
              } @{$self->words};

              $self->meta->create_anon_class(
                      superclasses => [__PACKAGE__],
                      methods      => \%methods,
              )->rebless_instance($self);
      }
}

package main;
my $a = Speaker->new;
my $b = Speaker->new(words => [qw(baz qux)]);
$a->bar; # => "Bar"
$b->bar; # => "Bar"
$b->qux; # => "Qux"
say "A" if $a->isa('Speaker'); # => "A"
say "B" if $b->isa('Speaker'); # => "B"
$a->qux; # Can't locate method "qux" via class "Speaker"

----


On Mar 19, 2008, at 4:22 PM, Christopher Brown wrote:

 Dave,

Sorry for taking so long to thank you for your reply.  Thanks.  On
further
t, it was a silly question, using a plain old method is obviously the
solution.

I do have follow-up questions, though. Suppose I want to generate those plain old methods dynamically. Is there a simple, moose way to do this
in
the BUILD subroutine.   On e way to accomplish this is to assign an
anonymous subroutine to a glob.  Like this:

package My::App;

use Moose;
has name => ( is => 'rw', isa=>'Str' );

sub BUILD {
      **__PACKAGE__::method = sub { print "hello world\n"; } ;*
}

package main;
my $app = My::App->new( { name => 'Moose' } );
$app->method;


But I don't want to do that.  I want to do it the Moose way.

I can hear you ask, but why would you want to do that? Well suppose, I
create an object that wraps a query.  If I can iterate over the record
set I
can replace the data slot with the new record and still named methods
that
act as accessors to the record.  This beats the snot out of trying to
instanciate a row object for each record.

Thanks in Advance,

Chris





On Wed, Mar 12, 2008 at 2:41 PM, Dave Rolsky <[EMAIL PROTECTED]> wrote:

 On Wed, 12 Mar 2008, Christopher Brown wrote:

 Despite the 'lazy' evaluation, it appears as if the attribute value
is

being

cached instead of being re-evaluated when the accessor is being
called.


Lazy just means "don't generate the attribute from the default sub
until
the _first_ time it is requested". It's still cached.

If you want to return a different value each time then you just want a
plain old method, not an attribute.


-dave

/*==========================
VegGuide.Org
Your guide to all that's veg
==========================*/






Reply via email to