view release on metacpan or  search on metacpan

README  view on Meta::CPAN

        Very nifty, it's like Carp::Always but with much more
        options/features (so you don't need a separate Carp::Always::Color,
        Carp::Always::Dump, and so on).

    SQL::Statement
        Author: REHSACK <https://metacpan.org/author/REHSACK>

        The concept is truly cool, unfortunately the parser is currently
        flaky/buggy: one SQL query might work but another valid and
        seemingly simple SQL would fail with weird error message. See
        distribution's RT queue. <br>

        Rating: 6/10

    PerlMongers::Hannover
        Author: PTC <https://metacpan.org/author/PTC>

        Instead of just printing some info, why not make it an Acme::PM or
        Acme::PerlMongers like Acme::CPANAuthors? Various stats can then be
        produced about the various Perl Mongers. <br>

    App::multiwhich
        Note that File::Which can also search for all matches too if you use
        it in a list context, e.g. @paths = which('foo'). File::Which also
        comes with a pwhich CLI utility which also accepts multiple
        arguments and has the -a switch to print all matches. The output
        format is slightly different than 'multiwhich' though. <br><br>In
        fact, the Unix 'which' command (or at least its Debian variant) also
        sports the -a switch.

    Object::Anon
        Author: ROBN <https://metacpan.org/author/ROBN>

        Nice idea. Some notes: 1) to be widely used, it really needs to be
        very efficient; 2) if the goal is simply to objectify a hash,
        perhaps Hash::Objectify or Object::From::Hash or Hash::To::Object
        (or Data::Objectify and so on) is a more descriptive name. <br>

    Data::Seek
        The &quot;extremely fast and efficient&quot; claim currently doesn't
        hold, as this module creates a *whole* flattened tree for *every*
        search operation. <br><br>A simple benchmark: <br><br>### <br> use
        Benchmark qw(timethese); <br> use Data::Seek; <br> use Data::DPath
        qw(dpath); <br> use JSON::Path; <br><br>my $data = { map { $_ =&gt;
        {map {$*=&gt;[1..4]} 1..20} } &quot;a&quot;..&quot;z&quot; };
        <br><br>timethese(-0.25, { <br><br>dseek =&gt; sub { $ds =
        Data::Seek-&gt;new(data=&gt;$data);
        $ds-&gt;search(&quot;j.1.\@&quot;)-&gt;data },
        <br><br>dseek*cacheobj=&gt;sub{ state
        $ds=Data::Seek-&gt;new(data=&gt;$data);
        $ds-&gt;search(&quot;j.1.\@&quot;)-&gt;data },
        <br><br>dpath=&gt;sub{ dpath(&quot;/j/1/*&quot;)-&gt;match($data) },
        <br><br>jpath=&gt;sub{
        JSON::Path-&gt;new(q[$.j.1.[*]])-&gt;values($data) }, <br> }); <br>
        =head2 #

        <br><br>### <br> Benchmark: running dpath, dseek, dseek_cacheobj,
        jpath for at least 0.25 CPU seconds... <br><br>dpath: 1 wallclock
        secs ( 0.27 usr + 0.00 sys = 0.27 CPU) @ 8292.59/s (n=2239)
        <br><br>(warning: too few iterations for a reliable count)
        <br><br>dseek: 1 wallclock secs ( 0.29 usr + 0.00 sys = 0.29 CPU) @
        37.93/s (n=11) <br><br>(warning: too few iterations for a reliable
        count) <br> dseek_cacheobj: 0 wallclock secs ( 0.33 usr + 0.00 sys =
        0.33 CPU) @ 42.42/s (n=14) <br><br>(warning: too few iterations for
        a reliable count) <br><br>jpath: 0 wallclock secs ( 0.27 usr + 0.00
        sys = 0.27 CPU) @ 11711.11/s (n=3162) <br><br>(warning: too few
        iterations for a reliable count) <br> =head2 #

        <br><br>Also: 1) the syntax is rather inconsistent: ':n' for array
        index access, but '.@' (instead of ':@') for grabbing all elements.
        2) currently cannot select subtree (must always select leaf node).
        <br><br>As alternatives, I recommend the much simpler JSON::Path, or
        the more powerful Data::DPath. <br>

    Games::2048
        Author: BLAIZER <https://metacpan.org/author/BLAIZER>

        My favorite 2048 implementation (it's text-mode, written in Perl,
        uses my module Color::ANSI::Util, and what else... oh yeah, it's the
        only implementation where I've reached 2048 :-) ). <br><br>One tip:
        enlarge the fonts of your terminal emulator (e.g. Ctrl-+ on Konsole)
        until it's big and convenient enough.

    App::D
        Author: BESSARABV <https://metacpan.org/author/BESSARABV>

        As an alternative, one can also do: <br><br>alias d=' <br><br>TZ=UTC
        date; # show date in UTC <br><br>date ; # show date in local
        timezone <br><br>cal -3 ; # show monthly calendar for curmon-1,
        curmon, curmon+1 <br> ' <br><br>

    Getopt::Long
        Author: JV <https://metacpan.org/author/JV>

        Having worked for quite some time with option processing and several
        other similar modules, I have to say that most of the time you
        probably want to use Getopt::Long instead of the other alternatives.
        Or at least pick the alternatives which are based on Getopt::Long,
        instead of those that reinvent the wheel and do their own option
        parsing. <br><br>Most other modules that reinvent option parsing
        either don't bother to do short option bundling (-abc instead of -a
        -b -c), or abbreviation (--long-o instead --long-option-name), or
        the choice to (dis)allow mix-mashing options and arguments, or
        support '--' to end option processing, or respect ordering, or
        support multiple options (--verbose --verbose), or support
        '--foo=val' *as well as* '--foo val', and so on. These are features
        and conveniences that are taken for granted by people working daily
        in Unix command-line. <br>

    Text::Table::Tiny
        Author: NEILB <https://metacpan.org/author/NEILB>

        Very fast, several times faster than Text::TabularDisplay or
        Text::Table (and many times faster than the other slower
        table-generator modules). It uses sprintf() to format a whole row
        instead of formatting each cell separately using sprintf() and
        joining cells together with join(). <br><br>I did a comparison in:
        <a
        href="http://blogs.perl.org/users/steven_haryanto/2014/07/benchmarki
        ng-several-ascii-table-generator-modules.html"
        rel="nofollow">blogs.perl.org/users/steven_haryanto/...</a>

    Mo  Author: TINITA <https://metacpan.org/author/TINITA>

        A great alternative when Moo is a bit too much for you. Useful for
        scripts that must start really fast. Mind you, Moo loads about 5K
        lines of code and more than a dozen files, all of which takes +-