Ports Search

This module was written because I stumbled on some serious issues of Readonly that aren't easily fixable without breaking backwards compatibility in subtle ways. In particular Readonly's use of ties is a source of subtle bugs and bad performance. Instead, this module uses the builtin readonly feature of perl, making access to the variables just as fast as any normal variable without the weird side-effects of ties. Readonly can do the same for scalars when Readonly::XS is installed, but chooses not to do so in the most common case.

File::Find::Object does same job as File::Find but works like an object and with an iterator. As File::Find is not object oriented, one cannot perform multiple searches in the same application. The second problem of File::Find is its file processing: after starting its main loop, one cannot easily wait for another event an so get the next result. With File::Find::Object you can get the next file by calling the next() function, but setting a callback is still possible.

LV makes lvalue subroutines easy and practical to use. It's inspired by the lvalue module which is sadly problematic because of the existence of another module on CPAN called Lvalue. (They can get confused on file-systems that have case-insensitive file names.) LV comes with three different implementations, based on Variable::Magic, Sentinel and tie; it will choose and use the best available one. You can force LV to pick a particular implementation using: $ENV{PERL_LV_IMPLEMENTATION} = 'Magic'; # or 'Sentinel' or 'Tie' The tie implementation is the slowest, but will work on Perl 5.6 with only core modules.

Lexical::Persistence does a few things, all related. Note that all the behaviors listed here are the defaults. Subclasses can override nearly every aspect of Lexical::Persistence's behavior. Lexical::Persistence lets your code access persistent data through lexical variables. This example prints "some value" because the value of $x persists in the $lp object between setter() and getter(). use Lexical::Persistence; my $lp = Lexical::Persistence->new(); $lp->call(\&setter); $lp->call(\&getter); sub setter { my $x = "some value" } sub getter { print my $x, "\n" }

The types provided with Moose are by design global. This package helps you to organise and selectively import your own and the built-in types in libraries. As a nice side effect, it catches typos at compile-time too. However, the main reason for this module is to provide an easy way to not have conflicts with your type names, since the internal fully qualified names of the types will be prefixed with the library's name. This module will also provide you with some helper functions to make it easier to use Moose types in your code.

Sub::Exporter is an incredibly powerful module, but with that power comes great responsibility, er- as well as some runtime penalties. This module is a Sub::Exporter wrapper that will let your users just use Exporter if all they are doing is picking exports, but use Sub::Exporter if your users try to use Sub::Exporter's more advanced features features, like renaming exports, if they try to use them. Note that this module will export @EXPORT and @EXPORT_OK package variables for Exporter to work. Additionally, if your package uses advanced Sub::Exporter features like currying, this module will only ever use Sub::Exporter, so you might as well use it directly.

Progress bars are handy - they tell you how much work has been done, how much is left to do and estimate how long it will take. But they can be fiddly! This module does the right thing in almost all cases in a really convenient way. It wraps Term::ProgressBar::Quiet so there is no output unless the code is running interactively - lets you put them in cron scripts. It deals with minor updates - only refreshes the screen when it will change what the user sees so it is efficient. It completes the progress bar when the progress object is destroyed (explicitly or by going out of scope) - no more '99%' done.

Sometimes you want to make sure that your "faster" algorithm really is faster than the old way. This lets you check. It might also be useful to check that your super whizzo XS or Inline::C version is actually faster. This module is based on the standard Benchmark module. If you have lots of timings to compare and you don't want to keep running the same benchmarks all the time, you can pass in a result object from Benchmark::timethis() instead of sub routine reference.

Test::Modern provides the best features of Test::More, Test::Fatal, Test::Warnings, Test::API, Test::LongString, and Test::Deep, as well as ideas from Test::Requires, Test::DescribeMe, Test::Moose, and Test::CleanNamespaces. Test::Modern also automatically imposes strict and warnings on your script, and loads IO::File. (Much of the same stuff Modern::Perl does.) Although Test::Modern is a modern testing framework, it should run fine on pre-modern versions of Perl. It should be easy to install on Perl 5.8.9 and above; and if you can persuade its dependencies to install (not necessarily easy!), should be OK on anything back to Perl 5.6.1.

Class names in Perl often don't sound great when spoken, or look good when written in prose. For this reason, we tend to say things like "customer" or "basket" when we are referring to My::Site::User::Customer or My::Site::Shop::Basket. We thought it would be nice if our classes knew what we would prefer to call them. This module will add a moniker (and plural_moniker) method to UNIVERSAL, and so to every class or module. So, if $ob->isa("Big::Scary::Animal"), moniker will return "animal"; $ob->isa("Cephalopod::Octopus"), plural_moniker will return "octopuses".