I would consider unblessing a bad idea. My recommendation would be to provide a method on your class to provide a hashref representation of your object, and use that in the value you send to YAML::Tiny. Moo just uses normal hashref objects, so the method can be pretty simple and just do a shallow clone, without re-blessing the result.

sub as_hashref {
    return { %{ $_[0] } };
}
[download]

This gives you an easy place to change how the object is serialized if you need it in the future, but doesn't over-complicate things. The more "correct" way to do this would involve using an explicit list of attributes and using their accessors, but it isn't really a problem to rely on it being a normal hashref based object. You are breaking encapsulation, but it's your object, so you can choose if that matters to you.

While Moo can work with objects that aren't based on hashrefs or use other non-standard storage, that isn't the default and is something you'd have to explicitly enable with a MooX module.

But YAML::Tiny can't serialize an object reference.

However, my personal preference for situations like this is to give my objects an ->unblessed method which copies the object's contents into a new, unblessed hashref and returns that, leaving the original object intact. It takes up a little more time and memory than unblessing the original reference, of course, but it allows me to continue using the object as an object afterwards, If you're just going to free the object after unblessing and dumping it, then that's not a concern, so Data::Structure::Util::unbless would probably make more sense in that situation.

#!/usr/bin/env perl

package Deblessify;
use strictures 2;
use feature 'say';
use Data::Dumper;
use YAML::Tiny;
use Moo;
use MooseX::MungeHas 'is_rw';

# attrs
has 'abc';
has 'def';
has 'foo';
has 'bar';
has 'name';

run();

sub run
{
    my $self = __PACKAGE__->new;
    $self->abc({aaa => 123, bbb => 456,});
    $self->def([qw/123 456 789 abc def ghi jkl mno/]);
    $self->foo('foo bar baz xyzzy');
    $self->bar(123.456789);
    $self->name('testfile');
    $self->deblessify;
}

sub deblessify
{
    my ($self) = @_;

    my $dumpstr = Dumper($self);
    say "dumpstr = $dumpstr";
    $dumpstr =~ s/^(\$VAR.*? =) bless\(/\$deblessed_obj =/;
    $dumpstr =~ s/\s*?},\s+'.*?'\s+\);$/};/;
    say "new str = $dumpstr";
    my $deblessed_obj = '';
    eval $dumpstr;
    say "deblessified obj: $deblessed_obj";
    my $yaml = YAML::Tiny->new($deblessed_obj);
    my $filename = $self->name . ".yaml";
    $yaml->write($filename);
}

1;
__END__
[download]