---
name: "Data::Dumper::Concise::Sugar"
section: "3pm"
platform: "linux"
package: "libdata-dumper-concise-perl"
version: "2.023-3"
release: "Debian 13 (Trixie)"
platforms: ["linux"]
url: "https://new.carta.tech/Data::Dumper::Concise::Sugar"
---

# Data::Dumper::Concise::Sugar(3pm)

return Dwarn @return\_value

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