{
   package Page;

   use strict;
   use warnings;

   use Moose;

   has 'url' => (
      is       => 'ro',
      isa      => 'Str',
      required => 1,
   );

   no Moose;
   __PACKAGE__->meta->make_immutable();
}

{
   package Container;

   use strict;
   use warnings;

   use Moose;

   my $pages_constraint = Moose::Util::TypeConstraints::create_paramet
+erized_type_constraint('ArrayRef[Page]');
   my $aoh_constraint   = Moose::Util::TypeConstraints::create_paramet
+erized_type_constraint('ArrayRef[HashRef]');

   around BUILDARGS => sub {
      my $orig  = shift;
      my $class = shift;
      my %args  = ( @_ == 1 ? %{ $_[0] } : @_ );

      if (exists($args{pages})) {
         my $pages = $args{pages};
         if (!$pages_constraint->check($pages)) {  # Need to coerce?
            if ($aoh_constraint->check($pages)) {  # Can we coerce?
               $args{pages} = [ map Page->new($_), @$pages ];
            }
         }
      }

      return $class->$orig(%args);
   };

   has 'pages' => (
      is      => 'rw',
      isa     => 'ArrayRef[Page]',
      default => sub { [ ] },
   );

   no Moose;
   __PACKAGE__->meta->make_immutable();
}

Container->new( pages => [ { url => "a" }, { url => "b" } ] );
[download]

This is basically the same approach you tried, but correctly uses the more appropriate BUILDARGS instead of BUILD.

Coded so it can take both ArrayRef[HashRef] and ArrayRef[Page].

thank you very much for your solutions:
tomorrow I will try both of them.

I tried the two samples.
The second one is the one I like it (because conceptually you don't have to create a type not related to class in the base-class).

Just a little precisation:
Here:

$args{pages} = [ map Page->new($_), @$pages ];
[download]


must be:


$args{pages} = [ map Page->new(URL=>$$_{Page}{URL})), @$pages ];
[download]



And I have a question:

I have also checked Moose manual:

What "around" is?



around BUILDARGS => sub {
[download]


Thank you for your answers.

Moose

{
   package Page;

   use strict;
   use warnings;

   use Moose;

   has 'url' => (
      is       => 'ro',
      isa      => 'Str',
      required => 1,
   );


   use Moose::Util::TypeConstraints;

   subtype 'Pages'
      => as 'ArrayRef[Page]';

   coerce 'Pages'
      => from 'ArrayRef[HashRef]'
         => via { [ map __PACKAGE__->new($_), @{ $_[0] } ] };

   no Moose::Util::TypeConstraints;


   no Moose;
   __PACKAGE__->meta->make_immutable();
}

{
   package Container;

   use strict;
   use warnings;

   use Moose;

   has 'pages' => (
      is      => 'rw',
      isa     => 'Pages',
      coerce  => 1,
      default => sub { [ ] },
   );

   no Moose;
   __PACKAGE__->meta->make_immutable();
}

Container->new( pages => [ { url => "a" }, { url => "b" } ] );
[download]

I don't really like the global-ness of the coercion. I'll be posting an alternative that uses BUILDARGS shortly.

tmpPages:
- Page:
   URL: http://www.perlmonks.org/

- Page:
   URL: http://www.perl.org/
[download]

package PagesGenerator;
our $VERSION=0.01;

use Moose; 
with 'MooseX::SimpleConfig';


use Page;


has 'tmpPages'=>(
              is=>'rw',
              isa=>'ArrayRef[HashRef]',
              default => sub { [ ] },
         );



has 'pages'=>(
              is=>'rw',
              isa=>'ArrayRef[Page]',
              default => sub { [ ] },
         );


sub BUILD{
    my $self=shift;
    

    
    @{$self->pages}= map {new Page(URL=>$$_{Page}{URL});} @{$self->tmp
+Pages};
    
    for ( @{ $self->pages } ) {
        print $_->URL;
        print "\n";

    }
    

}
[download]