NAME
    MooseX::Types::Implements - Require objects to implement a
    role/interface

VERSION
    version 1.103350

SYNOPSIS
        package My::Class;

        use Moose;
        use MooseX::Types::Implements qw( Implements );

        has 'vehicle' => (
            is => 'rw',
            isa => Implements[qw( My::Interfaces::Driveable )],
        );

        has 'pet_animal' => (
            is => 'rw',
            isa => Implements[qw( My::Interfaces::Pet My::Interfaces::Animal )],
        );

    Interfaces definitions:

        package My::Interfaces::Driveable;
        use Moose::Role;

        requires qw( drive stop );


        package My::Interfaces::Pet;
        use Moose::Role;

        requires qw( play obey );


        package My::Interfaces::Animal;
        use Moose::Role;

        requires qw( eat sleep roam );

    Classes:

        package My::Car;
        use Moose;
        with qw( My::Interfaces::Driveable );

        sub drive { ... };
        sub stop { ... };


        package My::Bicycle;
        use Moose;
        with qw( My::Interfaces::Driveable );

        sub drive { ... };
        sub stop { ... };


        package My::TimeMachine;
        use Moose;

        sub teleport { ... };


        package My::Dog;
        use Moose;
        with qw( My::Interfaces::Pet My::Interfaces::Animal );

        sub play { ... };
        sub obey { ... };

        sub eat { ... };
        sub sleep { ... };
        sub roam { ... };


        package My::Skunk;
        use Moose;
        with qw( My::Interfaces::Animal );

        sub eat { ... };
        sub sleep { ... };
        sub roam { ... };

    And finally:

        package main;

        my $class = My::Class->new();

        # My::Car and My::Bicycle implement My::Interfaces::Driveable
        $class->vehicle( My::Car->new() );
        $class->vehicle( My::Bicycle->new() );

        # throws error - you cannot drive TimeMachine
        $class->vehicle( My::TimeMachine->new() );


        # dog is a Pet and an Animal
        $class->pet_animal( My::Dog->new() );

        # throws error - Skunk is an Animal, but not really a Pet
        $class->pet_animal( My::Skunk->new() );

DESCRIPTION
    This class provides parameterizable polymorphic type constraint.

TYPES
  Implements
        # single role
        has 'vehicle' => (
            is => 'rw',
            isa => Implements[qw( My::Interfaces::Driveable )],
        );

        # all roles need to be implemented
        has 'pet_animal' => (
            is => 'rw',
            isa => Implements[qw( My::Interfaces::Pet My::Interfaces::Animal )],
        );

    "Implements" is a parameterizable type constraint that requires
    "Objects" to implement specified roles (automatically loaded).

    Subtyping is also supported:

        package My::Types;
        use MooseX::Types::Implements qw( Implements );
        use MooseX::Types -declare => [qw(
            Driveable
        )];

        subtype Driveable,
            as Implements[qw( My::Interfaces::Driveable )],
            message {
                "Object '$_' needs to implement My::Interfaces::Driveable"
            };

        package My::Class;
        use Moose;
        use My::Types qw( Driveable );

        has 'vehicle' => (
            is => 'rw',
            isa => Driveable,
        );

SEE ALSO
    *   MooseX::Types::Parameterizable

    *   MooseX::Types

AUTHOR
    Alex J. G. Burzyński <ajgb@cpan.org>

COPYRIGHT AND LICENSE
    This software is copyright (c) 2010 by Alex J. G. Burzyński
    <ajgb@cpan.org>.

    This is free software; you can redistribute it and/or modify it under
    the same terms as the Perl 5 programming language system itself.

