methods::import - import methods to be used like keywords
The following calls get on the $ua object.
get
$ua
use HTTP::Tiny; my $ua = HTTP::Tiny->new; for ($ua) { use methods::import qw(get post); my $response = get 'http://www.example.com/'; }
Alternative:
use HTTP::Tiny; use methods::import qw(get post); my $ua = HTTP::Tiny->new; using $ua, sub { my $response = get 'http://www.example.com/'; };
methods::import simplifies the task of calling a lot of methods on a single object.
Instead of:
$thing->set_foo(1); $thing->process(); $thing->set_foo(2); $thing->set_bar(3); $thing->process;
You can write:
for ($thing) { use methods::import qw( set_foo set_bar process ); set_foo 1; process; set_foo 2; set_bar 3; process; } # You cannot call process() here because it was lexical
As well as set_foo and the other functions explicitly named in the import list, methods::import will always export a function called using.
set_foo
using
using can be used as an alternative to setting $_ to point to an object.
$_
use methods::import qw( set_foo set_bar process ); using $thing, sub { set_foo 1; process; set_foo 2; set_bar 3; process; };
An equals sign allows you to rename the imported wrappers.
use methods::import qw( set_foo=foo set_bar=bar process ); using $thing, sub { foo 1; process; foo 2; bar 3; process; };
Even the using function can be renamed:
use methods::import qw( set_foo=foo set_bar=bar process using=processing ); processing $thing, sub { foo 1; process; foo 2; bar 3; process; };
When you import the wrappers, an scalar variable is created in the lexical scope of all the wrappers being imported. The wrappers will attempt to call the method on this scalar variable if it is defined, and fall back to $_ otherwise.
using accepts an object and a coderef. It sets the scalar variable to point to the object, calls the coderef, then restores the scalar variable to whatever it was before (usally undef). It then returns the return value from calling the coderef.
This means:
use methods::import qw( foo using=using1 ); use methods::import qw( bar using=using2 ); using1 $something, sub { bar(); };
bar() is being called on an undefined object, because using1 only sets the target object for foo, not bar.
bar()
using1
foo
bar
As a utility, if using is called with no parameters, it will simply return the current target object. Or if using is called with one parameter, it will set the target object and return any previous target object.
use methods::import qw( set_foo set_bar process ); using $thing; set_foo 1; process; set_foo 2; set_bar 3; process; using->some_other_method();
use methods::import qw(get); using LWP::UserAgent->new, sub { use methods::import qw(headers using=using_response); using_response get('http://example.com'), sub { my $headers = headers(); }; };
It is possible to curry leading arguments to a method:
use methods::import "foo", "foo" => { -as => "foo_123", -curry => [1,2,3] }; using $thing; foo(1, 2, 3, 4); # $thing->foo(1, 2, 3, 4) foo_123(4); # same
Note that the -as option has the same effect as = in the import list. = is just a shortcut.
-as
=
use methods::import "foo" => { -prototype => '&' }; using $thing; foo { ... }; # $thing->foo(sub { ... });
There is a shortcut for this too:
use methods::import qw( foo=foo=& ); use methods::import qw( foo==& ); # leaves `-as` blank
methods::import doesn't make any attempt to hide the wrapper functions it exports. They will show up on the call stack.
methods::import uses namespace::clean to fake lexical imports.
{ use methods::import qw(foo); using $object; foo(); } # Neither using() nor foo() are defined here.
You can switch off this behaviour by passing -keep as the first option to import:
-keep
import
{ use methods::import qw(-keep foo); using $object; foo(); } # using() and foo() are still defined here.
Or it can be done on a function by function basis:
use methods::import ( "foo" => { -keep => 1 }, "bar" => { -keep => 0 }, "using" => { -keep => 1 }, );
methods::import
If your class inherits from methods::import it can provide a method_list function that supplies a default list of methods for import.
method_list
For example:
package HTTP::Tiny::Keywords; use HTTP::Tiny; use parent 'methods::import'; sub method_list { qw( get post using=set_ua) } 1;
And a module using your HTTP::Tiny::Keywords might do this:
use HTTP::Tiny::Keywords; set_ua HTTP::Tiny->new; my $response = get 'http://www.example.com/';
Please report any bugs to http://rt.cpan.org/Dist/Display.html?Queue=methods-import.
with.
with
Toby Inkster <tobyink@cpan.org>.
This software is copyright (c) 2019 by Toby Inkster.
This is free software; you can redistribute it and/or modify it under the same terms as the Perl 5 programming language system itself.
THIS PACKAGE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
To install methods::import, copy and paste the appropriate command in to your terminal.
cpanm
cpanm methods::import
CPAN shell
perl -MCPAN -e shell install methods::import
For more information on module installation, please visit the detailed CPAN module installation guide.