NAME

Types::Sub - type constraints for subroutines and Sub::Meta

SYNOPSIS

    use Test2::V0;
    use Types::Sub -types;
    use Types::Standard -types;

    my $Sub = Sub[
        args    => [Int, Int],
        returns => Int
    ];

    use Function::Parameters;
    use Function::Return;

    fun add(Int $a, Int $b) :Return(Int) {
        return $a + $b
    }

    ok $Sub->check(\&add);
    ok !$Sub->check(sub {});

    done_testing;

DESCRIPTION

Types::Sub is type library for subroutines and Sub::Meta. This library can be used with Moo/Moose/Mouse, etc.

Types

Sub[`a]

A value where Ref['CODE'] and check by Sub::Meta#is_relaxed_same_interface.

    use Types::Sub -types;
    use Types::Standard -types;
    use Sub::Meta;

    use Function::Parameters;
    use Function::Return;

    fun distance(Num :$lat, Num :$lng) :Return(Num) { }

    #
    # Sub[`a] is ...
    #
    my $Sub = Sub[
        subname => 'distance',
        args    => { '$lat' => Num, '$lng' => Num },
        returns => Num
    ];

    ok $Sub->check(\&distance);

    #
    # almost equivalent to the following
    #
    my $submeta = Sub::Meta->new(
        subname => 'distance',
        args    => { '$lat' => Num, '$lng' => Num },
        returns => Num
    );

    my $meta = Sub::Meta::CreatorFunction::find_submeta(\&distance);
    ok $submeta->is_relaxed_same_interface($meta);

    done_testing;

If no argument is given, it matches Ref['CODE']. Sub[] == Ref['CODE']. This helps to keep writing simple when choosing whether or not to use stricter type checking depending on the environment.

    use Devel::StrictMode;

    has callback => (
        is  => 'ro',
        isa => STRICT ? Sub[
            args    => [Int],
            returns => [Int],
        ] : Sub[]
    );

StrictSub[`a]

A value where Ref['CODE'] and check by Sub::Meta#is_strict_same_interface.

SubMeta[`a]

A value where checking by Sub::Meta#is_relaxed_same_interface.

StrictSubMeta[`a]

A value where checking by Sub::Meta#is_strict_same_interface.

EXAMPLES

Function::Parameters

    use Function::Parameters;
    use Types::Standard -types;
    use Types::Sub -types;

    my $Sub = Sub[
        args => [Int, Int],
    ];

    fun add(Int $a, Int $b) { return $a + $b }

    fun double(Int $a) { return $a * 2 }

    ok $Sub->check(\&add);
    ok !$Sub->check(\&double);

Sub::WrapInType

    use Sub::WrapInType;
    use Types::Standard -types;
    use Types::Sub -types;

    my $Sub = Sub[
        args    => [Int, Int],
        returns => Int,
    ];

    ok $Sub->check(wrap_sub([Int,Int] => Int, sub {}));
    ok !$Sub->check(wrap_sub([Int] => Int, sub {}));

Sub::WrapInType::Attribute

    use Sub::WrapInType::Attribute;
    use Types::Standard -types;
    use Types::Sub -types;

    my $Sub = Sub[
        args    => [Int, Int],
        returns => Int,
    ];

    sub add :WrapSub([Int,Int] => Int) {
        my ($a, $b) = @_;
        return $a + $b
    }

    sub double :WrapSub([Int] => Int) {
        my $a = shift;
        return $a * 2
    }

    ok $Sub->check(\&add);
    ok !$Sub->check(\&double);

Sub::Meta::Library

    use Sub::Meta::Library;
    use Types::Standard -types;
    use Types::Sub -types;

    my $Sub = Sub[
        args    => [Int, Int],
        returns => Int,
    ];

    sub add {}
    my $meta = Sub::Meta->new(
        args    => [Int, Int],
        returns => Int,
    );
    Sub::Meta::Library->register(\&add, $meta);

    ok $Sub->check(\&add);

SEE ALSO

Sub::Meta::Type

LICENSE

Copyright (C) kfly8.

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

AUTHOR

kfly8 <kfly@cpan.org>

cpanm Sub::Meta

perl -MCPAN -e shell
install Sub::Meta