data::dumper::concise::sugar(3) [mojave man page]

Data::Dumper::Concise::Sugar(3) 			User Contributed Perl Documentation			   Data::Dumper::Concise::Sugar(3)

NAME

       Data::Dumper::Concise::Sugar - return Dwarn @return_value

SYNOPSIS

	 use Data::Dumper::Concise::Sugar;

	 return Dwarn some_call(...)

       is equivalent to:

	 use Data::Dumper::Concise;

	 if (wantarray) {
	    my @return = some_call(...);
	    warn Dumper(@return);
	    return @return;
	 } else {
	    my $return = some_call(...);
	    warn Dumper($return);
	    return $return;
	 }

       but shorter. If you need to force scalar context on the value,

	 use Data::Dumper::Concise::Sugar;

	 return DwarnS some_call(...)

       is equivalent to:

	 use Data::Dumper::Concise;

	 my $return = some_call(...);
	 warn Dumper($return);
	 return $return;

       If you need to force list context on the value,

	 use Data::Dumper::Concise::Sugar;

	 return DwarnL some_call(...)

       is equivalent to:

	 use Data::Dumper::Concise;

	 my @return = some_call(...);
	 warn Dumper(@return);
	 return @return;

       If you want to label your output, try DwarnN

	 use Data::Dumper::Concise::Sugar;

	 return DwarnN $foo

       is equivalent to:

	 use Data::Dumper::Concise;

	 my @return = some_call(...);
	 warn '$foo => ' . Dumper(@return);
	 return @return;

       If you want to output a reference returned by a method easily, try $Dwarn

	$foo->bar->{baz}->$Dwarn

       is equivalent to:

	 my $return = $foo->bar->{baz};
	 warn Dumper($return);
	 return $return;

       If you want to format the output of your data structures, try DwarnF

	my ($a, $c) = DwarnF { "awesome: $_[0] not awesome: $_[1]" } $awesome, $cheesy;

       is equivalent to:

	 my @return = ($awesome, $cheesy);
	 warn DumperF { "awesome: $_[0] not awesome: $_[1]" } $awesome, $cheesy;
	 return @return;

       If you want to immediately die after outputting the data structure, every Dwarn subroutine has a paired Ddie version, so just replace the
       warn with die.  For example:

	DdieL 'foo', { bar => 'baz' };

DESCRIPTION

	 use Data::Dumper::Concise::Sugar;

       will import Dwarn, $Dwarn, DwarnL, DwarnN, and DwarnS into your namespace. Using Exporter, so see its docs for ways to make it do something
       else.

   Dwarn
	 sub Dwarn { return DwarnL(@_) if wantarray; DwarnS($_[0]) }

   $Dwarn
	 $Dwarn = &Dwarn

   $DwarnN
	 $DwarnN = &DwarnN

   DwarnL
	 sub Dwarn { warn Data::Dumper::Concise::Dumper @_; @_ }

   DwarnS
	 sub DwarnS ($) { warn Data::Dumper::Concise::Dumper $_[0]; $_[0] }

   DwarnN
	 sub DwarnN { warn '$argname => ' . Data::Dumper::Concise::Dumper $_[0]; $_[0] }

       Note: this requires Devel::ArgNames to be installed.

   DwarnF
	 sub DwarnF (&@) { my $c = shift; warn &Data::Dumper::Concise::DumperF($c, @_); @_ }

TIPS AND TRICKS

   global usage
       Instead of always just doing:

	 use Data::Dumper::Concise::Sugar;

	 Dwarn ...

       We tend to do:

	 perl -MData::Dumper::Concise::Sugar foo.pl

       (and then in the perl code:)

	 ::Dwarn ...

       That way, if you leave them in and run without the "use Data::Dumper::Concise::Sugar" the program will fail to compile and you are less
       likely to check it in by accident.  Furthmore it allows that much less friction to add debug messages.

   method chaining
       One trick which is useful when doing method chaining is the following:

	 my $foo = Bar->new;
	 $foo->bar->baz->Data::Dumper::Concise::Sugar::DwarnS->biff;

       which is the same as:

	 my $foo = Bar->new;
	 (DwarnS $foo->bar->baz)->biff;

SEE ALSO

       You probably want Devel::Dwarn, it's the shorter name for this module.

perl v5.18.2							    2013-12-31					   Data::Dumper::Concise::Sugar(3)

Data::Dumper::Concise(3)				User Contributed Perl Documentation				  Data::Dumper::Concise(3)

NAME

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

SYNOPSIS

	 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;
	   warn Dumper($var);
	 }

       So for the structure:

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

       Data::Dumper::Concise will give you:

	 {
	   foo => "bar
baz",
	   quux => sub {
	       use warnings;
	       use strict 'refs';
	       'fleem';
	   }
	 }

       instead of the default Data::Dumper output:

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

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

       If you need to get the underlying Dumper object just call "DumperObject".

       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);

DESCRIPTION

       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?".

BUT BUT BUT ...
       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.

SUGARY SYNTAX

       This package also provides:

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

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

SEE ALSO

       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.

AUTHOR

       mst - Matt S. Trout <mst@shadowcat.co.uk>

CONTRIBUTORS

       frew - Arthur Axel "fREW" Schmidt <frioux@gmail.com>

COPYRIGHT

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

LICENSE

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

perl v5.18.2							    2013-12-31						  Data::Dumper::Concise(3)