http://qs1969.pair.com?node_id=235744


in reply to •Re: Data::XDumper
in thread Data::XDumper

I'm not trying to reinvent YAML in any way. I'm not interesting in serializing data structure, nor reading them in in different languages.

I want an accurate dump of perl data structures. Neither Dumper nor Denter offer this, and I doubt YAML does either (although I haven't checked really - feel free to correct me)

an example which shows where Dumper and Denter go wrong:
http://tnx.nl/scribble/420FRAP
how would YAML handle that?

•Update: the above link died.. so here it is, expanded to include other dumping formats mentioned also:

my $x = 4;
my $xx = sub{\@_}->(\$x, \$x);
my $y = \4;
my $yy = sub{\@_}->($y, $y);

bless \$xx->[0], 'Foo';
bless \$xx->[1], 'Bar';
bless \$yy->[0], 'Foo';
bless \$yy->[1], 'Bar';

use Data::XDumper qw(Dump);
print "******** Data::XDumper ********\n";
Dump $xx, $yy;
print "\n";

use Data::Dumper;
print "******** Data::Dumper ********\n";
print Dumper $xx, $yy;
print "\n";

use Data::Denter;
print "******** Data::Denter ********\n";
print Denter $xx, $yy;
print "\n";

# (by merlyn's suggestion in the reply)
$Data::Dumper::Purity = 1;
print "******** Data::Dumper with purity ********\n";
print Dumper $xx, $yy;
print "\n";

# and also
use YAML ();
print "******** YAML ********\n";
print YAML::Dump $xx, $yy;
print "\n";

[download]

And the corresponding output:
******** Data::XDumper ********
        [
           Foo \
$L002:        4,
           Bar \$L002
        ]
        [
$L001:     Bar \<ro> 4,
           $L001
        ]

******** Data::Dumper ********
$VAR1 = [
          \4,
          $VAR1->[0]
        ];
$VAR2 = [
          \4,
          $VAR2->[0]
        ];

******** Data::Denter ********
@
    $(REF00001)
        4
    $(*REF00001-1)
@
    $(REF00002)
        4
    $(*REF00002-1)

******** Data::Dumper with purity ********
$VAR1 = [
          \4,
          do{my $o}
        ];
$VAR1->[1] = $VAR1->[0];
$VAR2 = [
          \4,
          do{my $o}
        ];
$VAR2->[1] = $VAR2->[0];

******** YAML ********
--- #YAML:1.0
- &1 !perl/ref:
  =: 4
- *1
--- #YAML:1.0
- &1 !perl/ref:
  =: 4
- *1

[download]

Replies are listed 'Best First'.
•Re: Re: Data::XDumper
by merlyn (Sage) on Feb 16, 2003 at 16:42 UTC
    So, if the problem is that Data::Dumper dumps some structures wrong, then submit a patch to Data::Dumper, rather than inventing something different that a lot of people won't know about and leaving the buggy code in a core distribution.

    As for your example: 

    $x = 4;
$xx = sub{\@_}->(\$x, \$x);
$y = \4;
$yy = sub{\@_}->($y, $y);

bless \$xx->[0], 'Foo';
bless \$xx->[1], 'Bar';
bless \$yy->[0], 'Foo';
bless \$yy->[1], 'Bar';

use Data::Dumper;
print Dumper $xx, $yy;

    [download]
    I suspect you haven't seen the Purity flag, which needs to be set in some more complex data, such as yours.

    -- Randal L. Schwartz, Perl hacker
    Be sure to read my standard disclaimer if this is a reply.

[reply]
[d/l]

      So, if the problem is that Data::Dumper dumps some structures wrong, then submit a patch to Data::Dumper, rather than inventing something different that a lot of people won't know about and leaving the buggy code in a core distribution.

      The same could be said of YAML and of Data::Dump and of Data::BFDump and of Data::DumpXML.

      Actually of them all Data::Dumper is the most accurate. (Data::BFDump is more accurate, but im not sure which version I have on CPAN. I think the one there is broken. Ive been meaning to update it for quite a while.)

      YAML is IMO the most broken. I have done comparison tests and it fails more than everything else. Please dont recommend YAML to people without a big caveat that it shouldnt be used on self referential structures.

      Ps: You once said more or less the same thing to me about eval(). :-)

      • Update:  
      Point taken about reinventing the wheel though. If you are going to do so, you need to put a lot of work in to make it really a better wheel.

      • Update:  
      Minor typographical changes.

      ---
      demerphq


[reply]
[d/l]
      They're not really bugs.. they're more like design choices. There is no way to fix it except by radically changing its output format in an incompatible way. It's simply that Dumper's goal of eval-ability is in the way.

      And I also heavily dislike its output format :-)

      BTW, Dumper's purity flag has no effect in this case besides making the output even more unreadable

[reply]
Re: Data::XDumper
by xmath (Hermit) on Feb 16, 2003 at 19:28 UTC
    To answer my own question, YAML::Dump handles it very poorly.

    Like Dumper and Denter, it doesn't see the difference between $xx and $yy. It also appears to ignore blessings, which I find rather difficult to believe.

    Plus if I feed it a bit more complex structure (the example I included with XDumper), YAML gives me: Can't create YAML::Node from 'GLOB' at /Library/Perl/YAML/Transfer.pm line 41

    So I don't think YAML can be compared to XDumper. They simply have different goals and different advantages.

[reply]

In Section Meditations