Ubuntu Manpage: Data::Dmp - Dump Perl data structures as Perl code

Provided by: libdata-dmp-perl_0.14-1_all

NAME

       Data::Dmp - Dump Perl data structures as Perl code

VERSION

       This document describes version 0.14 of Data::Dmp (from Perl distribution Data-Dmp),
       released on 2015-12-27.

SYNOPSIS

        use Data::Dmp; # exports dd() and dmp()
        dd [1, 2, 3]; # prints "[1,2,3]"
        $a = dmp({a => 1}); # -> "{a=>1}"

DESCRIPTION

       Data::Dmp is a Perl dumper like Data::Dumper. It's compact (only about 150 lines of code
       long), starts fast and does not use other module except Regexp::Stringify when dumping
       regexes. It produces compact output (similar to Data::Dumper::Concise). It roughly has the
       same speed as Data::Dumper (usually a bit faster for smaller structures), but does not
       offer the various formatting options. It supports dumping objects, regexes, circular
       structures, coderefs. Its code is based on Data::Dump.

FUNCTIONS

   dd($data, ...) => $data ...
       Exported by default. Like "Data::Dump"'s "dd" (a.k.a. "dump"), print one or more data to
       STDOUT. Unlike "Data::Dump"'s "dd", it always prints and return the original data (like
       XXX), making it convenient to insert into expressions. This also removes ambiguity and
       saves one "wantarray()" call.

   dmp($data, ...) => $str
       Exported by default. Return dump result as string. Unlike "Data::Dump"'s "dd" (a.k.a.
       "dump"), it never prints and only return the data.

SETTINGS

   $Data::Dmp::OPT_PERL_VERSION => str (default: 5.010)
       Set target Perl version. If you set this to, say 5.010, then the dumped code will keep
       compatibility with Perl 5.10.0. This is used in the following ways:

       •   passed to Regexp::Stringify

       •   when dumping code references

           For example, in perls earlier than 5.016, feature.pm does not understand:

            no feature ':all';

           so we replace it with:

            no feature;

   $Data::Dmp::OPT_REMOVE_PRAGMAS => bool (default: 0)
       If set to 1, then pragmas at the start of coderef dump will be removed. Coderef dump is
       produced by B::Deparse and is of the form like:

        sub { use feature 'current_sub', 'evalbytes', 'fc', 'say', 'state', 'switch', 'unicode_strings', 'unicode_eval'; $a <=> $b }

       If you want to dump short coderefs, the pragmas might be distracting. You can turn turn on
       this option which will make the above dump become:

        sub { $a <=> $b }

       Note that without the pragmas, the dump might be incorrect.

BENCHMARKS

        [1..10]:
                              Rate  Data::Dump Data::Dumper Data::Dmp
        Data::Dump     28356+-42/s          --       -66.8%    -77.5%
        Data::Dumper  85500+-290/s 201.5+-1.1%           --    -32.3%
        Data::Dmp    126260+-210/s  345.26+-1% 47.67+-0.56%        --

        [1..100]:
                               Rate   Data::Dump Data::Dumper Data::Dmp
        Data::Dump    3449.1+-5.1/s           --       -77.4%    -78.3%
        Data::Dumper    15252+-31/s  342.2+-1.1%           --     -4.1%
        Data::Dmp    15905.9+-5.8/s 361.16+-0.7%  4.29+-0.22%        --

        Some mixed structure:
                            Rate    Data::Dump    Data::Dmp Data::Dumper
        Data::Dump    7840+-13/s            --       -74.1%       -79.2%
        Data::Dmp    30302+-42/s 286.49+-0.83%           --       -19.5%
        Data::Dumper 37637+-72/s     380+-1.2% 24.21+-0.29%           --

FAQ

When to use Data::Dmp? How does it compare to other dumper modules?
Data::Dmp might be suitable for you if you want a relatively fast pure-Perl data structure
dumper to eval-able Perl code. It produces compact, single-line Perl code but offers
little/no formatting options. Data::Dmp and Data::Dump module family usually produce Perl
code that is "more eval-able", e.g. it can recreate circular structure.

Data::Dump produces nicer output (some alignment, use of range operator to shorten lists,
use of base64 for binary data, etc) but no built-in option to produce compact/single-line
output. It's also relatively slow. I usually use its variant, Data::Dump::Color, for
console debugging.

Data::Dumper is core module, offers a lot of formatting options (like disabling hash key
sorting, setting verboseness/indent level, and so on) but you usually have to configure it
quite a bit before it does exactly like you want (that's why there are modules on CPAN
that are just wrapping Data::Dumper with some configuration, like Data::Dumper::Concise et
al). It does not support dumping Perl code that can recreate circular structures.

Of course, dumping to eval-able Perl code is slow (not to mention the cost of re-loading
the code back to in-memory data, via eval-ing) compared to dumping to JSON, YAML, Sereal,
or other format. So you need to decide first whether this is the appropriate route you
want to take. (But note that there is also Data::Dumper::Limited and Data::Undump which
uses a format similar to Data::Dumper but lets you load the serialized data without eval-
ing them, thus achieving the speed comparable to JSON::XS).

HOMEPAGE

       Please visit the project's homepage at <https://metacpan.org/release/Data-Dmp>.

SOURCE

       Source repository is at <https://github.com/perlancar/perl-Data-Dmp>.

BUGS

       Please report any bugs or feature requests on the bugtracker website
       <https://rt.cpan.org/Public/Dist/Display.html?Name=Data-Dmp>

       When submitting a bug or request, please include a test-file or a patch to an existing
       test-file that illustrates the bug or desired feature.

AUTHOR

       perlancar <perlancar@cpan.org>

COPYRIGHT AND LICENSE

       This software is copyright (c) 2015 by perlancar@cpan.org.

       This is free software; you can redistribute it and/or modify it under the same terms as
       the Perl 5 programming language system itself.