<html><head><meta name="color-scheme" content="light dark"></head><body><pre style="word-wrap: break-word; white-space: pre-wrap;">package Data::Dumper::Concise::Sugar;

use 5.006;

use Exporter ();
use Data::Dumper::Concise ();

BEGIN { @ISA = qw(Exporter) }

@EXPORT = qw(
   $Dwarn $DwarnN Dwarn DwarnS DwarnL DwarnN DwarnF
   $Ddie $DdieN Ddie DdieS DdieL DdieN DdieD
);

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

our $Dwarn = \&amp;Dwarn;
our $DwarnN = \&amp;DwarnN;

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

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

sub DwarnN ($) {
   require Devel::ArgNames;
   my $x = Devel::ArgNames::arg_names();
   warn(($x?$x:'(anon)') . ' =&gt; ' . Data::Dumper::Concise::Dumper $_[0]); $_[0]
}

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

sub Ddie { DdieL(@_) if wantarray; DdieS($_[0]) }

our $Ddie = \&amp;Ddie;
our $DdieN = \&amp;DdieN;

sub DdieL { die Data::Dumper::Concise::Dumper @_ }

sub DdieS ($) { die Data::Dumper::Concise::Dumper $_[0] }

sub DdieN ($) {
   require Devel::ArgNames;
   my $x = Devel::ArgNames::arg_names();
   die(($x?$x:'(anon)') . ' =&gt; ' . Data::Dumper::Concise::Dumper $_[0]);
}

=head1 NAME

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

=head1 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 =&gt; ' . Dumper(@return);
  return @return;

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

 $foo-&gt;bar-&gt;{baz}-&gt;$Dwarn

is equivalent to:

  my $return = $foo-&gt;bar-&gt;{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 =&gt; 'baz' };

=head1 DESCRIPTION

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

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

=head2 Dwarn

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

=head2 $Dwarn

  $Dwarn = \&amp;Dwarn

=head2 $DwarnN

  $DwarnN = \&amp;DwarnN

=head2 DwarnL

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

=head2 DwarnS

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

=head2 DwarnN

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

B&lt;Note&gt;: this requires L&lt;Devel::ArgNames&gt; to be installed.

=head2 DwarnF

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

=head1 TIPS AND TRICKS

=head2 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
C&lt;&lt; use Data::Dumper::Concise::Sugar &gt;&gt; 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.

=head2 method chaining

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

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

which is the same as:

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

=head1 SEE ALSO

You probably want L&lt;Devel::Dwarn&gt;, it's the shorter name for this module.

=cut

1;
</pre></body></html>