Slash Boxes
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

use Perl Log In

Log In

[ Create a new account ]

chromatic (983)

  (email not shown publicly)

Blog Information [] Profile for chr0matic []

Journal of chromatic (983)

Wednesday April 12, 2006
06:04 PM

Look Mom, No Source Filter!

[ #29304 ]

One of my favorite hacks in Perl Hacks shows how to declare the :Method attribute so you don't have to type my $self = shift; anymore. There are lots of ways to do that, but my approach was to avoid source filters (yay). The book goes into more detail, but effectively the trick allows you to declare any other parameter while avoiding most drawbacks of source filters.

Damian correctly pointed out that my technique does have the limitation of not always respecting the lexical compiling environment of the methods.

Today I figured out another approach that only handles invocants, but is strict safe. That is, now you can write:

package Foo;

use Attribute::Method;

sub new
    my ($class, %args) = @_;
    bless \%args, $class;

sub foo :Method
    return self->{foo}

Of course, you can also use this or o or just about any other allowed identifier.

What's the trick? I originally thought @DB::args would work, but if you take something off of the stack, it's just gone and so the really clever trampoline trick wouldn't do it. Now it only works with versions of Scalar::Util released this millennium.

Still, I don't really mind that syntax at all.

The Fine Print: The following comments are owned by whoever posted them. We are not responsible for them in any way.
More | Login | Reply
Loading... please wait.
  • It'd be nice if there was a table of contents on the Perl Hacks page -- even a tentative one. The rough cuts version would be much more enticing if I knew exactly what was in the book. :-)
    • What sort of time penalty is this sort of technique going to introduce?

      function calls are already pretty expensive, but depending on how you are implementing this I imagine it could result in a lot more of them. Would this be correct?
  • I have a little module that does exactly that for a little while now and didn't think anyone else was that crazy :)

    I played the game even a bit more in the last weeks:

        sub foo :Method( Int $foo, Object $bar! ) {
                print class, ': ', args->foo;

    Called via:

        $object->foo( foo => 23, bar => $bar_obj );

    "args" returns just a container object, that uses autoload t
    Ordinary morality is for ordinary people. -- Aleister Crowley
    • "args" returns just a container object, that uses autoload to simulate accessors. That's just to capture typos. It's mostly following the Perl 6 signature idea (at least the current one).

      Hmmm, it may pair nicely with Moose []: although the latter claims not to be a Perl 6 implementation in Perl 5, it is admittedly heavily inspired by Perl 6 itself, and to some extent imports Perl 6 semantics, with special emphasis on OO features, in Perl 5. Also, it seems that unlike e.g. v6 [], it is much less experimental a

      -- # This prints: Just another Perl hacker, seek DATA,15,0 and print q... ; __END__
  • Heya c, do you plan to release Attribute::Method on CPAN? I'd love to see it there, esp. if you have an XS implementation to do the magic lickedy-split!