Image

head

code

Html

root

para

L<Examples| file:../examples/index.podlite>


L<Download |file:../download/index.podlite>


React

=begin React :component<HeaderCol> :id<menu> 
=para L<Documentation|/doc/introduction>
=para L<Modules| /mods>
=para L<Examples| file:../examples/index.podlite>
=para L<Download |file:../download/index.podlite>
=para L<About|file:../about/index.podlite>
=para 🔍 K<⌘K>/K<ctrl-K>
=end React


HEADER

FOOTER

README

App::ShowPath - show the contents of the environment variable $PATH, in a browseable table form


=begin code :lang<bash>

$ showpath

=end code


App::ShowPath is a simple script to show the contents of $PATH via Term::TablePrint;


Humberto Massa `humbertomassa@gmail.com`


This library is free software; you can redistribute it and/or modify it under either the Artistic License 2.0 or the LGPL v3.0, at your convenience.



use Term::TablePrint;

multi sub MAIN() is export {
  print-table (['path'], |%*ENV<PATH>.split(':').map: { [ $_, ] }) if $*OUT.t
}



ShowPath

unit module App::SerializerPerf:auth<zef:japhb>:api<0>:ver<0.0.3>;

# NOTE: To test a structure pulled from a JSON file, you'll need a JSON test
#       file to work with.  I snapshotted mine from ~/.zef/store/360.zef.pm .


# Parse-only decoders
use JSON::Hjson;
use MessagePack;

# Bidirectional codecs
use BSON::Document;
use BSON::Simple;
use CBOR::Simple;
use Data::MessagePack;
use JSON::Fast;
use YAMLish;

# All used the same exported names
use Config::TOML           Empty;
use TOML:auth<zef:tony-o>  Empty;
use TOML::Thumb            Empty;

# Disambiguate codecs that used the same exported names
constant &config-toml-encode = Config::TOML::EXPORT::DEFAULT::<&to-toml>;
constant &config-toml-decode = Config::TOML::EXPORT::DEFAULT::<&from-toml>;
constant &toml-tony-o-encode = TOML::EXPORT::DEFAULT::<&to-toml>;
constant &toml-tony-o-decode = TOML::EXPORT::DEFAULT::<&from-toml>;
constant &toml-thumb-encode  = TOML::Thumb::EXPORT::DEFAULT::<&to-toml>;
constant &toml-thumb-decode  = TOML::Thumb::EXPORT::DEFAULT::<&from-toml>;


my @fast   = < CBOR::Simple BSON::Simple JSON::Fast >;
my @mpack  = < Data::MessagePack MessagePack >;
my @toml   = < TOML::Thumb TOML(tony-o) Config::TOML >;
my @misc   = < JSON::Hjson BSON::Document .raku/EVAL YAMLish >;
my @order  = (@fast, @mpack, @toml, @misc).flat;
my $length = @order.map(*.chars).max;
my %enabled is Set = @order;


sub time-them(%by-codec) {
    my $count = $*COUNT;
    my $runs  = $*RUNS;
    my %times;

    for ^$runs {
        for @order -> $codec {
            next unless my $test-code := %by-codec{$codec};

            CATCH   { default { } }
            CONTROL { when CX::Warn { .resume }
                      default { } }

            my $ts = now;
            $test-code() for ^$count;
            my $te = now;

            %times{$codec}.append($te - $ts);
        }
    }

    %times
}

sub show-times(Str:D $test, %times) {
    say "\n$test:";
    my $reference;
    for @order -> $codec {
        next unless %times{$codec} && my $fastest = %times{$codec}.min;
        if $reference {
            printf "%-{$length}s  %8.3fs (%.3fx)\n",
                   $codec, $fastest, $fastest / $reference;
        }
        else {
            printf "%-{$length}s  %8.3fs\n", $codec, $fastest;
            $reference = $fastest;
        }
    }
}

sub time-and-show(Str:D $test, %by-codec) {
    show-times($test, time-them(%by-codec));
}

sub show-sizes(%blobs) {
    say "\nSizes:";
    my $reference;
    for @order -> $codec {
        unless my $blob = %blobs{$codec} {
            printf "%-{$length}s  %8s\n", $codec, 'NONE';
            next;
        }

        my $size = $blob.bytes;

        if $reference {
            printf "%-{$length}s  %8d (%.3fx)\n",
                   $codec, $size, $size / $reference;
        }
        else {
            printf "%-{$length}s  %8d\n", $codec, $size;
            $reference = $size;
        }
    }
}

sub show-reliability(%encoders, %decoders) {
    say "\nReliability:";
    for @order -> $codec {
        my @errors;
        if %encoders{$codec} -> $encoder {
            $encoder();
            CATCH   { default { @errors.push: "Encoder failure for $codec:\n{.Str.indent(4)}" } }
            CONTROL { default { @errors.push: "Encoder warning for $codec:\n{.Str.indent(4)}"; .resume } }
        }

        if %decoders{$codec} -> $decoder {
            $decoder();
            CATCH   { default { @errors.push: "Decoder failure for $codec:\n{.Str.indent(4)}" } }
            CONTROL { default { @errors.push: "Decoder warning for $codec:\n{.Str.indent(4)}"; .resume } }
        }

        printf "%-{$length}s  %8s\n", $codec, @errors ?? 'FAIL' !! 'pass';
        .indent(4).say for @errors;
    }
}

sub show-fidelity(%by-codec, $reference) {
    say "\nFidelity:";

    for @order -> $codec {
        next unless my $decoder = %by-codec{$codec};
        my $decoded = try quietly $decoder();

        printf "%-{$length}s  %8s\n",
               $codec, $decoded eqv $reference ?? 'pass' !! 'FAIL';
    }
}


sub time-codecs(Str:D $variant, $struct,
                Bool:D :$size        = True,
                Bool:D :$reliability = True,
                Bool:D :$fidelity    = True,
                Bool:D :$encode      = True,
                Bool:D :$decode      = True,
               ) is export {
    say "\n====> $variant <====";

    use MONKEY-SEE-NO-EVAL;
    my $*BSON_SIMPLE_PLAIN_HASHES = True;
    my $*BSON_SIMPLE_PLAIN_BLOBS  = True;

    my $yaml  = try quietly save-yaml($struct).encode         if %enabled<YAMLish>;
    my $raku  = try quietly $struct.raku.encode               if %enabled<.raku/EVAL>;
    my $json  = try quietly to-json($struct, :!pretty).encode if %enabled<JSON::Fast>;
    my $bson  = try quietly bson-encode { b => $struct }      if %enabled<BSON::Simple>;
    my $cbor  = try quietly cbor-encode $struct               if %enabled<CBOR::Simple>;

    my $doc   = try quietly BSON::Document.new($bson)         if %enabled<BSON::Document>;
    my $doce  = try quietly $doc.encode                       if %enabled<BSON::Document>;

    my $mpack = try quietly Data::MessagePack::pack($struct)  if %enabled<Data::MessagePack>;

    my $toml1 = try quietly config-toml-encode({ t => $struct }).encode if %enabled<Config::TOML>;
    my $toml2 = try quietly toml-tony-o-encode({ t => $struct }).encode if %enabled<TOML(tony-o)>;
    my $toml3 = try quietly toml-thumb-encode( { t => $struct }).encode if %enabled<TOML::Thumb>;

    my %blobs := {
        'JSON::Fast'        => $json,
        'CBOR::Simple'      => $cbor,
        'BSON::Simple'      => $bson,
        'BSON::Document'    => $doce,
        'Data::MessagePack' => $mpack,
        'Config::TOML'      => $toml1,
        'TOML(tony-o)'      => $toml2,
        'TOML::Thumb'       => $toml3,
        '.raku/EVAL'        => $raku,
        'YAMLish'           => $yaml,
    };

    my %encoders := {
        'JSON::Fast'        => { my $j = to-json($struct, :!pretty).encode },
        'CBOR::Simple'      => { my $c = cbor-encode $struct },
        'BSON::Simple'      => { my $b = bson-encode { b => $struct } },
        'BSON::Document'    => { my $d = $doc.encode },
        'Data::MessagePack' => { my $p = Data::MessagePack::pack($struct) },
        'Config::TOML'      => { my $t = config-toml-encode({ t => $struct }).encode },
        'TOML(tony-o)'      => { my $t = toml-tony-o-encode({ t => $struct }).encode },
        'TOML::Thumb'       => { my $t = toml-thumb-encode( { t => $struct }).encode },
        '.raku/EVAL'        => { my $r = $struct.raku.encode },
        'YAMLish'           => { my $y = save-yaml($struct).encode },
    };

    my %decoders := {
        'JSON::Fast'        => { my $j = from-json  $json.decode },
        'JSON::Hjson'       => { my $h = from-hjson $json.decode },
        'CBOR::Simple'      => { my $c = cbor-decode $cbor },
        'BSON::Simple'      => { my $b = bson-decode($bson)<b> },
        'BSON::Document'    => { my $d = BSON::Document.new($doce)<b> },
        'Data::MessagePack' => { my $p = Data::MessagePack::unpack($mpack) },
        'MessagePack'       => { my $p = from-msgpack($mpack) },
        'Config::TOML'      => { my $t = config-toml-decode($toml1.decode)<t> },
        'TOML(tony-o)'      => { my $t = toml-tony-o-decode($toml2.decode)<t> },
        'TOML::Thumb'       => { my $t = toml-thumb-decode( $toml3.decode)<t> },
        '.raku/EVAL'        => { my $r = EVAL $raku.decode },
        'YAMLish'           => { my $y = load-yaml $yaml.decode },
    };

    show-sizes(%blobs)                     if $size;
    show-reliability(%encoders, %decoders) if $reliability;
    show-fidelity(%decoders, $struct)      if $fidelity;
    time-and-show('Encode', %encoders)     if $encode;
    time-and-show('Decode', %decoders)     if $decode;
}




serializer-perf - Performance tests for Raku data serializer codecs


=begin code :lang<shell>

serializer-perf [--runs=UInt] [--count=UInt] [--source=Path]

 --runs=<UInt>    Runs per test (for stable results)
 --count=<UInt>   Encodes/decodes per run (for sufficient duration)
 --source=<Path>  Test file containing JSON data

=end code


C<serializer-perf> is a test suite of performance and correctness (fidelity)
tests for Raku data serializer codecs.  It is currently able to test the
following codecs:


table_head

 ===========================================================================


table_row

table

(Note: C<JSON::Hjson> is a decoder I<only>, and has no native encode ability.
Thus performance and fidelity was tested against inputs in the JSON subset of
Hjson, though of course the point of Hjson is to allow more human-friendly
variation in data formatting -- similar to YAML in that respect.  Similarly,
C<MessagePack> is a decoder only as well, with no native encode ability; it was
tested with data packed by C<Data::MessagePack>.)


Because some of the tests are I<very> slow, the default values for C<--runs>
and C<--count> are 1 and 10 respectively.  If only testing the faster codecs
(those with Speed of Fair or better in the table above), these will be too low;
5 and 100 are more appropriate values in that case.


This library is free software; you can redistribute it and/or modify it under
the Artistic License 2.0.


SerializerPerf

The Raku Knowledge Base


=begin React :component<HeaderCol> :id<footer>  
=begin nested :!nested
=item1 B<Language>
    =item2 L<Get started|file:../getting-started/getting-started.podlite>
    =item2 L<Why Raku?|/doc/language/faq#Why-should-I-learn-Raku-What's-so-great-about-it>
    =item2 L<Try Raku|https://glot.io/new/raku>
    =item2 L<Raku cheat sheet|https://github.com/Raku/mu/blob/master/docs/Perl6/Cheatsheet/cheatsheet.txt>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<Raku on Exercism|https://exercism.org/tracks/raku>
    =item2 L<Wikipedia|https://en.wikipedia.org/wiki/Raku_(programming_language)>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=end nested
=begin nested :!nested

=item1 B<L<Documentation|/doc>>
    =item2 L<Getting started, Migration guides from other languages, & Tutorials | file:../doc/introduction.podlite>
    =item2 L<Language References|file:../doc/reference.podlite>
    =item2 L<Type Reference| file:../doc/types.podlite>
    =item2 L<Miscellaneous| file:../doc/miscellaneous.podlite>
    =item2 L<FAQs (Frequently Asked Questions)|/doc/language/faq>
    =item2 L<Community|/doc/language/community>
    =item2 L<The list of all documents|file:../doc/index.podlite>

=item1 B<Resources>
    =item2 L<The Raku Guide|https://raku.guide/>
    =item2 L<Books |https://perl6book.com/>
    =item2 L<Rosetta Code | https://www.raku.org/community/rosettacode>

=end nested
=begin nested :!nested

=item1 B<Resoures>
    =item2 L<Download | file:../download/index.podlite>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=item1 B<Learning>
    =item2 L<The Raku Guide|https://raku.guide/>
    =item2 L<Wikibook |https://en.wikibooks.org/wiki/Raku_Programming>
    =item2 L<Books |https://perl6book.com/>
    =item2 L<Rosetta Code | https://www.raku.org/community/rosettacode>
    =item2 L<Learn Raku in Y minutes|https://learnxinyminutes.com/docs/raku/>
    =item2 L<Golfing |https://github.com/AlexDaniel/raku-golf-cheatsheet>
=end nested
=begin nested :!nested

=item1 B<Explore>
    =item2 L<Raku Blog Aggregator|https://planet.raku.org/>
    =item2 L<Rakudo Weekly|https://rakudoweekly.blog/>
    =item2 L<The Weekly Challenge |https://perlweeklychallenge.org/>
    =item2 L<Raku Advent Calendar|https://raku-advent.blog/>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=end nested
=end React


=begin React :component<CookieConsent> :id<CookieConsent> :buttonCaption("Got it!")
=para
This website uses cookies for analytics.
=end React


README

NAME

SYNOPSIS

DESCRIPTION

AUTHOR

COPYRIGHT AND LICENSE

App::SerializerPerf v0.0.3

Authors

License

Dependencies

Test Dependencies

Provides

Documentation