More MOP related questions :)
In the p5 MetaModel, you can do the following:
$obj->meta->add_method('foo' =>
Perl6::Method->create_instance_method(sub { ... }));
$obj->meta->add_method('foo' => Perl6::Method->create_class_method(sub
{ ... }));
$obj->meta->add_method('foo' => Perl6::Method->create_submethod(sub {
... }));
$obj->meta->add_method('foo' =>
Perl6::Method->create_private_method(sub { ... }));
<quick aside for clarity>
The Perl6::Method package is really just a closure generator. It takes
a chunk of code (a sub {} ref) and wraps it with the appropriate
wrapper based on the type of "method-thing" you request. It currently
handles instance methods, class methods, private methods and
submethods. The details of this are not really relevant to this
discussion though, I just wanted to answer what I saw as an inevitable
question.
</quick aside for clarity>
Now I realize that in perl 6 you can re-open classes and add methods to
them. However this is not convenient for programmatic class generation.
And I would really prefer the old Perl 5 way of mucking with the symbol
table not be the Perl 6 way of doing this. The ideal approach IMO is to
be able to do what the p5 MetaModel prototype does, and be able to add
methods to the metaclass instance directly (which then exposes them to
the class and instances of the class).
So, how should this look in Perl 6? I currently have a two
thoughts/suggestions/directions.
1) Anonymous methods/submethods
$obj.meta.add_method('foo' => method (Foo $self: $bar) { ... }); #
adding an instance method
$obj.meta.add_method('foo' => method (::Foo $class: $bar) { ... }); #
adding a class method
$obj.meta.add_method('foo' => submethod ($self: $bar) { ... }); #
adding a submethod method
$obj.meta.add_method(':foo' => method ($self: $bar) { ... }); #
adding a private method (NOTE: ':' in name)
I am not sure if anonymous methods have been discussed already or not.
But this is one possible approach. The idea being that since it is a
method already, it would already know about things like $?SELF, $?CLASS
and next METHOD (although those values would be unbound), and would
likely have an invocant parameter (which could sometimes be used to
determine if it was a class method or instance method).
2) Closure factory
$obj.meta.add_method('foo' => sub ($self, $bar) { ... },
:type<instance>);
$obj.meta.add_method('foo' => sub ($self, $bar) { ... }, :type<class>);
$obj.meta.add_method('foo' => ($self, $bar) -> { ... },
:type<submethod>);
$obj.meta.add_method(':foo' => { ... }, :type<private>);
Given an arbitrary block of executable code (anything from a raw block,
to a pointy block, to a sub ref) the add_method closure factory will
turn it into the right "method-thing" based upon the :type<> parameter.
Thoughts??
Thanks,
Stevan
