Type::Tiny::Duck - type constraints based on the "can" method

       Toby Inkster <tobyink@cpan.org>.

       Please report any bugs to <https://github.com/tobyink/p5-type-tiny/issues>.

       This software is copyright (c) 2013-2014, 2017-2023 by Toby Inkster.

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

       Type constraints of the general form "{ $_->can("method") }".

       The name refers to the saying, "If it looks like a duck, swims like a duck, and quacks like a duck, then
       it probably is a duck". Duck typing can be a more flexible way of testing objects than relying on "isa",
       as it allows people to easily substitute mock objects.

       This package inherits from Type::Tiny; see that for most documentation.  Major differences are listed
       below:

   Attributes
       "methods"
           An arrayref of method names.

       "constraint"
           Unlike  Type::Tiny,  you  cannot  pass  a constraint coderef to the constructor.  Instead rely on the
           default.

       "inlined"
           Unlike Type::Tiny, you cannot pass an inlining coderef to  the  constructor.   Instead  rely  on  the
           default.

       "parent"
           Parent is always Types::Standard::Object, and cannot be passed to the constructor.

   Methods
       stringifies_to($constraint)
           See Type::Tiny::ConstrainedObject.

       numifies_to($constraint)
           See Type::Tiny::ConstrainedObject.

       "with_attribute_values($attr1 => $constraint1, ...)"
           See Type::Tiny::ConstrainedObject.

   Exports
       Type::Tiny::Duck can be used as an exporter.

         use Type::Tiny::Duck HttpClient => [ 'get', 'post' ];

       This will export the following functions into your namespace:

       "HttpClient"
       is_HttpClient( $value )
       assert_HttpClient( $value )
       to_HttpClient( $value )

       Multiple types can be exported at once:

         use Type::Tiny::Duck (
           HttpClient   => [ 'get', 'post' ],
           FtpClient    => [ 'upload', 'download' ],
         );

       THIS PACKAGE IS PROVIDED "AS IS" AND WITHOUT  ANY  EXPRESS  OR  IMPLIED  WARRANTIES,  INCLUDING,  WITHOUT
       LIMITATION, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.

perl v5.40.1                                       2025-05-06                              Type::Tiny::Duck(3pm)

       Type::Tiny::Duck - type constraints based on the "can" method

       Type::Tiny::Manual.

       Type::Tiny.

       Moose::Meta::TypeConstraint::DuckType.

       This module is covered by the Type-Tiny stability policy.

       Using via Types::Standard:

         package Logger {
           use Moo;
           use Types::Standard qw( HasMethods Bool );

           has debugging => ( is => 'rw', isa => Bool, default => 0 );
           has output    => ( is => 'ro', isa => HasMethods[ 'print' ] );

           sub warn {
             my ( $self, $message ) = @_;
             $self->output->print( "[WARNING] $message\n" );
           }

           sub debug {
             my ( $self, $message ) = @_;
             $self->output->print( "[DEBUG] $message\n" ) if $self->debugging;
           }
         }

       Using Type::Tiny::Duck's export feature:

         package Logger {
           use Moo;
           use Types::Standard qw( Bool );
           use Type::Tiny::Duck Printable => [ 'print' ];

           has debugging => ( is => 'rw', isa => Bool, default => 0 );
           has output    => ( is => 'ro', isa => Printable );

           sub warn {
             my ( $self, $message ) = @_;
             $self->output->print( "[WARNING] $message\n" );
           }

           sub debug {
             my ( $self, $message ) = @_;
             $self->output->print( "[DEBUG] $message\n" ) if $self->debugging;
           }
         }

       Using Type::Tiny::Duck's object-oriented interface:

         package Logger {
           use Moo;
           use Types::Standard qw( Bool );
           use Type::Tiny::Duck;

           my $Printable = Type::Type::Duck->new(
             name    => 'Printable',
             methods => [ 'print' ],
           );

           has debugging => ( is => 'rw', isa => Bool, default => 0 );
           has output    => ( is => 'ro', isa => $Printable );

           sub warn {
             my ( $self, $message ) = @_;
             $self->output->print( "[WARNING] $message\n" );
           }

           sub debug {
             my ( $self, $message ) = @_;
             $self->output->print( "[DEBUG] $message\n" ) if $self->debugging;
           }
         }