Data::Dumper::Concise - Less indentation and newlines plus sub deparsing

      use Data::Dumper::Concise;

      warn Dumper($var);

    is equivalent to:

      use Data::Dumper;
        local $Data::Dumper::Terse = 1;
        local $Data::Dumper::Indent = 1;
        local $Data::Dumper::Useqq = 1;
        local $Data::Dumper::Deparse = 1;
        local $Data::Dumper::Quotekeys = 0;
        local $Data::Dumper::Sortkeys = 1;
        local $Data::Dumper::Trailingcomma = 1;
        warn Dumper($var);

    So for the structure:

      { foo => "bar\nbaz", quux => sub { "fleem" } };

    Data::Dumper::Concise will give you:

        foo => "bar\nbaz",
        quux => sub {
            use warnings;
            use strict 'refs';

    instead of the default Data::Dumper output:

      $VAR1 = {
       'quux' => sub { "DUMMY" },
       'foo' => 'bar

    (note the tab indentation, oh joy ...)

    (The trailing comma on the last element of an array or hash is enabled
    by a new feature in Data::Dumper version 2.159, which was first released
    in Perl 5.24. Using Data::Dumper::Concise with an older version of
    Data::Dumper will still work, but you won't get those commas.)

    If you need to get the underlying Dumper object just call

    Also try out "DumperF" which takes a "CodeRef" as the first argument to
    format the output. For example:

      use Data::Dumper::Concise;

      warn DumperF { "result: $_[0] result2: $_[1]" } $foo, $bar;

    Which is the same as:

      warn 'result: ' . Dumper($foo) . ' result2: ' . Dumper($bar);

    This module always exports a single function, Dumper, which can be
    called with an array of values to dump those values.

    It exists, fundamentally, as a convenient way to reproduce a set of
    Dumper options that we've found ourselves using across large numbers of
    applications, primarily for debugging output.

    The principle guiding theme is "all the concision you can get while
    still having a useful dump and not doing anything cleverer than setting
    Data::Dumper options" - it's been pointed out to us that
    Data::Dump::Streamer can produce shorter output with less lines of code.
    We know. This is simpler and we've never seen it segfault. But for
    complex/weird structures, it generally rocks. You should use it as well,
    when Concise is underkill. We do.

    Why is deparsing on when the aim is concision? Because you often want to
    know what subroutine refs you have when debugging and because if you
    were planning to eval this back in you probably wanted to remove subrefs
    first and add them back in a custom way anyway. Note that this -does-
    force using the pure perl Dumper rather than the XS one, but I've never
    in my life seen Data::Dumper show up in a profile so "who cares?".

    Yes, we know. Consider this module in the ::Tiny spirit and feel free to
    write a Data::Dumper::Concise::ButWithExtraTwiddlyBits if it makes you
    happy. Then tell us so we can add it to the see also section.

    This package also provides:

    Data::Dumper::Concise::Sugar - provides Dwarn and DwarnS convenience

    Devel::Dwarn - shorter form for Data::Dumper::Concise::Sugar

    We use for some purposes, and dearly love, the following alternatives:

    Data::Dump - prettiness oriented but not amazingly configurable

    Data::Dump::Streamer - brilliant. beautiful. insane. extensive.
    excessive. try it.

    JSON::XS - no, really. If it's just plain data, JSON is a great option.

    mst - Matt S. Trout <>

    frew - Arthur Axel "fREW" Schmidt <>

    Copyright (c) 2010 the Data::Dumper::Concise "AUTHOR" and "CONTRIBUTORS"
    as listed above.

    This library is free software and may be distributed under the same
    terms as perl itself.