I think this is how its done...

Author: sshaw

MANIFEST

@@ -0,0 +1,5 @@
+lib/MooseX/NestedAttributesConstructor.pm
+lib/MooseX/NestedAttributesConstructor/Class.pm
+Makefile.PL
+MANIFEST	This list of files
+t/basic.t

lib/MooseX/NestedAttributesConstructor.pm

@@ -0,0 +1,75 @@
+package MooseX::NestedAttributesConstructor;
+use Moose;
+our $VERSION = '0.01';
+
+Moose::Exporter->setup_import_methods(
+ # class_metaroles => {
+ #	class => ['MooseX::NestedAttributesConstructor::Trait::Class']
+ # }
+ base_class_roles => ['MooseX::NestedAttributesConstructor::Class']
+);
+
+package MooseX::NestedAttributesConstructor::Meta::Trait::NestedAttribute;
+use Moose::Role;
+Moose::Util::meta_attribute_alias('NestedAttribute');
+
+1;
+
+=pod
+
+=head1 NAME
+
+MooseX::NestedAttributesConstructor - Create attributes from a nested data structure
+
+=head1 OVERVIEW
+
+ package Address
+ use Moose;
+
+ has street => ( is => 'rw' );
+ has city => ( is => 'rw' );
+ # ...
+
+ package Person;
+ use Moose;
+
+ has name => ( is => 'rw' );
+ has addresses => ( is => 'rw',
+ isa => 'ArrayRef[Address]',
+ traits => ['NestedAttribute'] );
+ # ...
+
+ package main;
+ use Person;
+
+ my $p = Person->new(name => 'sshaw',
+ addresses => [
+	{ city => 'LA' },
+	{ city => 'Da Bay' },
+{ city => 'Even São José' }
+ ]);
+
+ say $_->city for @{$p->addresses};
+
+=head1 WARNING
+
+This is the first Moose I've cooked. 
+
+=head1 DESCRIPTION
+
+This module creates attribute types from a nested data structure passed to an object's constructor.
+Just add the C<NestedAttrubute> trait to attributes with a custom or parameterized type.
+
+=head1 AUTHOR
+
+Skye Shaw (sshaw AT lucas.cis.temple.edu) 
+
+=head1 SEE ALSO
+
+L<MooseX::StrictConstructor>
+
+=head1 COPYRIGHT
+
+Copyright (c) 2012 Skye Shaw.
+
+This library is free software; you can redistribute it and/or modify it under the same terms as Perl itself.

lib/MooseX/NestedAttributesConstructor/Class.pm

@@ -0,0 +1,92 @@
+package MooseX::NestedAttributesConstructor::Class;
+use Moose::Role;
+
+around BUILDARGS => sub {
+ my $orig = shift;
+ my $class = shift;
+ my $argz = ref $_[0] ? shift : { @_ };
+ return $class->$orig(_construct($class, $argz));
+};
+
+# Called after BUILDARGS
+# around new_object => sub {
+# my $orig = shift;
+# my $self = shift;
+# my $argz = @_ == 1 ? $_[0] : {@_};
+# return $self->$orig(_construct($self, $argz));
+# };
+
+sub _construct
+{
+ my ($class, $options) = @_;
+ return $options unless $class->can('meta'); 
+
+ while( my ($name, $val) = each %$options ) {
+
+# May or may not be a metaclass
+ #my $attr = $class->can('get_attribute') ? $class->get_attribute($name) : $class->meta->get_attribute($name); 
+my $attr = $class->meta->get_attribute($name); 
+ my $vtype = ref($val);
+
+ next unless $attr
+ and ($vtype eq 'ARRAY' or $vtype eq 'HASH')
+ and !blessed($val)
+ and $attr->does('NestedAttribute')
+ and $attr->has_type_constraint
+ and ($attr->type_constraint->isa('Moose::Meta::TypeConstraint::Class') or
+ $attr->type_constraint->isa('Moose::Meta::TypeConstraint::Parameterized'));
+
+ my $ctype;
+ my $param = 1;
+
+ if($attr->type_constraint->isa('Moose::Meta::TypeConstraint::Parameterized')) {
+ $ctype = $attr->type_constraint->type_parameter->class;
+ }
+ else {
+ $ctype = $attr->type_constraint->class;
+ $param = 0;
+ }
+
+ if($vtype eq 'HASH') {
+ $val = _construct_hash($ctype, $val, $param);
+ }
+ elsif($param && ref($val->[0]) eq 'HASH') { 
+ $val = _construct_array($ctype, $val);
+ }
+
+ $options->{$name} = $val;
+ }
+
+ return $options;
+}
+
+sub _construct_array
+{
+ my ($class, $val) = @_;
+ my $collection = [];
+ for(@$val) {
+my $options = _construct($class, $_);
+push @$collection, $class->new(%$options);
+ }
+ 
+ $collection;
+}
+
+sub _construct_hash
+{
+ my ($class, $val, $is_param) = @_;
+
+ if($is_param) {
+ my $collection = {};
+ for(keys %$val) {
+ my $options = _construct($class, $val->{$_});
+ $collection->{$_} = $class->new(%$options);
+ }
+
+return $collection;
+ }
+
+ $class->new(%$val);
+}
+
+1;

t/basic.t

@@ -0,0 +1,55 @@
+package A;
+use Moose; 
+use MooseX::NestedAttributesConstructor;
+
+has 'a', traits => ['NestedAttribute'], is => 'rw', isa => 'A';
+has 'arrayref', traits => ['NestedAttribute'], is => 'rw', isa => 'ArrayRef[A]';
+has 'hashref', traits => ['NestedAttribute'], is => 'rw', isa => 'HashRef[A]';
+has 'str', is => 'rw', isa => 'Str';
+
+package main;
+use strict; 
+use warnings;
+
+use Test::More;
+
+my $a;
+subtest 'without nested attributes' => sub { 
+ $a = A->new(str => '123');
+ is($a->str, 123, '$a->str');
+
+ $a = A->new(arrayref => [ A->new(str => '123') ]);
+ isa_ok($a->arrayref, 'ARRAY', '$a->arrayref');
+ isa_ok($a->arrayref->[0], 'A', '$a->arrayref->[0]');
+ is($a->arrayref->[0]->str, '123', '$a->arrayref->[0]->str');
+};
+
+subtest 'with nested attributes' => sub {
+ eval { A->new(str => []) };
+ like($@, qr/validation failed/i, '$a->str not nested');
+
+ eval { A->new(a => { a => 'A' }) };
+ like($@, qr/validation failed/i, '$a->a->a nested but wrong type');
+ 
+ $a = A->new(str => '123', a => { str => '456' });
+ is($a->str, '123', '$a->str');
+ isa_ok($a->a, 'A', '$a->a');
+ is($a->a->str, '456', '$a->a->str');
+ 
+ $a = A->new(str => '123', arrayref => [ 
+ { a => { str => '123' } },
+ { a => { str => 'XYZ' } }
+]);
+ is($a->str, '123', '$a->str');
+ isa_ok($a->arrayref, 'ARRAY', '$a->arrayref');
+ is(@{$a->arrayref}, 2, '$a->arrayref size'); 
+ isa_ok($a->arrayref->[0], 'A', '$a->arrayref->[0]');
+ isa_ok($a->arrayref->[0]->a, 'A', '$a->arrayref->[0]->a');
+ is($a->arrayref->[0]->a->str, '123', '$a->arrayref->[0]->a->str');
+ isa_ok($a->arrayref->[1], 'A', '$a->arrayref->[1]');
+ isa_ok($a->arrayref->[1]->a, 'A', '$a->arrayref->[1]->a');
+ is($a->arrayref->[1]->a->str, 'XYZ', '$a->arrayref->[1]->a->str');
+};
+
+done_testing();
+