1Data::Printer(3) User Contributed Perl Documentation Data::Printer(3)
2
6 Data::Printer - colored & full-featured pretty print of Perl data
7 structures and objects
8
10 Want to see what's inside a variable in a complete, colored and human-
11 friendly way?
12 use DDP; # same as 'use Data::Printer'
14 p $some_var;
16 p $some_var, as => "This label will be printed too!";
17 # no need to use '\' before arrays or hashes!
19 p @array;
20 p %hash;
21 # for anonymous array/hash references, use postderef (on perl 5.24 or later):
23 p [ $one, $two, $three ]->@*;
24 p { foo => $foo, bar => $bar }->%*;
25 # or deref the anonymous ref:
27 p @{[ $one, $two, $three ]};
28 p %{{ foo => $foo, bar => $bar }};
29 # or put '&' in front of the call:
31 &p( [ $one, $two, $three ] );
32 &p( { foo => $foo, bar => $bar } );
33 The snippets above will print the contents of the chosen variables to
35 STDERR on your terminal, with colors and a few extra features to help
36 you debug your code.
37 If you wish to grab the output and handle it yourself, call "np()":
39 my $dump = np $var;
41 die "this is what happened: " . np %data;
43 The "np()" function is the same as "p()" but will return the string
45 containing the dump. By default it has no colors, but you can change
46 that easily too.
47 That's pretty much it :)
49 Data::Printer is fully customizable, even on a per-module basis! Once
51 you figure out your own preferences, create a .dataprinter
52 configuration file for yourself (or one for each project) and
53 Data::Printer will automatically use it!
54
56 Here's what Data::Printer offers Perl developers, out of the box:
57 • Variable dumps designed for easy parsing by the human brain, not a
59 machine.
60 • Highly customizable, from indentation size to depth level. You can
62 even rename the exported "p()" function!
63 • Beautiful (and customizable) colors to highlight variable dumps and
65 make issues stand-out quickly on your console. Comes bundled with
66 several themes for you to pick that work on light and dark terminal
67 backgrounds, and you can create your own as well.
68 • Filters for specific data structures and objects to make debugging
70 much, much easier. Includes filters for many popular classes from
71 CPAN like JSON::*, URI, HTTP::*, LWP, Digest::*, DBI and
72 DBIx::Class. printing what really matters to developers debugging
73 code. It also lets you create your own custom filters easily.
74 • Lets you inspect information that's otherwise difficult to
76 find/debug in Perl 5, like circular references, reference counting
77 (refcount), weak/read-only information, overloaded operators,
78 tainted data, ties, dual vars, even estimated data size - all to
79 help you spot issues with your data like leaks without having to
80 know a lot about internal data structures or install hardcore tools
81 like Devel::Peek and Devel::Gladiator.
82 • keep your custom settings on a .dataprinter file that allows
84 different options per module being analyzed! You may also create a
85 custom profile class with your preferences and filters and upload
86 it to CPAN.
87 • output to many different targets like files, variables or open
89 handles (defaults to STDERR). You can send your dumps to the screen
90 or anywhere else, and customize this setting on a per-project or
91 even per-module basis, like print everything from Some::Module to a
92 debug.log file with extra info, and everything else to STDERR.
93 • Easy to learn, easy to master. Seriously, the synopsis above and
95 the customization section below cover about 90% of all use cases.
96 • Works on Perl 5.8 and later. Because you can't control where you
98 debug, we try our best to be compatible with all versions of Perl
99 5.
100 • Best of all? All that with No non-core dependencies, Zero. Nada. So
102 don't worry about adding extra weight to your project, as
103 Data::Printer can be easily added/removed.
104
106 The ever-popular Data::Dumper is a fantastic tool, meant to stringify
107 data structures in a way they are suitable for being "eval"'ed back in.
108 The thing is, a lot of people keep using it (and similar ones, like
109 Data::Dump) to print data structures and objects on screen for
110 inspection and debugging, and while you can use those modules for that,
111 it doesn't mean you should.
112 This is where Data::Printer comes in. It is meant to do one thing and
114 one thing only:
115 format Perl variables and objects to be inspected by a human
117 If you want to serialize/store/restore Perl data structures, this
119 module will NOT help you. Try Storable, Data::Dumper, JSON, or
120 whatever. CPAN is full of such solutions!
121 Whenever you type "use Data::Printer" or "use DDP", we export two
123 functions to your namespace:
124 p()
126 This function pretty-prints the contents of whatever variable to STDERR
127 (by default), and will use colors by default if your terminal supports
128 it.
129 p @some_array;
131 p %some_hash;
132 p $scalar_or_ref;
133 Note that anonymous structures will only work if you postderef them:
135 p [$foo, $bar, $baz]->@*;
137 you may also deref it manually:
139 p %{{ foo => $foo }};
141 or prefix "p()" with "&":
143 &p( [$foo, $bar, $baz] ); # & (note mandatory parenthesis)
145 You can pass custom options that will work only on that particular
147 call:
148 p @var, as => "some label", colorized => 0;
150 p %var, show_memsize => 1;
151 By default, "p()" prints to STDERR and returns the same variable being
153 dumped. This lets you quickly wrap variables with "p()" without
154 worrying about changing return values. It means that if you change
155 this:
156 sub foo { my $x = shift + 13; $x }
158 to this:
160 sub foo { my $x = shift + 13; p($x) }
162 The function will still return $x after printing the contents. This
164 form of handling data even allows method chaining, so if you want to
165 inspect what's going on in the middle of this:
166 $object->foo->bar->baz;
168 You can just add "DDP::p" anywhere:
170 $object->foo->DDP::p->bar->baz; # what happens to $object after ->foo?
172 Check out the customization quick reference section below for all
174 available options, including changing the return type, output target
175 and a lot more.
176 np()
178 The "np()" function behaves exactly like "p()" except it always returns
179 the string containing the dump (thus ignoring any setting regarding
180 dump mode or destination), and contains no colors by default. In fact,
181 the only way to force a colored "np()" is to pass "colored => 1" as an
182 argument to each call. It is meant to provide an easy way to fetch the
183 dump and send it to some unsupported target, or appended to some other
184 text (like part of a log message).
185
187 There are 3 possible ways to customize Data::Printer:
188 1. [RECOMMENDED] Creating a ".dataprinter" file either on your home
190 directory or your project's base directory, or both, or wherever you
191 set the "DATAPRINTERRC" environment variable to.
192 2. Setting custom properties on module load. This will override any
194 setting from your config file on the namespace (package/module) it was
195 called:
196 use DDP max_depth => 2, deparse => 1;
198 3. Setting custom properties on the actual call to "p()" or "np()".
200 This overrides all other settings:
201 p $var, show_tainted => 1, indent => 2;
203 The .dataprinter configuration file
205 The most powerful way to customize Data::Printer is to have a
206 ".dataprinter" file in your home directory or your project's root
207 directory. The format is super simple and can be understood in the
208 example below:
209 # global settings (note that only full line comments are accepted)
211 max_depth = 1
212 theme = Monokai
213 class.stringify = 0
214 # use quotes if you want spaces to be significant:
216 hash_separator = " => "
217 # You can set rules that apply only to a specific
219 # caller module (in this case, MyApp::Some::Module):
220 [MyApp::Some::Module]
221 max_depth = 2
222 class.expand = 0
223 escape_chars = nonlatin1
224 [MyApp::Other::Module]
226 multiline = 0
227 output = /var/log/myapp/debug.data
228 Note that if you set custom properties as arguments to "p()" or "np()",
230 you should group suboptions as a hashref. So while the ".dataprinter"
231 file has ""class.expand = 0"" and ""class.inherited = none"", the
232 equivalent code is ""class => { expand => 0, inherited => 'none' }"".
233 Properties Quick Reference
235 Below are (almost) all available properties and their (hopefully sane)
236 default values. See Data::Printer::Object for further information on
237 each of them:
238 # scalar options
240 show_tainted = 1
241 show_unicode = 1
242 show_lvalue = 1
243 print_escapes = 0
244 scalar_quotes = "
245 escape_chars = none
246 string_max = 4096
247 string_preserve = begin
248 string_overflow = '(...skipping __SKIPPED__ chars...)'
249 unicode_charnames = 0
250 # array options
252 array_max = 100
253 array_preserve = begin
254 array_overflow = '(...skipping __SKIPPED__ items...)'
255 index = 1
256 # hash options
258 hash_max = 100
259 hash_preserve = begin
260 hash_overflow = '(...skipping __SKIPPED__ keys...)'
261 hash_separator = ' '
262 align_hash = 1
263 sort_keys = 1
264 quote_keys = auto
265 # general options
267 name = var
268 return_value = pass
269 output = stderr
270 use_prototypes = 1
271 indent = 4
272 show_readonly = 1
273 show_tied = 1
274 show_dualvar = lax
275 show_weak = 1
276 show_refcount = 0
277 show_memsize = 0
278 memsize_unit = auto
279 separator = ,
280 end_separator = 0
281 caller_info = 0
282 caller_message = 'Printing in line __LINE__ of __FILENAME__'
283 max_depth = 0
284 deparse = 0
285 alias = p
286 warnings = 1
287 # colorization (see Colors & Themes below)
289 colored = auto
290 theme = Material
291 # object output
293 class_method = _data_printer
294 class.parents = 1
295 class.linear_isa = auto
296 class.universal = 1
297 class.expand = 1
298 class.stringify = 1
299 class.show_reftype = 0
300 class.show_overloads = 1
301 class.show_methods = all
302 class.sort_methods = 1
303 class.inherited = none
304 class.format_inheritance = string
305 class.parent_filters = 1
306 class.internals = 1
307 Settings' shortcuts
309 • as - prints a string before the dump. So:
311 p $some_var, as => 'here!';
313 is a shortcut to:
315 p $some_var, caller_info => 1, caller_message => 'here!';
317 • multiline - lets you create shorter dumps. By setting it to 0, we
319 use a single space as linebreak and disable the array index.
320 Setting it to 1 (the default) goes back to using "\n" as linebreak
321 and restore whatever array index you had originally.
322 • fulldump - when set to 1, disables all max string/hash/array
324 values. Use this to generate complete (full) dumps of all your
325 content, which is trimmed by default.
326 Colors & Themes
328 Data::Printer lets you set custom colors for pretty much every part of
329 the content being printed. For example, if you want numbers to be shown
330 in bright green, just put "colors.number = #00ff00" on your
331 configuration file.
332 See Data::Printer::Theme for the full list of labels, ways to represent
334 and customize colors, and even how to group them in your own custom
335 theme.
336 The colorization is set by the "colored" property. It can be set to 0
338 (never colorize), 1 (always colorize) or 'auto' (the default), which
339 will colorize "p()" only when there is no "ANSI_COLORS_DISABLED"
340 environment variable, the output is going to the terminal (STDOUT or
341 STDERR) and your terminal actually supports colors.
342 Profiles
344 You may bundle your settings and filters into a profile module. It
345 works like a configuration file but gives you the power and flexibility
346 to use Perl code to find out what to print and how to print. It also
347 lets you use CPAN to store your preferred settings and install them
348 into your projects just like a regular dependency.
349 use DDP profile => 'ProfileName';
351 See Data::Printer::Profile for all the ways to load a profile, a list
353 of available profiles and how to make one yourself.
354 Filters
356 Data::Printer works by passing your variable to a different set of
357 filters, depending on whether it's a scalar, a hash, an array, an
358 object, etc. It comes bundled with filters for all native data types
359 (always enabled, but overwritable), including a generic object filter
360 that pretty-prints regular and Moo(se) objects and is even aware of
361 Role::Tiny.
362 Data::Printer also comes with filter bundles that can be quickly
364 activated to make it easier to debug binary data and many popular CPAN
365 modules that handle date and time, databases (yes, even DBIx::Class),
366 message digests like MD5 and SHA1, and JSON and Web content like HTTP
367 requests and responses.
368 So much so we recommend everyone to activate all bundled filters by
370 putting the following line on your ".dataprinter" file:
371 filters = ContentType, DateTime, DB, Digest, Web
373 Creating your custom filters is very easy, and you're encouraged to
375 upload them to CPAN. There are many options available under the
376 "Data::Printer::Filter::*" namespace. Check Data::Printer::Filter for
377 more information!
378 Making your classes DDP-aware (without adding any dependencies!)
380 The default object filter will first check if the class implements a
381 sub called '"_data_printer()"' (or whatever you set the "class_method"
382 option to in your settings). If so, Data::Printer will use it to get
383 the string to print instead of making a regular class dump.
384 This means you could have the following in one of your classes:
386 sub _data_printer {
388 my ($self, $ddp) = @_;
389 return 'Hey, no peeking! But foo contains ' . $self->foo;
390 }
391 Notice that you can do this without adding Data::Printer as a
393 dependency to your project! Just write your sub and it will be called
394 with the object to be printed and a $ddp object ready for you. See
395 Data::Printer::Object for how to use it to pretty-print your data.
396 Finally, if your object implements string overload or provides a method
398 called "to_string", "as_string" or "stringify", Data::Printer will use
399 it. To disable this behaviour, set "class.stringify = 0" on your
400 ".dataprinter" file, or call p() with "class => { stringify => 0 }".
401 Loading a filter for that particular class will of course override
403 these settings.
404
406 You can't pass more than one variable at a time.
407 p $foo, $bar; # wrong
409 p $foo; p $bar; # right
410 You can't use it in variable declarations (it will most likely not do
412 what you want):
413 p my @array = qw(a b c d); # wrong
415 my @array = qw(a b c d); p @array; # right
416 If you pass a nonexistant key/index to DDP using prototypes, they will
418 trigger autovivification:
419 use DDP;
421 my %foo;
422 p $foo{bar}; # undef, but will create the 'bar' key (with undef)
423 my @x;
425 p $x[5]; # undef, but will initialize the array with 5 elements (all undef)
426 Slices (both array and hash) must be coerced into actual arrays (or
428 hashes) to properly shown. So if you want to print a slice, instead of
429 doing something like this:
430 p @somevar[1..10]; # WRONG! DON'T DO THIS!
432 try one of those:
434 my @x = @somevar[1..10]; p @x; # works!
436 p [ @somevar[1..0] ]->@*; # also works!
437 p @{[@somevar[1..0]]}; # this works too!!
438 Finally, as mentioned before, you cannot pass anonymous references on
440 the default mode of "use_prototypes = 1":
441 p { foo => 1 }; # wrong!
443 p %{{ foo => 1 }}; # right
444 p { foo => 1 }->%*; # right on perl 5.24+
445 &p( { foo => 1 } ); # right, but requires the parenthesis
446 sub pp { p @_ }; # wrapping it also lets you use anonymous data.
447 use DDP use_prototypes => 0;
449 p { foo => 1 }; # works, but now p(@foo) will fail, you must always pass a ref,
450 # e.g. p(\@foo)
451
453 While we make a genuine effort not to break anything on new releases,
454 sometimes we do. To make things easier for people migrating their code,
455 we have aggregated here a list of all incompatible changes since ever:
456 • 1.00 - some defaults changed! Because we added a bunch of new
458 features (including color themes), you may notice some difference
459 on the default output of Data::Printer. Hopefully it's for the
460 best.
461 • 1.00 - new ".dataprinter" file format. This should only affect you
463 if you have a ".dataprinter" file. The change was required to
464 avoid calling "eval" on potentially tainted/unknown code. It also
465 provided a much cleaner interface.
466 • 1.00 - new way of creating external filters. This only affects you
468 if you write or use external filters. Previously, the sub in your
469 "filters" call would get the reference to be parsed and a
470 properties hash. The properties hash has been replaced with a
471 Data::Printer::Object instance, providing much more power and
472 flexibility. Because of that, the filter call does not export
473 "p()"/"np()" anymore, replaced by methods in Data::Printer::Object.
474 • 1.00 - new way to call filters. This affects you if you load your
476 own inline filters. The fix is quick and Data::Printer will
477 generate a warning explaining how to do it. Basically, "filters =>
478 { ... }" became "filters => [{ ... }]" and you must replace
479 "-external => [1,2]" with "filters => [1, 2]", or "filters => [1,
480 2, {...}]" if you also have inline filters. This allowed us much
481 more power and flexibility with filters, and hopefully also makes
482 things clearer.
483 • 0.36 - "p()"'s default return value changed from 'dump' to 'pass'.
485 This was a very important change to ensure chained calls and to
486 prevent weird side-effects when "p()" is the last statement in a
487 sub. Read the full discussion <https://github.com/garu/Data-
488 Printer/issues/16>.
489 Any undocumented change was probably unintended. If you bump into one,
491 please file an issue on Github!
492
494 Using p() in some/all of your loaded modules
495 (contributed by Matt S. Trout (mst))
496 While debugging your software, you may want to use Data::Printer in
498 some or all loaded modules and not bother having to load it in each and
499 every one of them. To do this, in any module loaded by "myapp.pl",
500 simply write:
501 ::p @myvar; # note the '::' in front of p()
503 Then call your program like:
505 perl -MDDP myapp.pl
507 This also has the advantage that if you leave one p() call in by
509 accident, it will trigger a compile-time failure without the -M, making
510 it easier to spot :)
511 If you really want to have p() imported into your loaded modules, use
513 the next tip instead.
514 Adding p() to all your loaded modules
516 (contributed by Árpád Szász)
517 If you wish to automatically add Data::Printer's "p()" function to
519 every loaded module in you app, you can do something like this to your
520 main program:
521 BEGIN {
523 {
524 no strict 'refs';
525 require Data::Printer;
526 my $alias = 'p';
527 foreach my $package ( keys %main:: ) {
528 if ( $package =~ m/::$/ ) {
529 *{ $package . $alias } = \&Data::Printer::p;
530 }
531 }
532 }
533 }
534 WARNING This will override all locally defined subroutines/methods that
536 are named "p", if they exist, in every loaded module. If you already
537 have a subroutine named '"p()"', be sure to change $alias to something
538 custom.
539 If you rather avoid namespace manipulation altogether, use the previous
541 tip instead.
542 Using Data::Printer from the Perl debugger
544 (contributed by Árpád Szász and Marcel Grünauer (hanekomu))
545 With DB::Pluggable, you can easily set the perl debugger to use
547 Data::Printer to print variable information, replacing the debugger's
548 standard "p()" function. All you have to do is add these lines to your
549 ".perldb" file:
550 use DB::Pluggable;
552 DB::Pluggable->run_with_config( \'[DataPrinter]' ); # note the '\'
553 Then call the perl debugger as you normally would:
555 perl -d myapp.pl
557 Now Data::Printer's "p()" command will be used instead of the
559 debugger's!
560 See perldebug for more information on how to use the perl debugger, and
562 DB::Pluggable for extra functionality and other plugins.
563 If you can't or don't want to use DB::Pluggable, or simply want to keep
565 the debugger's "p()" function and add an extended version using
566 Data::Printer (let's call it "px()" for instance), you can add these
567 lines to your ".perldb" file instead:
568 $DB::alias{px} = 's/px/DB::px/';
570 sub px {
571 my $expr = shift;
572 require Data::Printer;
573 print Data::Printer::p($expr);
574 }
575 Now, inside the Perl debugger, you can pass as reference to "px"
577 expressions to be dumped using Data::Printer.
578 Using Data::Printer in a perl shell (REPL)
580 Some people really enjoy using a REPL shell to quickly try Perl code.
581 One of the most popular ones out there is Devel::REPL. If you use it,
582 now you can also see its output with Data::Printer!
583 Just install Devel::REPL::Plugin::DataPrinter and add the following
585 line to your re.pl configuration file (usually ".re.pl/repl.rc" in your
586 home dir):
587 load_plugin('DataPrinter');
589 The next time you run "re.pl", it should dump all your REPL using
591 Data::Printer!
592 Easily rendering Data::Printer's output as HTML
594 To turn Data::Printer's output into HTML, you can do something like:
595 use HTML::FromANSI;
597 use Data::Printer;
598 my $html_output = ansi2html( np($object, colored => 1) );
600 In the example above, the $html_output variable contains the HTML
602 escaped output of "p($object)", so you can print it for later
603 inspection or render it (if it's a web app).
604 Using Data::Printer with Template Toolkit
606 (contributed by Stephen Thirlwall (sdt))
607 If you use Template Toolkit and want to dump your variables using
609 Data::Printer, install the Template::Plugin::DataPrinter module and
610 load it in your template:
611 [% USE DataPrinter %]
613 The provided methods match those of "Template::Plugin::Dumper":
615 ansi-colored dump of the data structure in "myvar":
617 [% DataPrinter.dump( myvar ) %]
618 html-formatted, colored dump of the same data structure:
620 [% DataPrinter.dump_html( myvar ) %]
621 The module allows several customization options, even letting you load
623 it as a complete drop-in replacement for Template::Plugin::Dumper so
624 you don't even have to change your previous templates!
625 Migrating from Data::Dumper to Data::Printer
627 If you are porting your code to use Data::Printer instead of
628 Data::Dumper, you could replace:
629 use Data::Dumper;
631 with something like:
633 use Data::Printer;
635 sub Dumper { np @_, colored => 1 }
636 this sub will accept multiple variables just like Data::Dumper.
638 Unified interface for Data::Printer and other debug formatters
640 (contributed by Kevin McGrath (catlgrep))
641 If you want a really unified approach to easily flip between debugging
643 outputs, use Any::Renderer and its plugins, like
644 Any::Renderer::Data::Printer.
645 Printing stack traces with arguments expanded using Data::Printer
647 (contributed by Sergey Aleynikov (randir))
648 There are times where viewing the current state of a variable is not
650 enough, and you want/need to see a full stack trace of a function call.
651 The Devel::PrettyTrace module uses Data::Printer to provide you just
653 that. It exports a "bt()" function that pretty-prints detailed
654 information on each function in your stack, making it easier to spot
655 any issues!
656 Troubleshooting apps in real time without changing a single line of your
658 code
659 (contributed by Marcel Grünauer (hanekomu))
660 dip is a dynamic instrumentation framework for troubleshooting Perl
662 programs, similar to DTrace
663 <http://opensolaris.org/os/community/dtrace/>. In a nutshell, "dip"
664 lets you create probes for certain conditions in your application that,
665 once met, will perform a specific action. Since it uses Aspect-oriented
666 programming, it's very lightweight and you only pay for what you use.
667 "dip" can be very useful since it allows you to debug your software
669 without changing a single line of your original code. And Data::Printer
670 comes bundled with it, so you can use the "p()" function to view your
671 data structures too!
672 # Print a stack trace every time the name is changed,
674 # except when reading from the database.
675 dip -e 'before { print longmess(np $_->{args}[1], colored => 1)
676 if $_->{args}[1] } call "MyObj::name" & !cflow("MyObj::read")' myapp.pl
677 You can check dip's own documentation for more information and options.
679 Sample output for color fine-tuning
681 (contributed by Yanick Champoux (yanick))
682 The "examples/try_me.pl" file included in this distribution has a
684 sample dump with a complex data structure to let you quickly test color
685 schemes.
686
688 As of 1.0.0 this module complies with "Major.Minor.Revision" versioning
689 scheme (SemVer), meaning backwards incompatible changes will trigger a
690 new major number, new features without any breaking changes trigger a
691 new minor number, and simple patches trigger a revision number.
692
694 Many thanks to everyone who helped design and develop this module with
695 patches, bug reports, wishlists, comments and tests. They are
696 (alphabetically):
697 Adam Rosenstein, Alexandr Ciornii (chorny), Alexander Hartmaier
699 (abraxxa), Allan Whiteford, Anatoly (Snelius30), Andreas König (andk),
700 Andy Bach, Anthony DeRobertis, Árpád Szász, Athanasios Douitsis
701 (aduitsis), Baldur Kristinsson, Benct Philip Jonsson (bpj), brian d
702 foy, Chad Granum (exodist), Chris Prather (perigrin), Curtis Poe
703 (Ovid), David D Lowe (Flimm), David E. Condon (hhg7), David Golden
704 (xdg), David Precious (bigpresh), David Raab, David E. Wheeler
705 (theory), Damien Krotkine (dams), Denis Howe, dirk, Dotan Dimet, Eden
706 Cardim (edenc), Elliot Shank (elliotjs), Eugen Konkov (KES777),
707 Fernando Corrêa (SmokeMachine), Fitz Elliott, Florian (fschlich), Frew
708 Schmidt (frew), GianniGi, Graham Knop (haarg), Graham Todd, Gregory J.
709 Oschwald, grr, Håkon Hægland, Iaroslav O. Kosmina (darviarush), Ivan
710 Bessarabov (bessarabv), J Mash, James E. Keenan (jkeenan), Jarrod
711 Funnell (Timbus), Jay Allen (jayallen), Jay Hannah (jhannah), jcop,
712 Jesse Luehrs (doy), Joel Berger (jberger), John S. Anderson (genehack),
713 Karen Etheridge (ether), Kartik Thakore (kthakore), Kevin Dawson
714 (bowtie), Kevin McGrath (catlgrep), Kip Hampton (ubu), Londran, Marcel
715 Grünauer (hanekomu), Marco Masetti (grubert65), Mark Fowler (Trelane),
716 Martin J. Evans, Matt S. Trout (mst), Maxim Vuets, Michael Conrad, Mike
717 Doherty (doherty), Nicolas R (atoomic), Nigel Metheringham (nigelm),
718 Nuba Princigalli (nuba), Olaf Alders (oalders), Paul Evans (LeoNerd),
719 Pedro Melo (melo), Philippe Bruhat (BooK), Przemysław Wesołek (jest),
720 Rebecca Turner (iarna), Renato Cron (renatoCRON), Ricardo Signes
721 (rjbs), Rob Hoelz (hoelzro), Salve J. Nilsen (sjn), sawyer, Sebastian
722 Willing (Sewi), Sébastien Feugère (smonff), Sergey Aleynikov (randir),
723 Slaven Rezić, Stanislaw Pusep (syp), Stephen Thirlwall (sdt), sugyan,
724 Tai Paul, Tatsuhiko Miyagawa (miyagawa), Thomas Sibley (tsibley), Tim
725 Heaney (oylenshpeegul), Toby Inkster (tobyink), Torsten Raudssus
726 (Getty), Tokuhiro Matsuno (tokuhirom), trapd00r, Tsai Chung-Kuan, Veesh
727 Goldman (rabbiveesh), vividsnow, Wesley Dal`Col (blabos), y, Yanick
728 Champoux (yanick).
729 If I missed your name, please drop me a line!
731
733 Copyright (C) 2011-2021 Breno G. de Oliveira
734 This program is free software; you can redistribute it and/or modify it
736 under the terms of either: the GNU General Public License as published
737 by the Free Software Foundation; or the Artistic License.
738 See <http://dev.perl.org/licenses/> for more information.
740
742 BECAUSE THIS SOFTWARE IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
743 FOR THE SOFTWARE, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT
744 WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER
745 PARTIES PROVIDE THE SOFTWARE "AS IS" WITHOUT WARRANTY OF ANY KIND,
746 EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
747 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE
748 ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE SOFTWARE IS WITH
749 YOU. SHOULD THE SOFTWARE PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL
750 NECESSARY SERVICING, REPAIR, OR CORRECTION.
751 IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
753 WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
754 REDISTRIBUTE THE SOFTWARE AS PERMITTED BY THE ABOVE LICENCE, BE LIABLE
755 TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL, OR
756 CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
757 SOFTWARE (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
758 RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
759 FAILURE OF THE SOFTWARE TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
760 SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
761 DAMAGES.
762perl v5.34.0 2022-01-21 Data::Printer(3)