Stories
Slash Boxes
Comments
NOTE: use Perl; is on undef hiatus. You can read content, but you can't post it. More info will be forthcoming forthcomingly.

All the Perl that's Practical to Extract and Report

The Fine Print: The following comments are owned by whoever posted them. We are not responsible for them in any way.
 Full
 Abbreviated
 Hidden
More | Login | Reply
Loading... please wait.
  • With Perl 5 that would look like either:

    package POC::TestAnnouncer;

    use Moose::Role;

    before test => sub {
      my $project = $_[1];
      announce-start-of('test', $project{name});
    };

    after test => sub {
      my $project = $_[1];
      announce-end-of('test', $project{name});
    };

    And then there's the more powerful around:

    package POC::TestAnnouncer;

    use Moose::Role;

    around test => sub {
      my $fn = shift;
      my $self = shift;
      my $project = $_[0];
      announce-start-of('test', $project{name});
    --
    --fREW
    http://blog.afoolishmanifesto.com
    • Thanks. I was only aware of how Moose did it to the extent that people come into the #perl6 channel sometimes and ask "what's the equivalent to Moose's before/after/around in Perl 6?" and we answer "[call|next][same|with]".

      (The "call-" methods are returning calls, and the "next-" methods are tailcalls. "-same" sends along the original arguments, and "-with" allows you to send new ones.)

      What's really neat, and what I still haven't quite gotten my head wrapped around, is that these four routines are used in three quite different situations:

      • Walking along the candidate list in of matching multi subs or methods.
      • Walking up the inheritance tree in a class hierarchy.
      • Unwrapping the candy wrapping of wrapped routines.

      That's a way cool generalization, but the interactions between these three (or at least the first two) are still not very well-understood. It is thought that a class-hierarchy dispatcher will constitute the "outer loop", and a multi candidate dispatcher will form the "inner loop". We're still trying that model out for size.

      • Oh, huh, and I should probably add that mixins may look like they do a variant of wrapping in Perl 6, but they really work by creating an anonymous subclass to the class of the object, and re-blessing the object to that subclass. So, they work by inheritance, not wrapping.

        The fact that both of these use "callsame;" to delegate to the original routine means that I can use mixins and think they are wrappers, and they'll still behave as I expect. That's why I like the above unification.

        • The Moose version Frew posted uses Roles. So applying this "mixin" at Runtime to an instance will also derive an anonymous subclass with the Role applied and re-bless an instance into that subclass.

        • Also playing about some I came up with something nearly identical using MooseX::Declare's syntax.


          role POC::TestAnnouncer {
                  use mro;

                  method test ($project) {
                      announce-start-of('test', $project{name});
                      my $result = $self->maybe::next::method($project); # callsame
                      announce-end-of('test', $result);
                 

          • I mean $.callsame rather than .callsame. Thanks to TimToady and TiMBuS for clarifying things at least enough that I understand that much.