For #3 have a look at the documentation. $Data::Dumper::Sortkeys is the relevant option in this case.

#!/usr/bin/perl
use warnings;
use strict;

use Data::Dumper;

my $struct = [{a => 12, b => 14}, {arr => [5, 6, 7]}];
$Data::Dumper::Sortkeys = 1;
my $dump = Dumper($struct);
print $dump;
my $copy = eval "my $dump";
print Dumper $copy;
[download]

If your structure contains references into itself or code refs, you also need $Data::Dumper::Purity and $Data::Dumper::Deparse. The second one can introduce bugs.

I'd second SankoR's point about using something like JSON. But for Data::Dumper, see my module Data::Undump::PPI. Data::Dump is a little trickier because its output includes stuff like the range operator, repetition operator, and even MIME::Base64. Of course there's eval, but that's a giant security hole with input that you don't have 100% control over.

see -> Data::Dumper

> Can someone please demonstrate a Data::Dump round trip?

see -> Data::Dump

Not what you wanted? Then please be more specific...

PS: You might also be interested in Data::Printer

Data::Diff ?

Here's an unasked for but suggested YAML version with round trips and a unified diff in the middle, mainly because I haven't played with YAML for a long, long time.

#!/usr/bin/perl

use strict; # https://perlmonks.org/?node_id=11152489
use warnings;

my @animals = (qw( cow camel dog cat  )); # slightly changed from 1115
+0326
my @foods   = (qw( fish pasture meat  ));
my @places  = (qw( wood sea    desert ));
my $commands = {
    select => {
        completion_list => [@animals],
        commands => {
                        give => {
                                    completion_list => \@foods,
                        },
                        take_to => {
                                    completion_list => \@places,
                        },
        },
    },
    kill  => {
        completion_list => [@animals],
    }
};

use YAML qw( DumpFile LoadFile );
my $originalfile = 'original.11152489';
my $changedfile = 'changed.11152489';
DumpFile $originalfile, $commands;
$commands->{select}{commands}{give}{completion_list}[0] .= 'es';
DumpFile $changedfile, $commands;
system "diff -u $originalfile $changedfile";
use Data::Dump 'dd'; dd 'original', LoadFile $originalfile;
use Data::Dump 'dd'; dd 'changed',  LoadFile $changedfile;
[download]

Outputs:

--- original.11152489   2023-05-30 15:43:38.568028573 -0700
+++ changed.11152489    2023-05-30 15:43:38.571361943 -0700
@@ -9,7 +9,7 @@
   commands:
     give:
       completion_list:
-        - fish
+        - fishes
         - pasture
         - meat
     take_to:
(
  "original",
  {
    kill   => { completion_list => ["cow", "camel", "dog", "cat"] },
    select => {
                commands => {
                  give => { completion_list => ["fish", "pasture", "me
+at"] },
                  take_to => { completion_list => ["wood", "sea", "des
+ert"] },
                },
                completion_list => ["cow", "camel", "dog", "cat"],
              },
  },
)
(
  "changed",
  {
    kill   => { completion_list => ["cow", "camel", "dog", "cat"] },
    select => {
                commands => {
                  give => { completion_list => ["fishes", "pasture", "
+meat"] },
                  take_to => { completion_list => ["wood", "sea", "des
+ert"] },
                },
                completion_list => ["cow", "camel", "dog", "cat"],
              },
  },
)
[download]

I haven't played with YAML for a long, long time.

I have had to work with YAML a bit recently and the one tip I have is that for any dataset beyond the very small indeed, use ingy's excellent YAML::XS instead. Plain YAML is very slow in comparison.

---

🦛

Sometime ago I've stumped in a problem that Data::Dumper doesn't show cyrillic symbols correctly, so I write my own dumper:

use Scalar::Util qw/blessed/;
use Data::Dumper;

sub pretty {
    my $self = shift;
    my $structure = shift;
    my $depth = shift;
    $depth = 0 if not defined $depth;
    $depth += 2;
    my $string;
    if (blessed($structure)) {
        return Dumper($structure);
    }

    if (ref $structure eq ref {} ) {
        # HASH 
        my @arr;
        foreach my $el (sort keys %{ $structure }) {
            push @arr, " "x$depth . $el ." => ". $self->pretty($$struc
+ture{$el},$depth);
        }
        $string .= "HASH { \n" .join(",\n",@arr,undef);
                $string .= " "x($depth-2) ."}";
    } elsif (ref $structure eq ref [] ) {
        # ARRAY 
        my @arr;
        foreach my $el ( @{ $structure }) {
            push @arr, " "x$depth . $self->pretty($el,$depth);
        }
        $string .=  "ARRAY [ \n" .join(",\n",@arr,undef);
                $string .= " "x($depth-2) ."]";
    } else {
        $string .= "'".$structure."'";
    }
    return $string;
}
[download]

As you can see, I've let Dumper deal with blessed structures, while hashes and arrays printing is done in my way.

See Data::Dumper::AutoEncode.



The way forward always starts with a minimal test.

Data::Dumper is not great at that. Why not use JSON or YAML instead?

Data::Dumper isn't meant for this, but it can be done.

use Data::Dumper qw( );

sub serializer {
   local $Data::Dumper::Purity   = 1;
   local $Data::Dumper::Sortkeys = 1;  # Optional, but requested
   local $Data::Dumper::Useqq    = 1;  # Optional.
   return Data::Dumper->Dump( [ $_[0] ], [qw( D )] );
}

sub deserializer {
   my $D;
   eval( $_[0] )
      or die ( $@ );

   return $D;
}

my $text = serializer( $data );
my $copy = deserializer( $text );
[download]

[Woops, this was supposed to be a reply to the OP.]