Crafting Custom Interfaces with Sub::Exporter

Sub::Exporter Crafting Custom Interfaces

rjbs @cpan.org Ricardo SIGNES

What’s an Exporter? • Something that takes care of the annoying details of importing.

What is Importing?

What is Importing? • Build it over there, then bring it here.

What is Importing? • Build it over there, then bring it here. • For our purposes, “it” is code.

Why Do We Import?

Why Do We Import? • We want someone else to do the hard, boring work.

Why Do We Import? • We want someone else to do the hard, boring work. • And we want it done cheap.

sub strftime { my($pkg,$fmt,$time); ($pkg,$fmt,$time,$tzname) = @_; my $me = ref($pkg) ? $pkg : bless []; if(deﬁned $tzname) { $tzname = uc $tzname; $tzname = sprintf(“%+05d”,$tzname) unless($tzname =~ /D/); $epoch = timegm(@{$time}[0..5]); @$me = gmtime($epoch + tz_offset($tzname) - tz_offset()); } else { @$me = @$time; undef $epoch; } _subs($me,$fmt); }

Date::Format::strftime

strftime

How Importing Works

How Importing Works • the client use-s a module

How Importing Works • the client use-s a module • the module’s import method is called

How Importing Works • the client use-s a module • the module’s import method is called • something ugly happens

How Importing Works • the client use-s a module • the module’s import method is called • something ugly happens • the client has more named subs

How Importing Works • usually that ugliness is Exporter.pm

How Importing Works • usually that ugliness is Exporter.pm # the dark and twisted heart of Exporter.pm *{“${callpkg}::$sym”} = &{“${pkg}::$sym”};

*{quot;$::$quot;} = &{quot;$::$quot;}; • the caller gets the same code • with the same name

*{quot;$::$quot;} = &{quot;$::$quot;}; • Exporter.pm churns out identically named and constructed products.

The Factory Model

The Factory Model • One size fits all

The Factory Model • One size fits all • If it doesn’t fit your code, adjust your code.

The Factory Model • One size fits all • If it doesn’t fit your code, adjust your code. • Or abuse the Exporter

The Factory Model • There’s Only One Way To Do It

The Tool Metaphor

The Tool Metaphor • “You can’t write good code without good tools.”

The Tool Metaphor • “You can’t write good code without good tools.” • Exporters are tools for making tools.

The Tool Metaphor • “You can’t write good code without good tools.” • Exporters are tools for making tools. • Their quality has an impact all the way down the line.

Craftsman Tools

Craftsman Tools • We want adaptable tools, customized for our current needs.

Craftsman Tools • We want adaptable tools, customized for our current needs. • We want tools hand-crafted to our specifications.

Craftsman Tools • We want adaptable tools, customized for our current needs. • We want tools hand-crafted to our specifications. • We want to reduce our labor by having someone else do the boring work.

Sub::Exporter!

Basic Exporting

The Basics • String::Truncate • trunc: truncate a string to length • elide: truncate, ending in “...”

String::Truncate

String::Truncate $string = “This string is 34 characters long.”;

String::Truncate $string = “This string is 34 characters long.”; trunc($string, 10); # This strin

String::Truncate $string = “This string is 34 characters long.”; trunc($string, 10); # This strin elide($string, 10); # This st...

Basic Exports To let your client write: use String::Truncate qw(elide trunc);

Basic Exports package String::Truncate; use Sub::Exporter -setup => { exports => [ qw(elide trunc) ], };

Basic Groups To let your client write: use String::Truncate qw(:all)

Basic Groups package String::Truncate; use Sub::Exporter -setup => { exports => [ qw(elide trunc) ], };

Basic Groups package String::Truncate; use Sub::Exporter -setup => { exports => [ qw(elide trunc) ], groups => { all => [qw(elide trunc)] }, };

Basic Groups To let your client write: use String::Truncate qw(:basic)

Basic Groups package String::Truncate; use Sub::Exporter -setup => { exports => [ qw(elide trunc) ], groups => { basic => [qw(elide trunc)] } };

Basic Defaults To let your client write: use String::Truncate; # imports “trunc”

Basic Defaults package String::Truncate; use Sub::Exporter -setup => { exports => [ qw(elide trunc) ], groups => { basic => [ qw(elide trunc) ], default => [ qw(trunc) ] }, };

Using Exporter.pm package String::Truncate; use Exporter; use vars qw(@ISA @EXPORT @EXPORT_OK %EXPORT_TAGS); @ISA = qw(Exporter); @EXPORT = qw(trunc); @EXPORT_OK = qw(elide trunc); %EXPORT_TAGS = ( all => @EXPORT_OK, basic => [ qw(elide trunc) ], );

Renaming Exports

Renaming Exports • avoid namespace collisions

Renaming Exports use CGI qw(:standard); use LWP::Simple; my $head = head(...); # what happens?

Renaming Exports • avoid unclear or ambiguous names

Renaming Exports use File::Basename; use XML::Parser; my $file = fileparse($ARGV[0]); $parser->parsefile($file);

Renaming Exports • “privatize” subs imported to classes

Renaming Exports package XML::Parser::Hypothetical; use File::Basename;

Renaming Exports Using Exporter::Renaming use Exporter::Renaming; use String::Truncate qw(elide), Renaming => [ trunc => ‘trunc_str’ ]; no Exporter::Renaming;

Renaming Exports To let your client write: use String::Truncate qw(trunc), trunc => { -as => ‘trunc_str’ };

Renaming Exports package String::Truncate; use Sub::Exporter -setup => { exports => [ qw(elide trunc) ], groups => { basic => [ qw(elide trunc) ], default => [ qw(trunc) ] }, };

Wait a second... use String::Truncate qw(trunc), trunc => { -as => ‘trunc_str’ };

Data::OptList Quick and Dirty Data Structures

Data::OptList @optlist = ( qw(alfa bravo), charlie => [ 0, 1, 2 ], delta => { a => 1 }, ‘echo’, foxtrox => undef, ‘gulf’, );

Data::OptList $as_href = { @optlist = ( alfa => undef, qw(alfa bravo), bravo => undef, charlie => [ 0, 1, 2 ], charlie => [ 0, 1, 2], delta => { a => 1 }, delta => { a => 1 }, ‘echo’, echo => undef, foxtrox => undef, foxtrot => undef, ‘gulf’, gulf => undef, ); ];

Data::OptList $as_aref = [ @optlist = ( [ alfa => undef ], qw(alfa bravo), [ bravo => undef ], charlie => [ 0, 1, 2 ], [ charlie => [0,1,2] ], delta => { a => 1 }, [ delta => {a => 1}], ‘echo’, [ echo => undef ], foxtrox => undef, [ foxtrot => undef ], ‘gulf’, [ gulf => undef ], ); ];

Data::OptList @optlist = ( qw(aye aye) love => [ qw(chex) ], love => [ qw(milk) ], aye => { sir => ‘!’ }, );

Data::OptList $as_aref = [ @optlist = ( [ aye => undef ], qw(aye aye) [ aye => undef ], love => [ qw(chex) ], [ love => [qw(chex)] ], love => [ qw(milk) ], [ love => [qw(milk)] ], aye => { sir => ‘!’ }, [ aye => {sir => ‘!’}] ); ];

Data::OptList @optlist = ( qw(aye aye) love => [ qw(chex) ], $as_href = die “...”; love => [ qw(milk) ], aye => { sir => ‘!’ }, );

Customizing Exports

Subclassed Exporters

Subclassed Exporters • import is a method

Subclassed Exporters • import is a method • that implies that exporters are classes

Subclassed Exporters • import is a method • that implies that exporters are classes • and that we can subclass them

package String::Truncate::Split; use base qw(String::Truncate); sub trunc { my ($string, $length) = @_; # ... return ($head, $tail); }

Subclassed Exporters • *{“$::$”} = &{“$::$”};

Subclassed Exporters • *{“$::$”} = &{“$::$”}; • @EXPORT has to be defined in the derived class

Subclassed Exporters • *{“$::$”} = &{“$::$”}; • @EXPORT has to be defined in the derived class • the export has to be defined in the exporting package

package String::Truncate::Split; use base qw(String::Truncate); sub trunc { my ($string, $length) = @_; # ... return ($head, $tail); } 1;

package String::Truncate::Split; use base qw(String::Truncate); our @EXPORT_OK = @String::Truncate::EXPORT_OK; our @EXPORT = @String::Truncate::EXPORT; our %EXPORT_TAGS = %String::Truncate::EXPORT_TAGS; sub trunc { my ($string, $length) = @_; # ... return ($head, $tail); }

package String::Truncate::Split; use base qw(String::Truncate); our @EXPORT_OK = @String::Truncate::EXPORT_OK; our @EXPORT = @String::Truncate::EXPORT; our %EXPORT_TAGS = %String::Truncate::EXPORT_TAGS; sub trunc { my ($string, $length) = @_; # ... return ($head, $tail); } *$_ = &{“String::Truncate::$_”} for grep { not defined &{__PACKAGE__.“::$_”} } @EXPORT;

package String::Truncate::Split; use base qw(String::Truncate); our @EXPORT_OK = @String::Truncate::EXPORT_OK; our @EXPORT = @String::Truncate::EXPORT; our %EXPORT_TAGS = %String::Truncate::EXPORT_TAGS; sub trunc { my ($string, $length) = @_; # ... return ($head, $tail); } do { no strict ‘refs’; *$_ = &{“String::Truncate::$_”} for grep { not defined &{__PACKAGE__.“::$_”} } @EXPORT; }

Subclassed Exporters • Sub::Exporter finds exports with “can”

Subclassed Exporters • Sub::Exporter finds exports with “can” • this means you can subclass exporting toolkits, replacing just pieces

package String::Truncate::Split; use base qw(String::Truncate); sub trunc { my ($string, $length) = @_; # ... return ($head, $tail); }

Customizing Exports

Customizing Exports • What if you want trunc to work differently when you use it?

Customizing Exports • Some modules do this with package variables.

Package-Level Config use String::Truncate qw(:all); $String::Truncate::DEFAULT_LENGTH = 20; $String::Truncate::DEFAULT_MARKER = “--”;

Package-Level Config use String::Truncate qw(:all); $String::Truncate::DEFAULT_LENGTH = 20; $String::Truncate::DEFAULT_MARKER = “--”; use Tools::Useful;

Package-Level Config use String::Truncate (); use Tools::Useful; sub trunc { my ($string, $length) = @_; $length = 20 if not defined $length; String::Truncate::trunc($string, $length) }

Package-Level Config use String::Truncate (); use Tools::Useful; sub trunc { local $String::Truncate::DEFAULT_LENGTH = 20; String::Truncate::trunc(@_); }

Custom Imports use String::Truncate qw(trunc), elide => { -as => ‘trail_off’, marker => ‘etc’, };

Custom Imports use String::Truncate qw(trunc elide), elide => { -as => ‘trail_off’, marker => ‘etc’, };

Custom Imports use String::Truncate trunc => { -as => ‘trunc_str’, length => 10 }, elide => { -as => ‘elide_str’, length => 10 };

Custom Imports use String::Truncate -all => { -suffix => ‘_str’, length => 10 };

Exports to Order package String::Truncate; use Sub::Exporter -setup => { exports => [ qw(elide trunc) ], groups => { basic => [ qw(elide trunc) ], default => [ qw(trunc) ] }, };

Exports to Order package String::Truncate; use Sub::Exporter -setup => { exports => [ elide => undef, trunc => undef, ], groups => { basic => [ qw(elide trunc) ], default => [ qw(trunc) ] }, };

Exports to Order package String::Truncate; use Sub::Exporter -setup => { exports => [ elide => ’_build_elide’, trunc => ’_build_trunc’, ], groups => { basic => [ qw(elide trunc) ], default => [ qw(trunc) ] }, };

Generating Routines

Generating Routines sub _build_trunc {

Generating Routines sub _build_trunc { my ($class, $name, $arg) = @_;

Generating Routines sub _build_trunc { my ($class, $name, $arg) = @_; my $_length = $arg->{length};

Generating Routines sub _build_trunc { my ($class, $name, $arg) = @_; my $_length = $arg->{length}; return sub {

Generating Routines sub _build_trunc { my ($class, $name, $arg) = @_; my $_length = $arg->{length}; return sub { my ($string, $length, @rest) = @_;

Generating Routines sub _build_trunc { my ($class, $name, $arg) = @_; my $_length = $arg->{length}; return sub { my ($string, $length, @rest) = @_; $length = $_length if !defined $length;

Generating Routines sub _build_trunc { my ($class, $name, $arg) = @_; my $_length = $arg->{length}; return sub { my ($string, $length, @rest) = @_; $length = $_length if !defined $length; trunc($string, $length, @rest);

Generating Routines sub _build_trunc { my ($class, $name, $arg) = @_; my $_length = $arg->{length}; return sub { my ($string, $length, @rest) = @_; $length = $_length if !defined $length; trunc($string, $length, @rest); }

Generating Routines sub _build_trunc { my ($class, $name, $arg) = @_; my $_length = $arg->{length}; return sub { my ($string, $length, @rest) = @_; $length = $_length if !defined $length; trunc($string, $length, @rest); } }

Routines ex nihilo

Routines ex nihilo use Cypher::Trivial qw(cyphers);

Routines ex nihilo use Cypher::Trivial qw(cyphers); my ($encyph, $decyph) = cyphers(“secret”);

Routines ex nihilo use Cypher::Trivial qw(cyphers); my ($encyph, $decyph) = cyphers(“secret”); $cyphertext

Routines ex nihilo use Cypher::Trivial qw(cyphers); my ($encyph, $decyph) = cyphers(“secret”); $cyphertext = $encyph->(“Top secret message.”);

Routines ex nihilo use Cypher::Trivial qw(cyphers); my ($encyph, $decyph) = cyphers(“secret”); $cyphertext = $encyph->(“Top secret message.”); sub encypher {

Routines ex nihilo use Cypher::Trivial qw(cyphers); my ($encyph, $decyph) = cyphers(“secret”); $cyphertext = $encyph->(“Top secret message.”); sub encypher { my $text = shift; $encyph->($text);

Routines ex nihilo use Cypher::Trivial qw(cyphers); my ($encyph, $decyph) = cyphers(“secret”); $cyphertext = $encyph->(“Top secret message.”); sub encypher { my $text = shift; $encyph->($text); }

Routines ex nihilo

Routines ex nihilo use Cypher::Trivial

Routines ex nihilo use Cypher::Trivial encypher => { secret => “secret” };

Routines ex nihilo use Cypher::Trivial encypher => { secret => “secret” }; encypher(“Top secret message”);

Routines ex nihilo sub _build_encypher { my ($class, $name, $arg) = @_; my ($enc, $dec) = cyphers($arg->{secret}); return $enc; } sub _build_decypher { my ($class, $name, $arg) = @_; my ($enc, $dec) = cyphers($arg->{secret}); return $dec; }

Routines ex nihilo package Cypher::Trivial; use Sub::Exporter -setup => { exports => [ encypher => ’_build_encypher’, decypher => ’_build_decypher’, cyphers => undef, ], groups => { cyphers => [ qw(encypher decypher) ], } };

Routines ex nihilo use Cypher::Trivial encypher => { secret => “secret” }; encypher(“Top secret message”);

Routines ex nihilo use Cypher::Trivial -cyphers => { secret => “secret” }; encypher(“Top secret message”); decypher(“Gbc frperg zrffntr”);

Generating Groups package Cypher::Trivial; use Sub::Exporter -setup => { exports => [ encypher => ’_build_encypher’, decypher => ’_build_decypher’, cyphers => undef, ], groups => { cyphers => [ qw(encypher decypher) ], } };

Generating Groups sub _build_encypher { my ($class, $name, $arg) = @_; my ($enc, $dec) = cyphers($arg->{secret}); return $enc; } sub _build_decypher { my ($class, $name, $arg) = @_; my ($enc, $dec) = cyphers($arg->{secret}); return $dec; }

Generating Groups package Cypher::Trivial; use Sub::Exporter -setup => { exports => [ encypher => ’_build_encypher’, decypher => ’_build_decypher’, cyphers => undef, ], groups => { cyphers => ’_build_cyphers’, } };

Generating Groups

Generating Groups sub _build_cyphers {

Generating Groups sub _build_cyphers { my ($class, $name, $arg) = @_;

Generating Groups sub _build_cyphers { my ($class, $name, $arg) = @_; my %sub;

Generating Groups sub _build_cyphers { my ($class, $name, $arg) = @_; my %sub; @sub{qw(encypher decypher)}

Generating Groups sub _build_cyphers { my ($class, $name, $arg) = @_; my %sub; @sub{qw(encypher decypher)} = cyphers($arg->{secret});

Generating Groups sub _build_cyphers { my ($class, $name, $arg) = @_; my %sub; @sub{qw(encypher decypher)} = cyphers($arg->{secret}); return %sub;

Generating Groups sub _build_cyphers { my ($class, $name, $arg) = @_; my %sub; @sub{qw(encypher decypher)} = cyphers($arg->{secret}); return %sub; }

Generating Groups use Cypher::Trivial -cyphers => { secret => “secret” };

Generating Groups use Cypher::Trivial -cyphers => { secret => “secret” }, -cyphers => { secret => ‘Secret1234’, -suffix => ‘_strong’ } ;

Exporting Methods

ZOMG O NO!

Methods & Exporter.pm

Methods & Exporter.pm • Exporter.pm: “Do not export method names!”

Methods & Exporter.pm • Exporter.pm: “Do not export method names!” • *{“$::$”} = &{“$::$”};

Methods & Exporter.pm package Object::Hybrid; use Exporter; @Object::Exporter::ISA = qw(Exporter); @Object::Exporter::EXPORT_OK = qw(retrieve); sub retrieve { my ($class, $id) = @_; my $row = $class->get_row(id => $id); bless $row => $class; }

Methods & Exporter.pm use Object::Hybrid qw(retrieve); my $object = retrieve(42); my $object = retrieve(49);

Methods & Exporter.pm package Object::Hybrid; use Exporter; @Object::Exporter::ISA = qw(Exporter); @Object::Exporter::EXPORT_OK = qw(object); sub retrieve { my ($class, $id) = @_; my $row = $class->get_row(id => $id); bless $row => $class; } sub object { __PACKAGE__->retrieve(@_) }

Methods & Exporter.pm use Object::Hybrid qw(object); my $object = object(42); my $object = object(49);

Methods & Exporter.pm use Object::Hybrid; my $object = Object::Hybrid->object(42);

Methods & Exporter.pm

Methods & Exporter.pm use Object::Hybrid;

Methods & Exporter.pm use Object::Hybrid; use Object::Hybrid::With::Much::Derivation;

Methods & Exporter.pm use Object::Hybrid; use Object::Hybrid::With::Much::Derivation; my $object = Object::Hybrid->retrieve(42);

Methods & Exporter.pm use Object::Hybrid; use Object::Hybrid::With::Much::Derivation; my $object = Object::Hybrid->retrieve(42); my $thing =

Methods & Exporter.pm use Object::Hybrid; use Object::Hybrid::With::Much::Derivation; my $object = Object::Hybrid->retrieve(42); my $thing = Object::Hybrid::With::Much::Derivation

Methods & Exporter.pm use Object::Hybrid; use Object::Hybrid::With::Much::Derivation; my $object = Object::Hybrid->retrieve(42); my $thing = Object::Hybrid::With::Much::Derivation ->retrieve(49);

Methods & Exporter.pm package Object::Hybrid; use Exporter; @Object::Exporter::ISA = qw(Exporter); @Object::Exporter::EXPORT_OK = qw(object); sub retrieve { my ($class, $id) = @_; my $row = $class->get_row(id => $id); bless $row => $class; } sub object { __PACKAGE__->retrieve(@_) }

Currying Methods use Object::Hybrid qw(object); use Object::Hybrid::With::Much::Derivation object => { -as => ‘derived_object’ }; my $object = object(42); my $thing = derived_object(49);

Currying Methods use Object::Hybrid qw(object); my $object = Object::Hybrid->object(49);

Currying Methods

Currying Methods use Sub::Exporter -setup => {

Currying Methods use Sub::Exporter -setup => { exports => [ object => &_build_object ],

Currying Methods use Sub::Exporter -setup => { exports => [ object => &_build_object ], };

Currying Methods use Sub::Exporter -setup => { exports => [ object => &_build_object ], }; sub _build_object {

Currying Methods use Sub::Exporter -setup => { exports => [ object => &_build_object ], }; sub _build_object { my ($class, $name, $arg) = @_;

Currying Methods use Sub::Exporter -setup => { exports => [ object => &_build_object ], }; sub _build_object { my ($class, $name, $arg) = @_; return sub { $class->new(@_); }

Currying Methods use Sub::Exporter -setup => { exports => [ object => &_build_object ], }; sub _build_object { my ($class, $name, $arg) = @_; return sub { $class->new(@_); } }

Currying Methods use Sub::Exporter -setup => { exports => [ object => curry_class(‘new’) ], }

Currying Methods use Sub::Exporter::Util qw(curry_class); use Sub::Exporter -setup => { exports => [ object => curry_class(‘new’) ], }

Exporting Methods

Exporting Methods • Sometimes you want to export methods without currying the class.

Exporting Methods • Sometimes you want to export methods without currying the class. • Exporters can serve as method crafters.

Exporting Methods package Mixin::Dumper; use Sub::Exporter -setup => { exports => [ qw(dump) ], groups => { default => [ qw(dump) ] }, }; sub dump { my ($self) = @_; require Data::Dumper; Data::Dumper::Dumper($self); }

Exporting Methods package Email::Simple::mixin:ReplyText; use Sub::Exporter -setup => { exports => [ qw(reply_text) ], groups => { defaults => [ qw(reply_text) ] }, }; sub reply_text { my ($self) = @_; join “n”, map “>$_”, split /n/, $self->body; }

Exporting Methods package Email::Simple::mixin:ReplyText; use Sub::Exporter -setup => { into => ‘Email::Simple’, exports => [ qw(reply_text) ], groups => { defaults => [ qw(reply_text) ] }, }; sub reply_text { my ($self) = @_; join “n”, map “>$_”, split /n/, $self->body; }

Exporting Methods use Email::Simple; use Email::Simple::mixin::ReplyText;

Exporting Methods use Email::Simple; use Email::Simple::mixin::ReplyText; use Email::Simple::Mock; use Email::Simple::mixin::ReplyText { into => ‘Email::Simple::Mock’ };

Emulating mixin.pm

Emulating mixin.pm • Don’t import into my namespace...

Emulating mixin.pm • Don’t import into my namespace... • ...import to a new namespace...

Emulating mixin.pm • Don’t import into my namespace... • ...import to a new namespace... • ...and add it to my @ISA.

Emulating mixin.pm

Emulating mixin.pm • This makes it easy to import a chunk of methods and override just a few...

Emulating mixin.pm • This makes it easy to import a chunk of methods and override just a few... • ...and those few can call SUPER.

Emulating mixin.pm package Email::Simple::mixin:ReplyText; use Sub::Exporter -setup => { into => ‘Email::Simple’, exports => [ qw(reply_text) ], groups => { defaults => [ qw(reply_text) ] }, }; sub reply_text { my ($self) = @_; join “n”, map “>$_”, split /n/, $self->body; }

Emulating mixin.pm package Email::Simple::mixin:ReplyText; use Sub::Exporter -setup => { into => ‘Email::Simple’, exporter=> mixin_exporter, exports => [ qw(reply_text) ], groups => { defaults => [ qw(reply_text) ] }, }; sub reply_text { my ($self) = @_; join “n”, map “>$_”, split /n/, $self->body; }

Collectors

Collectors • Arguments that don’t export anything.

Collectors • Arguments that don’t export anything. • They collect data for generators to use.

Collectors package String::Truncate; use Sub::Exporter -setup => { exports => [ elide => ’_build_elide’, trunc => ’_build_trunc’, ], collectors => [ qw(defaults) ], };

Collectors

Collectors use String::Truncate

Collectors use String::Truncate defaults => { length => 10 },

Collectors use String::Truncate defaults => { length => 10 }, qw(-all),

Collectors use String::Truncate defaults => { length => 10 }, qw(-all), trunc => { length => 1, -as => ‘onechar’ },

Collectors use String::Truncate defaults => { length => 10 }, qw(-all), trunc => { length => 1, -as => ‘onechar’ }, elide => { marker => ‘&c’, -as => ‘yul’ },

Collectors use String::Truncate defaults => { length => 10 }, qw(-all), trunc => { length => 1, -as => ‘onechar’ }, elide => { marker => ‘&c’, -as => ‘yul’ }, ;

Collectors sub _build_trunc { my ($class, $name, $arg) = @_; my $_length = $arg->{length}; return sub { my ($string, $length, @rest) = @_; $length = $_length if !defined $length; trunc($string, $length, @rest); } }

Collectors sub _build_trunc { my ($class, $name, $arg, $col) = @_; my $_length = $arg->{length}; return sub { my ($string, $length, @rest) = @_; $length = $_length if !defined $length; trunc($string, $length, @rest); } }

Collectors sub _build_trunc { my ($class, $name, $arg, $col) = @_; my $_length = $arg->{length}; $_length = $col->{defaults}{length} if !defined $_length; return sub { my ($string, $length, @rest) = @_; $length = $_length if !defined $length; trunc($string, $length, @rest); } }

Collectors

Collectors • Arguments that don’t export. • They collect data for generators to use.

Collectors • Arguments that don’t export. • They collect data for generators to use. • They can validate the collected data.

Collectors package String::Truncate; use Sub::Exporter -setup => { exports => [ elide => ’_build_elide’, trunc => ’_build_trunc’, ], collectors => { defaults => ’_validate_defaults’, }, };

Collectors sub _validate_defaults { my ($class, $value, $data) = @_; return (ref $value eq ‘HASH’); }

Collectors

Collectors • Arguments that don’t export. • They collect data for generators to use. • They can validate the collected data.

Collectors • Arguments that don’t export. • They collect data for generators to use. • They can validate the collected data. • They can do Almost Anything Else.

Collectors sub _validate_defaults { my ($class, $value, $data) = @_; return (ref $value eq ‘HASH’); }

Collectors

Collectors • name - name of the collection

Collectors • name - name of the collection • class - invocant of import method

Collectors • name - name of the collection • class - invocant of import method • config - exporter configuration

Collectors • name - name of the collection • class - invocant of import method • config - exporter configuration • into - the package that’s importing

Collectors • name - name of the collection • class - invocant of import method • config - exporter configuration • into - the package that’s importing • import_args - args to import method

Collectors

Collectors • name - the name of the collection

Collectors • name - the name of the collection • class - import’s invocant

Collectors

Collectors • config - the Sub::Exporter config

Collectors • config - the Sub::Exporter config • find out what exports exist

Collectors • config - the Sub::Exporter config • find out what exports exist • validate collection value based on config

use LWP::Simple “/^is_/”; is_success($res); is_failure($res);

use LWP::Simpleton; use Sub::Exporter -setup => { collectors => { like => Sub::Exporter::Util::like }, };

use LWP::Simple like => qr/^is_/; is_success($res); is_failure($res);

use LWP::Simple like => [ qr/^is_/, undef, qr/^get/, { -prefix => ‘https_’, ssl => 1 } ]; is_success($res); is_failure($res); https_get(“https://codesimply.com”)

Collectors

Collectors • into - the target to which exports go

Collectors • into - the target to which exports go • alter the class directly

Collectors • into - the target to which exports go • alter the class directly • particularly useful: @ISA

sub _make_base { my ($class, $value, $data) = @_; my $target = $data->{into}; push @{“$target::ISA”}, $class; }

sub _make_base { my ($class, $value, $data) = @_; my $target = $data->{into}; push @{“$target::ISA”}, $class; } use Sub::Exporter -setup => { collectors => { base => ’_make_base’ }, };

sub _make_base { my ($class, $value, $data) = @_; my $target = $data->{into}; push @{“$target::ISA”}, $class; } use Sub::Exporter -setup => { collectors => { base => ’_make_base’ }, }; use Magic::Superclass -base;

package Email::Constants; sub _set_constants { my ($class, $value, $data) = @_; Package::Generator->assign_symbols( $data->{into}, [ EX_TEMPFAIL => 75, FORMATS => [ qw(Maildir mbox mh) ], ], ); }

package Email::Constants; sub _set_constants { my ($class, $value, $data) = @_; Package::Generator->assign_symbols( $data->{into}, [ EX_TEMPFAIL => 75, FORMATS => [ qw(Maildir mbox mh) ], ], ); } use Sub::Exporter -setup => { collectors => { constants => ’_set_constants’ }, };

use Email::Constants qw(constants);

Collectors

Collectors • import_args - the arguments to import

Collectors • import_args - the arguments to import • rewrite the arguments list

Collectors • import_args - the arguments to import • rewrite the arguments list • add new imports

sub _setup {

sub _setup { my ($class, $value, $data) = @_;

sub _setup { my ($class, $value, $data) = @_; if (ref $value eq ‘HASH’) {

sub _setup { my ($class, $value, $data) = @_; if (ref $value eq ‘HASH’) { push @{ $data->{import_args} },

sub _setup { my ($class, $value, $data) = @_; if (ref $value eq ‘HASH’) { push @{ $data->{import_args} }, [ _import => { -as => ‘import’, %$value } ];

sub _setup { my ($class, $value, $data) = @_; if (ref $value eq ‘HASH’) { push @{ $data->{import_args} }, [ _import => { -as => ‘import’, %$value } ]; return 1;

sub _setup { my ($class, $value, $data) = @_; if (ref $value eq ‘HASH’) { push @{ $data->{import_args} }, [ _import => { -as => ‘import’, %$value } ]; return 1; } elsif (ref $value eq ‘ARRAY’) {

sub _setup { my ($class, $value, $data) = @_; if (ref $value eq ‘HASH’) { push @{ $data->{import_args} }, [ _import => { -as => ‘import’, %$value } ]; return 1; } elsif (ref $value eq ‘ARRAY’) { push @{ $data->{import_args} },

sub _setup { my ($class, $value, $data) = @_; if (ref $value eq ‘HASH’) { push @{ $data->{import_args} }, [ _import => { -as => ‘import’, %$value } ]; return 1; } elsif (ref $value eq ‘ARRAY’) { push @{ $data->{import_args} }, [ _import => {

sub _setup { my ($class, $value, $data) = @_; if (ref $value eq ‘HASH’) { push @{ $data->{import_args} }, [ _import => { -as => ‘import’, %$value } ]; return 1; } elsif (ref $value eq ‘ARRAY’) { push @{ $data->{import_args} }, [ _import => { -as => ‘import’, exports => $value } ];

sub _setup { my ($class, $value, $data) = @_; if (ref $value eq ‘HASH’) { push @{ $data->{import_args} }, [ _import => { -as => ‘import’, %$value } ]; return 1; } elsif (ref $value eq ‘ARRAY’) { push @{ $data->{import_args} }, [ _import => { -as => ‘import’, exports => $value } ]; return 1;

sub _setup { my ($class, $value, $data) = @_; if (ref $value eq ‘HASH’) { push @{ $data->{import_args} }, [ _import => { -as => ‘import’, %$value } ]; return 1; } elsif (ref $value eq ‘ARRAY’) { push @{ $data->{import_args} }, [ _import => { -as => ‘import’, exports => $value } ]; return 1; }

sub _setup { my ($class, $value, $data) = @_; if (ref $value eq ‘HASH’) { push @{ $data->{import_args} }, [ _import => { -as => ‘import’, %$value } ]; return 1; } elsif (ref $value eq ‘ARRAY’) { push @{ $data->{import_args} }, [ _import => { -as => ‘import’, exports => $value } ]; return 1; } return;

sub _setup { my ($class, $value, $data) = @_; if (ref $value eq ‘HASH’) { push @{ $data->{import_args} }, [ _import => { -as => ‘import’, %$value } ]; return 1; } elsif (ref $value eq ‘ARRAY’) { push @{ $data->{import_args} }, [ _import => { -as => ‘import’, exports => $value } ]; return 1; } return; }

use Sub::Exporter -setup => {

use Sub::Exporter -setup => { collectors => { -setup => ’_setup’ },

use Sub::Exporter -setup => { collectors => { -setup => ’_setup’ }, exports => [ _import => ’_build_import’ ],

use Sub::Exporter -setup => { collectors => { -setup => ’_setup’ }, exports => [ _import => ’_build_import’ ], });

-setup => { into_level => 2, exports => [qw(foo)] }

-setup => { into_level => 2, exports => [qw(foo)] } _import => { -as => ‘import’, into_level => 2, exports => [qw(foo)] }

-setup => [ qw(foo bar baz) ]

-setup => [ qw(foo bar baz) ] _import => { -as => ‘import’, exports => [qw(foo bar baz)] }

use Sub::Exporter -setup => { collectors => { -setup => ’_setup’ }, exports => [ _import => ’_build_import’ ], });

use Sub::Exporter -setup => { collectors => { -setup => ’_setup’ }, exports => [ _import => sub { my ($class, $name, $arg) = @_; build_exporter($arg); }, ], });

package Sub::Exporter; use Sub::Exporter -setup => { collectors => { -setup => &_setup }, exports => [ _import => sub { my ($class, $name, $arg) = @_; build_exporter($arg); }, ], });

RJBS’s Advice

RJBS’s Advice • Write the client code first.

RJBS’s Advice • Write the client code first. • Make as many assumptions as possible.

RJBS’s Advice • Write the client code first. • Make as many assumptions as possible. • Let most of them be refuted.

Any Questions?

Random Tricks

Mixed-in Helpers $object->complex_method($arg);

Mixed-in Helpers sub _build_cplx_method { my ($mixin) = @_; sub { my ($self, $arg) = @_; $mixin->validate_arg($arg); $mixin->do_stuff($self, $arg); return $mixin->analyze($self); } } sub validate_arg {...}

Mixed-in Helpers package Mixin::Helper; use Sub::Exporter -setup => { exports => [ complex_method => ’_build_cplx_method’, ], }; sub _build_cplx_method { ...

Mixed-in Helpers sub _build_cplx_method { my ($mixin) = @_; sub { my ($self, $arg) = @_; $mixin->validate_arg($arg); $mixin->do_stuff($self, $arg); return $mixin->analyze($self); } } sub validate_arg {...}

Mixed-in Helpers package Mixin::Helper::Faster; use base qw(Mixin::Helper); sub analyze { my ($mixin, $object) = @_; return 1; } 1;

A Coderef Generator

A Coderef Generator use String::Truncate ();

A Coderef Generator use String::Truncate (); my $trunc;

A Coderef Generator use String::Truncate (); my $trunc; String::Truncate->import(

A Coderef Generator use String::Truncate (); my $trunc; String::Truncate->import(trunc =>

A Coderef Generator use String::Truncate (); my $trunc; String::Truncate->import(trunc => { -as => $trunc });

Accessors sans ISA package YAPC::Slideshow; use Accessors::Simple -setup => { fields => [ qw(topic presenter timeslot room) ], };

Accessors sans ISA

Accessors sans ISA sub _make_accessor {

Accessors sans ISA sub _make_accessor { my ($field) = @_;

Accessors sans ISA sub _make_accessor { my ($field) = @_; sub {

Accessors sans ISA sub _make_accessor { my ($field) = @_; sub { my ($self) = shift;

Accessors sans ISA sub _make_accessor { my ($field) = @_; sub { my ($self) = shift; $self->{field} = shift if @_;

Accessors sans ISA sub _make_accessor { my ($field) = @_; sub { my ($self) = shift; $self->{field} = shift if @_; return $self->{$field};

Accessors sans ISA sub _make_accessor { my ($field) = @_; sub { my ($self) = shift; $self->{field} = shift if @_; return $self->{$field}; }

Accessors sans ISA sub _make_accessor { my ($field) = @_; sub { my ($self) = shift; $self->{field} = shift if @_; return $self->{$field}; } }

Accessors sans ISA sub _make_accessor { my ($field) = @_; sub { my ($self) = shift; $self->{field} = shift if @_; return $self->{$field}; } } sub _make_many_accessors {

Accessors sans ISA sub _make_accessor { my ($field) = @_; sub { my ($self) = shift; $self->{field} = shift if @_; return $self->{$field}; } } sub _make_many_accessors { my @fields = @{ $arg->{fields} };

Accessors sans ISA sub _make_accessor { my ($field) = @_; sub { my ($self) = shift; $self->{field} = shift if @_; return $self->{$field}; } } sub _make_many_accessors { my @fields = @{ $arg->{fields} }; my %sub = map { $_ => _make_accessor($_) } @fields;

Accessors sans ISA sub _make_accessor { my ($field) = @_; sub { my ($self) = shift; $self->{field} = shift if @_; return $self->{$field}; } } sub _make_many_accessors { my @fields = @{ $arg->{fields} }; my %sub = map { $_ => _make_accessor($_) } @fields; return %sub;

Accessors sans ISA sub _make_accessor { my ($field) = @_; sub { my ($self) = shift; $self->{field} = shift if @_; return $self->{$field}; } } sub _make_many_accessors { my @fields = @{ $arg->{fields} }; my %sub = map { $_ => _make_accessor($_) } @fields; return %sub; }

Accessors sans ISA sub _make_accessor { my ($field) = @_; sub { my ($self) = shift; $self->{field} = shift if @_; return $self->{$field}; } } sub _make_many_accessors { my @fields = @{ $arg->{fields} }; my %sub = map { $_ => _make_accessor($_) } @fields; return %sub; } use Sub::Exporter -setup =>

Accessors sans ISA sub _make_accessor { my ($field) = @_; sub { my ($self) = shift; $self->{field} = shift if @_; return $self->{$field}; } } sub _make_many_accessors { my @fields = @{ $arg->{fields} }; my %sub = map { $_ => _make_accessor($_) } @fields; return %sub; } use Sub::Exporter -setup => { groups => { setup => &_make_many_accessors } };

Eat Exporter’s Brain

Eat Exporter’s Brain sub exporter_upgrade {

Eat Exporter’s Brain sub exporter_upgrade { my ($pkg) = @_;

Eat Exporter’s Brain sub exporter_upgrade { my ($pkg) = @_; my $new_pkg = “$pkg::SE”;

Eat Exporter’s Brain sub exporter_upgrade { my ($pkg) = @_; my $new_pkg = “$pkg::SE”; Sub::Exporter::setup_exporter({

Eat Exporter’s Brain sub exporter_upgrade { my ($pkg) = @_; my $new_pkg = “$pkg::SE”; Sub::Exporter::setup_exporter({ as => ‘import’,

Eat Exporter’s Brain sub exporter_upgrade { my ($pkg) = @_; my $new_pkg = “$pkg::SE”; Sub::Exporter::setup_exporter({ as => ‘import’, into => $new_pkg,

Eat Exporter’s Brain sub exporter_upgrade { my ($pkg) = @_; my $new_pkg = “$pkg::SE”; Sub::Exporter::setup_exporter({ as => ‘import’, into => $new_pkg, exports => [ @{“$pkg::EXPORT_OK”} ],

Eat Exporter’s Brain sub exporter_upgrade { my ($pkg) = @_; my $new_pkg = “$pkg::SE”; Sub::Exporter::setup_exporter({ as => ‘import’, into => $new_pkg, exports => [ @{“$pkg::EXPORT_OK”} ], groups => {

Eat Exporter’s Brain sub exporter_upgrade { my ($pkg) = @_; my $new_pkg = “$pkg::SE”; Sub::Exporter::setup_exporter({ as => ‘import’, into => $new_pkg, exports => [ @{“$pkg::EXPORT_OK”} ], groups => { %{“$pkg::EXPORT_TAGS”},

Eat Exporter’s Brain sub exporter_upgrade { my ($pkg) = @_; my $new_pkg = “$pkg::SE”; Sub::Exporter::setup_exporter({ as => ‘import’, into => $new_pkg, exports => [ @{“$pkg::EXPORT_OK”} ], groups => { %{“$pkg::EXPORT_TAGS”}, default => [ @{“$pkg::EXPORTS”} ],

Eat Exporter’s Brain sub exporter_upgrade { my ($pkg) = @_; my $new_pkg = “$pkg::SE”; Sub::Exporter::setup_exporter({ as => ‘import’, into => $new_pkg, exports => [ @{“$pkg::EXPORT_OK”} ], groups => { %{“$pkg::EXPORT_TAGS”}, default => [ @{“$pkg::EXPORTS”} ], },

Eat Exporter’s Brain sub exporter_upgrade { my ($pkg) = @_; my $new_pkg = “$pkg::SE”; Sub::Exporter::setup_exporter({ as => ‘import’, into => $new_pkg, exports => [ @{“$pkg::EXPORT_OK”} ], groups => { %{“$pkg::EXPORT_TAGS”}, default => [ @{“$pkg::EXPORTS”} ], }, });

Eat Exporter’s Brain sub exporter_upgrade { my ($pkg) = @_; my $new_pkg = “$pkg::SE”; Sub::Exporter::setup_exporter({ as => ‘import’, into => $new_pkg, exports => [ @{“$pkg::EXPORT_OK”} ], groups => { %{“$pkg::EXPORT_TAGS”}, default => [ @{“$pkg::EXPORTS”} ], }, }); push @{“$new_pkg::ISA”}, $class;

Eat Exporter’s Brain sub exporter_upgrade { my ($pkg) = @_; my $new_pkg = “$pkg::SE”; Sub::Exporter::setup_exporter({ as => ‘import’, into => $new_pkg, exports => [ @{“$pkg::EXPORT_OK”} ], groups => { %{“$pkg::EXPORT_TAGS”}, default => [ @{“$pkg::EXPORTS”} ], }, }); push @{“$new_pkg::ISA”}, $class; return $new_pkg;

Eat Exporter’s Brain sub exporter_upgrade { my ($pkg) = @_; my $new_pkg = “$pkg::SE”; Sub::Exporter::setup_exporter({ as => ‘import’, into => $new_pkg, exports => [ @{“$pkg::EXPORT_OK”} ], groups => { %{“$pkg::EXPORT_TAGS”}, default => [ @{“$pkg::EXPORTS”} ], }, }); push @{“$new_pkg::ISA”}, $class; return $new_pkg; }

package UNIVERSAL;

package UNIVERSAL; sub exporter_upgrade {

package UNIVERSAL; sub exporter_upgrade { my ($pkg) = @_;

package UNIVERSAL; sub exporter_upgrade { my ($pkg) = @_; my $new_pkg = “$pkg::SE”;

package UNIVERSAL; sub exporter_upgrade { my ($pkg) = @_; my $new_pkg = “$pkg::SE”; return $new_pkg if $new_pkg->isa($pkg);

package UNIVERSAL; sub exporter_upgrade { my ($pkg) = @_; my $new_pkg = “$pkg::SE”; return $new_pkg if $new_pkg->isa($pkg); Sub::Exporter::setup_exporter({

package UNIVERSAL; sub exporter_upgrade { my ($pkg) = @_; my $new_pkg = “$pkg::SE”; return $new_pkg if $new_pkg->isa($pkg); Sub::Exporter::setup_exporter({ as => ‘import’,

package UNIVERSAL; sub exporter_upgrade { my ($pkg) = @_; my $new_pkg = “$pkg::SE”; return $new_pkg if $new_pkg->isa($pkg); Sub::Exporter::setup_exporter({ as => ‘import’, into => $new_pkg,

package UNIVERSAL; sub exporter_upgrade { my ($pkg) = @_; my $new_pkg = “$pkg::SE”; return $new_pkg if $new_pkg->isa($pkg); Sub::Exporter::setup_exporter({ as => ‘import’, into => $new_pkg, exports => [ @{“$pkg::EXPORT_OK”} ],

package UNIVERSAL; sub exporter_upgrade { my ($pkg) = @_; my $new_pkg = “$pkg::SE”; return $new_pkg if $new_pkg->isa($pkg); Sub::Exporter::setup_exporter({ as => ‘import’, into => $new_pkg, exports => [ @{“$pkg::EXPORT_OK”} ], groups => {

package UNIVERSAL; sub exporter_upgrade { my ($pkg) = @_; my $new_pkg = “$pkg::SE”; return $new_pkg if $new_pkg->isa($pkg); Sub::Exporter::setup_exporter({ as => ‘import’, into => $new_pkg, exports => [ @{“$pkg::EXPORT_OK”} ], groups => { %{“$pkg::EXPORT_TAGS”},

package UNIVERSAL; sub exporter_upgrade { my ($pkg) = @_; my $new_pkg = “$pkg::SE”; return $new_pkg if $new_pkg->isa($pkg); Sub::Exporter::setup_exporter({ as => ‘import’, into => $new_pkg, exports => [ @{“$pkg::EXPORT_OK”} ], groups => { %{“$pkg::EXPORT_TAGS”}, default => [ @{“$pkg::EXPORTS”} ],

package UNIVERSAL; sub exporter_upgrade { my ($pkg) = @_; my $new_pkg = “$pkg::SE”; return $new_pkg if $new_pkg->isa($pkg); Sub::Exporter::setup_exporter({ as => ‘import’, into => $new_pkg, exports => [ @{“$pkg::EXPORT_OK”} ], groups => { %{“$pkg::EXPORT_TAGS”}, default => [ @{“$pkg::EXPORTS”} ], },

package UNIVERSAL; sub exporter_upgrade { my ($pkg) = @_; my $new_pkg = “$pkg::SE”; return $new_pkg if $new_pkg->isa($pkg); Sub::Exporter::setup_exporter({ as => ‘import’, into => $new_pkg, exports => [ @{“$pkg::EXPORT_OK”} ], groups => { %{“$pkg::EXPORT_TAGS”}, default => [ @{“$pkg::EXPORTS”} ], }, });

package UNIVERSAL; sub exporter_upgrade { my ($pkg) = @_; my $new_pkg = “$pkg::SE”; return $new_pkg if $new_pkg->isa($pkg); Sub::Exporter::setup_exporter({ as => ‘import’, into => $new_pkg, exports => [ @{“$pkg::EXPORT_OK”} ], groups => { %{“$pkg::EXPORT_TAGS”}, default => [ @{“$pkg::EXPORTS”} ], }, }); push @{“$new_pkg::ISA”}, $class;

package UNIVERSAL; sub exporter_upgrade { my ($pkg) = @_; my $new_pkg = “$pkg::SE”; return $new_pkg if $new_pkg->isa($pkg); Sub::Exporter::setup_exporter({ as => ‘import’, into => $new_pkg, exports => [ @{“$pkg::EXPORT_OK”} ], groups => { %{“$pkg::EXPORT_TAGS”}, default => [ @{“$pkg::EXPORTS”} ], }, }); push @{“$new_pkg::ISA”}, $class; return $new_pkg;

package UNIVERSAL; sub exporter_upgrade { my ($pkg) = @_; my $new_pkg = “$pkg::SE”; return $new_pkg if $new_pkg->isa($pkg); Sub::Exporter::setup_exporter({ as => ‘import’, into => $new_pkg, exports => [ @{“$pkg::EXPORT_OK”} ], groups => { %{“$pkg::EXPORT_TAGS”}, default => [ @{“$pkg::EXPORTS”} ], }, }); push @{“$new_pkg::ISA”}, $class; return $new_pkg; }

Fixing caller

Fixing caller sub default_exporter {

Fixing caller sub default_exporter { my ($class, $gen, $name, $arg, $col, $as, $into)

Fixing caller sub default_exporter { my ($class, $gen, $name, $arg, $col, $as, $into) = @_;

Fixing caller sub default_exporter { my ($class, $gen, $name, $arg, $col, $as, $into) = @_; _install(

Fixing caller sub default_exporter { my ($class, $gen, $name, $arg, $col, $as, $into) = @_; _install( _generate($class, $generator, $name, $arg, $col),

Fixing caller sub default_exporter { my ($class, $gen, $name, $arg, $col, $as, $into) = @_; _install( _generate($class, $generator, $name, $arg, $col), $into,

Fixing caller sub default_exporter { my ($class, $gen, $name, $arg, $col, $as, $into) = @_; _install( _generate($class, $generator, $name, $arg, $col), $into, $as,

Fixing caller sub default_exporter { my ($class, $gen, $name, $arg, $col, $as, $into) = @_; _install( _generate($class, $generator, $name, $arg, $col), $into, $as, );

Fixing caller sub default_exporter { my ($class, $gen, $name, $arg, $col, $as, $into) = @_; _install( _generate($class, $generator, $name, $arg, $col), $into, $as, ); }

sub evil_eval_exporter { # TOTALLY UNTESTED!

sub evil_eval_exporter { # TOTALLY UNTESTED! my ($class, $gen, $name, $arg, $col, $as, $into)

sub evil_eval_exporter { # TOTALLY UNTESTED! my ($class, $gen, $name, $arg, $col, $as, $into) = @_;

sub evil_eval_exporter { # TOTALLY UNTESTED! my ($class, $gen, $name, $arg, $col, $as, $into) = @_; $col->{_g} ||= do {

sub evil_eval_exporter { # TOTALLY UNTESTED! my ($class, $gen, $name, $arg, $col, $as, $into) = @_; $col->{_g} ||= do { my $g = Dump(&_generate)->Names(‘GEN’)->Out;

sub evil_eval_exporter { # TOTALLY UNTESTED! my ($class, $gen, $name, $arg, $col, $as, $into) = @_; $col->{_g} ||= do { my $g = Dump(&_generate)->Names(‘GEN’)->Out; $g =~ s/A$GEN = sub/sub _generate/;

sub evil_eval_exporter { # TOTALLY UNTESTED! my ($class, $gen, $name, $arg, $col, $as, $into) = @_; $col->{_g} ||= do { my $g = Dump(&_generate)->Names(‘GEN’)->Out; $g =~ s/A$GEN = sub/sub _generate/; $g = “package $into;n$g”;

sub evil_eval_exporter { # TOTALLY UNTESTED! my ($class, $gen, $name, $arg, $col, $as, $into) = @_; $col->{_g} ||= do { my $g = Dump(&_generate)->Names(‘GEN’)->Out; $g =~ s/A$GEN = sub/sub _generate/; $g = “package $into;n$g”; eval $g;

sub evil_eval_exporter { # TOTALLY UNTESTED! my ($class, $gen, $name, $arg, $col, $as, $into) = @_; $col->{_g} ||= do { my $g = Dump(&_generate)->Names(‘GEN’)->Out; $g =~ s/A$GEN = sub/sub _generate/; $g = “package $into;n$g”; eval $g; &{“$into::_generate”};

sub evil_eval_exporter { # TOTALLY UNTESTED! my ($class, $gen, $name, $arg, $col, $as, $into) = @_; $col->{_g} ||= do { my $g = Dump(&_generate)->Names(‘GEN’)->Out; $g =~ s/A$GEN = sub/sub _generate/; $g = “package $into;n$g”; eval $g; &{“$into::_generate”}; };

sub evil_eval_exporter { # TOTALLY UNTESTED! my ($class, $gen, $name, $arg, $col, $as, $into) = @_; $col->{_g} ||= do { my $g = Dump(&_generate)->Names(‘GEN’)->Out; $g =~ s/A$GEN = sub/sub _generate/; $g = “package $into;n$g”; eval $g; &{“$into::_generate”}; }; _install(

sub evil_eval_exporter { # TOTALLY UNTESTED! my ($class, $gen, $name, $arg, $col, $as, $into) = @_; $col->{_g} ||= do { my $g = Dump(&_generate)->Names(‘GEN’)->Out; $g =~ s/A$GEN = sub/sub _generate/; $g = “package $into;n$g”; eval $g; &{“$into::_generate”}; }; _install( $col->{_g}($class, $generator, $name, $arg, $col),

sub evil_eval_exporter { # TOTALLY UNTESTED! my ($class, $gen, $name, $arg, $col, $as, $into) = @_; $col->{_g} ||= do { my $g = Dump(&_generate)->Names(‘GEN’)->Out; $g =~ s/A$GEN = sub/sub _generate/; $g = “package $into;n$g”; eval $g; &{“$into::_generate”}; }; _install( $col->{_g}($class, $generator, $name, $arg, $col), $into,

sub evil_eval_exporter { # TOTALLY UNTESTED! my ($class, $gen, $name, $arg, $col, $as, $into) = @_; $col->{_g} ||= do { my $g = Dump(&_generate)->Names(‘GEN’)->Out; $g =~ s/A$GEN = sub/sub _generate/; $g = “package $into;n$g”; eval $g; &{“$into::_generate”}; }; _install( $col->{_g}($class, $generator, $name, $arg, $col), $into, $as,

sub evil_eval_exporter { # TOTALLY UNTESTED! my ($class, $gen, $name, $arg, $col, $as, $into) = @_; $col->{_g} ||= do { my $g = Dump(&_generate)->Names(‘GEN’)->Out; $g =~ s/A$GEN = sub/sub _generate/; $g = “package $into;n$g”; eval $g; &{“$into::_generate”}; }; _install( $col->{_g}($class, $generator, $name, $arg, $col), $into, $as, );

sub evil_eval_exporter { # TOTALLY UNTESTED! my ($class, $gen, $name, $arg, $col, $as, $into) = @_; $col->{_g} ||= do { my $g = Dump(&_generate)->Names(‘GEN’)->Out; $g =~ s/A$GEN = sub/sub _generate/; $g = “package $into;n$g”; eval $g; &{“$into::_generate”}; }; _install( $col->{_g}($class, $generator, $name, $arg, $col), $into, $as, ); }

Thank You!

http://d.hatena.ne.jp	161
http://www.techgig.com	4
http://www.slideshare.net	2
http://192.168.10.100	1
http://reader.excite.co.jp	1
http://localhost:10010	1

Crafting Custom Interfaces with Sub::Exporter

by Ricardo Signes on Jun 29, 2007

Accessibility

Categories

Upload Details

Usage Rights

6 Embeds 170

Statistics

Crafting Custom Interfaces with Sub::Exporter Presentation Transcript