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".