$VAR1 = {
          'key2' => {
                    'subkey_a' => 'foo',
                    'subkey_c' => 'bar',
                    '<<' => {
                            'subkey_b' => 'qwer',
                            'subkey_a' => 'asdf'
                          }
                  },
          'key1' => $VAR1->{'key2'}{'<<'}
        };
[download]

The expected functionality is for the keys of key1 to be merged into the keys of key2, with key2 taking precedence. Not having the time or resources to dig into the XS guts of either module, my solution was a simple recursion function to traverse the data structure, merging the '<<' references with their containing objects:

#!/usr/bin/perl
use strict; use warnings;
use YAML::XS;
use Data::Dumper;
my $data;
{local $/;$data = <DATA>};
print Dumper mergekeys( Load $data );

sub mergekeys
{
    my ($ref) = @_;
    my $type = ref $ref;
    if ($type eq 'HASH')
    {
        my $tmphref = $ref->{'<<'};
        if ($tmphref)
        {
            die "Merge key does not support merging non-hashmaps"
                unless (ref $tmphref eq 'HASH');
            my %tmphash = %$tmphref;
            delete $ref->{'<<'};
            %$ref = (%tmphash, %$ref);
        }
        mergekeys($_) for (values %$ref);
    }
    elsif ($type eq 'ARRAY')
    {
        mergekeys($_) for (@$ref);
    }
    return $ref;
}
[download]

This produces the much more accurate data structure:

$VAR1 = {
          'key2' => {
                    'subkey_b' => 'qwer',
                    'subkey_a' => 'foo',
                    'subkey_c' => 'bar'
                  },
          'key1' => {
                    'subkey_b' => 'qwer',
                    'subkey_a' => 'asdf'
                  }
        };
[download]

Obviously, this is not a very robust solution. It makes no checks for cyclical data, potentially expands the data structure due to dereferencing some addresses, and its recursive nature means it would rapidly consume resources when used on very deep data structures. But for the needs that I had, it worked pretty well. Hopefully the maintainers of YAML::XS and YAML::Syck can provide this functionality soon, since it seems that their respective underlying C libraries support merge keys just fine.