view release on metacpan or  search on metacpan

README  view on Meta::CPAN

        A couple of prior arts: <br><br>* all, <a
        href="https://metacpan.org/pod/all"
        rel="nofollow">metacpan.org/pod/all</a> (since 2003), nicer
        interface and offers &quot;use&quot;/compile-time interface, so it's
        more equivalent to the statements it wants to replace. The
        Submodules equivalent would be: BEGIN { for my $i
        (Submodules-&gt;find(&quot;Blah&quot;)) { $i-&gt;require } }.
        <br><br>* Module::Require, <a
        href="https://metacpan.org/pod/Module::Require"
        rel="nofollow">metacpan.org/pod/Module::Require</a> (since 2001),
        also nicer interface, more flexible, and more lightweight
        implementation. <br><br>I don't like Submodules' interface, it's too
        verbose and clunky. IMO, the interface should be a one-liner and
        without manual looping.

    Regexp::Assemble
        Author: RSAVAGE <https://metacpan.org/author/RSAVAGE>

        I guess it depends on your data, but for random shortish strings
        (hundreds to thousands of them), I find that using raw joining is
        much faster to assemble the regex. And the resulting regex is also
        (much) faster to match. Please see Bencher::Scenario::RegexpAssemble
        if you're interested in the benchmark script.

    Tie::Scalar::Callback
        Author: DFARRELL <https://metacpan.org/author/DFARRELL>

        There is a prior art Tie::Simple (created in 2004) which works for
        scalar as well as the other types of ties that perl supports (array,
        hash, handle). <br>

    JSON::Create
        Author: BKB <https://metacpan.org/author/BKB>

        Review for 0.02: Performance-wise, still has some catching up to do
        against JSON::XS &amp; Cpanel::JSON::XS with regards to encoding
        arrays &amp; hashes. <br><br>UPDATE review for 0.19: Giving it 4
        stars now. Speed has been improving and on-par/slightly better than
        the other JSON XS modules in some areas, while a bit worse in some
        other areas. Faster modules are always welcome.

        Rating: 8/10

    Set::Scalar
        Author: DAVIDO <https://metacpan.org/author/DAVIDO>

        Confirming previous reviewer, the module is a lot slower (~ 20-40x)
        than other alternatives like Array::Utils or List::MoreUtils when
        you want to perform basic set operations like
        union/intersect/diff/symmetric diff.

    Exporter::Easy
        Author: NEILB <https://metacpan.org/author/NEILB>

        I can see the value of Exporter::Easy (although these days the
        saving in typing is not as big, with plain Exporter one can just
        say: use Exporter 'import'; our @EXPORT = qw(a b c)).
        <br><br>However I fail to see the value of Exporter::Easiest. I'd
        rather use plain Perl than some DDL which cannot be checked
        statically or cannot be syntax-highlighted, just to save some []'s
        and ()'s (which I can get my editor to help me type them).
        <br><br>In short, I'd rather use plain Exporter than save a few
        keystrokes but add a non-core dependency.

        Rating: 6/10

    App::cpm
        Author: SKAJI <https://metacpan.org/author/SKAJI>

        Due to parallel processes and defaulting on no_test, can be several
        times faster than cpanminus (tried installing a module on a vanilla
        perlbrew instance with local CPAN mirror, which pulled +- 200
        distributions, &quot;cpanm -n&quot; took 2m9s, while cpm took 38s.)
        I hope this gets developed further. Great job. <br>

    Zodiac::Chinese
        Author: CAVAC <https://metacpan.org/author/CAVAC>

        From the doc: &quot;This module generates one's Chinese zodiac.
        However, for those born in late January to early February, it may be
        wrong.&quot; Well, a module that might return wrong results is not
        very useful. <br>

        Rating: 2/10

    JSON::MultiValueOrdered
        Author: TOBYINK <https://metacpan.org/author/TOBYINK>

        I guess if you want to switch JSON implementation more easily with
        JSON, JSON::PP, and JSON::XS, it's better to use
        JSON::Tiny::Subclassable instead of JSON::Tiny, because the
        interface is more similar to JSON{::XS,::PP}, although it's not
        exactly the same. JT:Subclassable also supports pretty() which is
        often used when debugging. In short, I found
        JSON::Tiny::Subclassable is a better &quot;Tiny JSON&quot; module
        than JSON::Tiny.

    JSON::Tiny
        Author: DAVIDO <https://metacpan.org/author/DAVIDO>

        Ah, the many JSON implementation modules out there... <br><br>I
        guess if you want to switch JSON implementation more easily with
        JSON, JSON::PP, and JSON::XS, it's better to use
        JSON::Tiny::Subclassable instead of JSON::Tiny, because the
        interface is more similar to JSON{::XS,::PP}, although it's not
        exactly the same. <br><br>

    Devel::Confess
        Author: HAARG <https://metacpan.org/author/HAARG>

        Provides some more features compared to Carp::Always, like producing
        stack trace even when exception is ref/object, color &amp; dump
        function arguments (so you don't need a separate Carp::Always::Dump
        and Carp::Always::Color). Recommended. <br>

    Carp::Always
        Author: FERREIRA <https://metacpan.org/author/FERREIRA>

        This module works well for string exceptions (e.g. die &quot;some
        message&quot;), but for ref/object exceptions (e.g. die
        [404,&quot;Not found&quot;] or die $some_object) it will simply