NAME methods::import - import methods to be used like keywords SYNOPSIS The following calls `get` on the $ua object. 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/'; }; DESCRIPTION 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`. `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; }; Renaming Imports 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; }; How `using` Works 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`. 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(); Nested Imports 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(); }; }; Currying 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. Prototypes 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 Call Stack methods::import doesn't make any attempt to hide the wrapper functions it exports. They will show up on the call stack. Lexical Exports 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`: { 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 }, ); Inheriting from `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`. 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/'; BUGS Please report any bugs to . SEE ALSO `with`. AUTHOR Toby Inkster . COPYRIGHT AND LICENCE 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. DISCLAIMER OF WARRANTIES 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.