From: Arthur Axel 'fREW' Schmidt <frioux@gmail.com>
Date: Wed, 21 Apr 2010 05:06:04 +0000 (-0500)
Subject: document DwarnL and ::Dwarn
X-Git-Tag: v2.000~4
X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=commitdiff_plain;h=13b908a8bb2c12f572dffcf9e096fabf8a7b2b3b;p=p5sagit%2FData-Dumper-Concise.git

document DwarnL and ::Dwarn
---

diff --git a/lib/Data/Dumper/Concise/Sugar.pm b/lib/Data/Dumper/Concise/Sugar.pm
index 7405ba8..9394935 100644
--- a/lib/Data/Dumper/Concise/Sugar.pm
+++ b/lib/Data/Dumper/Concise/Sugar.pm
@@ -29,9 +29,15 @@ is equivalent to:
 
   use Data::Dumper::Concise;
 
-  my @return = some_call(...);
-  warn Dumper(@return);
-  return @return;
+  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,
 
@@ -47,32 +53,74 @@ is equivalent to:
   warn Dumper($return);
   return $return;
 
-Another trick that is extremely useful when doing method chaining is the
-following:
+If you need to force list context on the value,
 
-  my $foo = Bar->new;
-  $foo->bar->baz->Data::Dumper::Concise::Sugar::DwarnS->biff;
+  use Data::Dumper::Concise::Sugar;
 
-which is the same as:
+  return DwarnL some_call(...)
 
-  my $foo = Bar->new;
-  (DwarnS $foo->bar->baz)->biff;
+is equivalent to:
+
+  use Data::Dumper::Concise;
+
+  my @return = some_call(...);
+  warn Dumper(@return);
+  return @return;
 
 =head1 DESCRIPTION
 
   use Data::Dumper::Concise::Sugar;
 
-will import Dwarn and DwarnS into your namespace. Using L<Exporter>, so see
+will import Dwarn, DwarnL, and DwarnS into your namespace. Using L<Exporter>, so see
 its docs for ways to make it do something else.
 
 =head2 Dwarn
 
+  sub Dwarn { return DwarnL(@_) if wantarray; DwarnS($_[0]) }
+
+=head2 DwarnL
+
   sub Dwarn { warn Data::Dumper::Concise::Dumper @_; @_ }
 
-=head3 DwarnS
+=head2 DwarnS
 
   sub DwarnS ($) { warn Data::Dumper::Concise::Dumper $_[0]; $_[0] }
 
+=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<< 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.
+
+=head2 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;
+
 =head1 SEE ALSO
 
 You probably want L<Devel::Dwarn>, it's the shorter name for this module.
diff --git a/lib/Devel/Dwarn.pm b/lib/Devel/Dwarn.pm
index c522a11..7f32a10 100644
--- a/lib/Devel/Dwarn.pm
+++ b/lib/Devel/Dwarn.pm
@@ -11,8 +11,7 @@ sub import {
 Devel::Dwarn - return Dwarn @return_value
 
 =head1 SYNOPSIS
-
-  use Devel::Dwarn;
+  use Data::Dumper::Concise::Sugar;
 
   return Dwarn some_call(...)
 
@@ -20,13 +19,19 @@ is equivalent to:
 
   use Data::Dumper::Concise;
 
-  my @return = some_call(...);
-  warn Dumper(@return);
-  return @return;
+  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 Devel::Dwarn;
+  use Data::Dumper::Concise::Sugar;
 
   return DwarnS some_call(...)
 
@@ -38,8 +43,45 @@ is equivalent to:
   warn Dumper($return);
   return $return;
 
-Another trick that is extremely useful when doing method chaining is the
-following:
+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;
+
+=head1 TIPS AND TRICKS
+
+=head2 global usage
+
+Instead of always just doing:
+
+  use Devel::Dwarn;
+
+  Dwarn ...
+
+We tend to do:
+
+  perl -MDevel::Dwarn foo.pl
+
+(and then in the perl code:)
+
+  ::Dwarn ...
+
+That way, if you leave them in and run without the C<< use Devel::Dwarn >>
+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->new;
   $foo->bar->baz->Devel::Dwarn::DwarnS->biff;