namespace::autoclean results from the CPAN

namespace::autoclean

Benchmark-Featureset-ParamCheck

view release on metacpan or search on metacpan

            "Params::Validate" : "1.26",
            "Params::ValidationCompiler" : "0.24",
            "Ref::Util" : "0.203",
            "Ref::Util::XS" : "0.116",
            "Specio::Declare" : "0.37",
            "Specio::Library::Builtins" : "0.37",
            "Type::Nano" : "0",
            "Type::Params" : "1.016002",
            "Type::Tiny::XS" : "0.012",
            "Types::Standard" : "1.016002",
            "namespace::autoclean" : "0",
            "perl" : "5.012"
         }
      },
      "test" : {
         "requires" : {
            "Module::Runtime" : "0",
            "Test::Modern" : "0.013"
         }
      }
   },

META.yml view on Meta::CPAN

  Params::Validate: '1.26'
  Params::ValidationCompiler: '0.24'
  Ref::Util: '0.203'
  Ref::Util::XS: '0.116'
  Specio::Declare: '0.37'
  Specio::Library::Builtins: '0.37'
  Type::Nano: '0'
  Type::Params: '1.016002'
  Type::Tiny::XS: '0.012'
  Types::Standard: '1.016002'
  namespace::autoclean: '0'
  perl: '5.012'
resources:
  Identifier: http://purl.org/NET/cpan-uri/dist/Benchmark-Featureset-ParamCheck/project
  bugtracker: https://github.com/tobyink/p5-benchmark-featureset-paramcheck/issues
  homepage: https://metacpan.org/release/Benchmark-Featureset-ParamCheck
  license: http://dev.perl.org/licenses/
  repository: git://github.com/tobyink/p5-benchmark-featureset-paramcheck.git
version: '0.007'
x_serialization_backend: 'CPAN::Meta::YAML version 0.018'
x_static_install: 1

Makefile.PL view on Meta::CPAN

                          develop   => { recommends => { "Dist::Inkt" => 0.001 } },
                          runtime   => {
                                         requires => {
                                           "Data::Validator" => 1.07,
                                           "IO::String" => 0,
                                           "Moose" => 2.2002,
                                           "Moose::Util::TypeConstraints" => 2.2002,
                                           "MooseX::Params::Validate" => 0.21,
                                           "Mouse" => "v2.4.7",
                                           "Mouse::Util::TypeConstraints" => 0,
                                           "namespace::autoclean" => 0,
                                           "Params::Check" => 0.38,
                                           "Params::Validate" => 1.26,
                                           "Params::ValidationCompiler" => 0.24,
                                           "perl" => 5.012,
                                           "Ref::Util" => 0.203,
                                           "Ref::Util::XS" => 0.116,
                                           "Specio::Declare" => 0.37,
                                           "Specio::Library::Builtins" => 0.37,
                                           "Type::Nano" => 0,
                                           "Type::Params" => 1.016002,

doap.ttl view on Meta::CPAN

@prefix xsd:   <http://www.w3.org/2001/XMLSchema#> .

<http://dev.perl.org/licenses/>
	dc:title             "the same terms as the perl 5 programming language system itself".

<http://purl.org/NET/cpan-uri/dist/Benchmark-Featureset-ParamCheck/project>
	a                    doap:Project;
	dc:contributor       <http://purl.org/NET/cpan-uri/person/tobyink>;
	doap-deps:develop-recommendation [ doap-deps:on "Dist::Inkt 0.001"^^doap-deps:CpanId ];
	doap-deps:runtime-requirement [
		doap-deps:on "namespace::autoclean"^^doap-deps:CpanId;
	], [ doap-deps:on "Params::Check 0.38"^^doap-deps:CpanId ], [
		doap-deps:on "Params::Validate 1.26"^^doap-deps:CpanId;
	], [
		doap-deps:on "Params::ValidationCompiler 0.24"^^doap-deps:CpanId;
	], [ doap-deps:on "Ref::Util 0.203"^^doap-deps:CpanId ], [
		doap-deps:on "Ref::Util::XS 0.116"^^doap-deps:CpanId;
	], [
		doap-deps:on "Specio::Declare 0.37"^^doap-deps:CpanId;
	], [
		doap-deps:on "Specio::Library::Builtins 0.37"^^doap-deps:CpanId;

lib/Benchmark/Featureset/ParamCheck/Base/MXPV.pm view on Meta::CPAN

use strict;
use warnings;

package Benchmark::Featureset::ParamCheck::Base::MXPV;

our $AUTHORITY = 'cpan:TOBYINK';
our $VERSION   = '0.007';

use parent qw(Benchmark::Featureset::ParamCheck::Base);
use MooseX::Params::Validate 0.21;
use namespace::autoclean;

sub run_named_check {
	my ($class, $times, @args) = @_;
	my $check = $class->get_named_check;
	validated_hash(\@args, %$check) for 1 .. $times;
	return;
}

sub run_positional_check {
	my ($class, $times, @args) = @_;

lib/Benchmark/Featureset/ParamCheck/Base/PV.pm view on Meta::CPAN

package Benchmark::Featureset::ParamCheck::Base::PV;

our $AUTHORITY = 'cpan:TOBYINK';
our $VERSION   = '0.007';

# Give Params::Validate a fighting chance.
BEGIN { $ENV{PARAMS_VALIDATE_IMPLEMENTATION} = 'XS' };

use parent qw(Benchmark::Featureset::ParamCheck::Base);
use Params::Validate 1.26;
use namespace::autoclean;

sub run_named_check {
	my ($class, $times, @args) = @_;
	my $check = $class->get_named_check;
	&validate(\@args, $check) for 1 .. $times;
	return;
}

sub run_positional_check {
	my ($class, $times, @args) = @_;

lib/Benchmark/Featureset/ParamCheck/Base/ParamsCheck.pm view on Meta::CPAN

use strict;
use warnings;

package Benchmark::Featureset::ParamCheck::Base::ParamsCheck;

our $AUTHORITY = 'cpan:TOBYINK';
our $VERSION   = '0.007';

use parent qw(Benchmark::Featureset::ParamCheck::Base);
use Params::Check 0.38 qw(check);
use namespace::autoclean;

use constant allow_extra_key => !!1;
use constant accept_hash     => !!0;
use constant accept_array    => !!0;

sub run_named_check {
	my ($class, $times, @args) = @_;
	my $check = $class->get_named_check;
	check($check, @args) || die('failed check') for 1 .. $times;
	return;

lib/Benchmark/Featureset/ParamCheck/Implementation/DataValidator/Moose.pm view on Meta::CPAN

use warnings;

package Benchmark::Featureset::ParamCheck::Implementation::DataValidator::Moose;

our $AUTHORITY = 'cpan:TOBYINK';
our $VERSION   = '0.007';

use parent qw(Benchmark::Featureset::ParamCheck::Base::DataValidator);
use Moose 2.2002 ();
use Moose::Util::TypeConstraints;
use namespace::autoclean;

use constant long_name => 'Data::Validator with Moose';
use constant short_name => 'DV-Moose';

my $t = \&Moose::Util::TypeConstraints::find_or_parse_type_constraint;

sub get_named_check {
	state $check = Data::Validator->new(
		integer   => { isa => $t->('Int') },
		hashes    => { isa => $t->('ArrayRef[HashRef]') },

lib/Benchmark/Featureset/ParamCheck/Implementation/DataValidator/Mouse.pm view on Meta::CPAN

use warnings;

package Benchmark::Featureset::ParamCheck::Implementation::DataValidator::Mouse;

our $AUTHORITY = 'cpan:TOBYINK';
our $VERSION   = '0.007';

use parent qw(Benchmark::Featureset::ParamCheck::Base::DataValidator);
use Mouse v2.4.7 ();
use Mouse::Util::TypeConstraints;
use namespace::autoclean;

use constant long_name => 'Data::Validator with Mouse';
use constant short_name => 'DV-Mouse';

my $t = \&Mouse::Util::TypeConstraints::find_or_parse_type_constraint;

sub get_named_check {
	state $check = Data::Validator->new(
		integer   => { isa => $t->('Int') },
		hashes    => { isa => $t->('ArrayRef[HashRef]') },

lib/Benchmark/Featureset/ParamCheck/Implementation/DataValidator/TypeTiny.pm view on Meta::CPAN

package Benchmark::Featureset::ParamCheck::Implementation::DataValidator::TypeTiny;

our $AUTHORITY = 'cpan:TOBYINK';
our $VERSION   = '0.007';

use parent qw(Benchmark::Featureset::ParamCheck::Base::DataValidator);
use Ref::Util 0.203 ();
use Ref::Util::XS 0.116 ();
use Types::Standard 1.001_009 -types;
use Type::Tiny::XS 0.012 ();
use namespace::autoclean;

use constant long_name => 'Data::Validator with Type::Tiny';
use constant short_name => 'DV-TT';

sub get_named_check {
	state $check = Data::Validator->new(
		integer   => { isa => Int },
		hashes    => { isa => ArrayRef[HashRef] },
		object    => { isa => HasMethods[qw/ print close /] },
	);

lib/Benchmark/Featureset/ParamCheck/Implementation/MXPV/Moose.pm view on Meta::CPAN

use warnings;

package Benchmark::Featureset::ParamCheck::Implementation::MXPV::Moose;

our $AUTHORITY = 'cpan:TOBYINK';
our $VERSION   = '0.007';

use parent qw(Benchmark::Featureset::ParamCheck::Base::MXPV);
use Moose 2.2002 ();
use Moose::Util::TypeConstraints;
use namespace::autoclean;

use constant long_name => 'MooseX::Params::Validate with Moose';
use constant short_name => 'MXPV-Moose';

my $t = \&Moose::Util::TypeConstraints::find_or_parse_type_constraint;

sub get_named_check {
	state $check = {
		integer   => { isa => $t->('Int') },
		hashes    => { isa => $t->('ArrayRef[HashRef]') },

lib/Benchmark/Featureset/ParamCheck/Implementation/MXPV/TypeTiny.pm view on Meta::CPAN

package Benchmark::Featureset::ParamCheck::Implementation::MXPV::TypeTiny;

our $AUTHORITY = 'cpan:TOBYINK';
our $VERSION   = '0.007';

use parent qw(Benchmark::Featureset::ParamCheck::Base::MXPV);
use Ref::Util 0.203 ();
use Ref::Util::XS 0.116 ();
use Types::Standard 1.001_009 -types;
use Type::Tiny::XS 0.012 ();
use namespace::autoclean;

use constant long_name => 'MooseX::Params::Validate with Type::Tiny';
use constant short_name => 'MXPV-TT';

sub get_named_check {
	state $check = {
		integer   => { isa => Int },
		hashes    => { isa => ArrayRef[HashRef] },
		object    => { isa => HasMethods[qw/ print close /] },
	};

lib/Benchmark/Featureset/ParamCheck/Implementation/PV.pm view on Meta::CPAN

use strict;
use warnings;

package Benchmark::Featureset::ParamCheck::Implementation::PV;

our $AUTHORITY = 'cpan:TOBYINK';
our $VERSION   = '0.007';

use parent qw(Benchmark::Featureset::ParamCheck::Base::PV);
use Params::Validate 1.26 qw(:types);
use namespace::autoclean;

use constant long_name => 'Params::Validate';
use constant short_name => 'PV';

sub get_named_check {
	state $check = {
		integer   => { type => SCALAR,   regex => qr/\A-?[0-9]+\z/ },
		hashes    => { type => ARRAYREF, callbacks => { hashes => sub { !grep ref ne 'HASH', @{$_[0]} } } },
		object    => { type => OBJECT,   can => [qw/print close/] },
	};

lib/Benchmark/Featureset/ParamCheck/Implementation/PV/TypeTiny.pm view on Meta::CPAN

package Benchmark::Featureset::ParamCheck::Implementation::PV::TypeTiny;

our $AUTHORITY = 'cpan:TOBYINK';
our $VERSION   = '0.007';

use parent qw(Benchmark::Featureset::ParamCheck::Base::PV);
use Ref::Util 0.203 ();
use Ref::Util::XS 0.116 ();
use Types::Standard 1.001_009 -types;
use Type::Tiny::XS 0.012 ();
use namespace::autoclean;

use constant long_name => 'Params::Validate with Type::Tiny';
use constant short_name => 'PV-TT';

sub get_named_check {
	state $check = {
		integer   => { callbacks => { typecheck => (Int)->compiled_check } },
		hashes    => { callbacks => { typecheck => (ArrayRef[HashRef])->compiled_check } },
		object    => { callbacks => { typecheck => (HasMethods[qw/ print close /])->compiled_check } },
	};

lib/Benchmark/Featureset/ParamCheck/Implementation/PVC/Moose.pm view on Meta::CPAN

use warnings;

package Benchmark::Featureset::ParamCheck::Implementation::PVC::Moose;

our $AUTHORITY = 'cpan:TOBYINK';
our $VERSION   = '0.007';

use parent qw(Benchmark::Featureset::ParamCheck::Base::PVC);
use Params::ValidationCompiler 0.24 qw(validation_for);
use Moose::Util::TypeConstraints 2.2002;
use namespace::autoclean;

my $t = \&Moose::Util::TypeConstraints::find_or_parse_type_constraint;

use constant long_name => 'Params::ValidationCompiler with Moose';
use constant short_name => 'PVC-Moose';

sub get_named_check {
	state $check = validation_for(
		params => {
			integer   => { type => $t->('Int') },

lib/Benchmark/Featureset/ParamCheck/Implementation/PVC/Specio.pm view on Meta::CPAN


our $AUTHORITY = 'cpan:TOBYINK';
our $VERSION   = '0.007';

use parent qw(Benchmark::Featureset::ParamCheck::Base::PVC);
use Params::ValidationCompiler 0.24 qw(validation_for);
use Ref::Util 0.203 ();
use Ref::Util::XS 0.116 ();
use Specio::Declare 0.37;
use Specio::Library::Builtins 0.37;
use namespace::autoclean;

use constant long_name  => 'Params::ValidationCompiler with Specio';
use constant short_name => 'PVC-Specio';

sub get_named_check {
	state $check = validation_for(
		params => {
			integer   => { type => t('Int') },
			hashes    => { type => t('ArrayRef', of => t('HashRef')) },
			object    => { type => object_can_type('Printable', methods => [qw/ print close /]) },

lib/Benchmark/Featureset/ParamCheck/Implementation/PVC/TypeTiny.pm view on Meta::CPAN


our $AUTHORITY = 'cpan:TOBYINK';
our $VERSION   = '0.007';

use parent qw(Benchmark::Featureset::ParamCheck::Base::PVC);
use Params::ValidationCompiler 0.24 qw(validation_for);
use Ref::Util 0.203 ();
use Ref::Util::XS 0.116 ();
use Types::Standard 1.001_009 -types;
use Type::Tiny::XS 0.012 ();
use namespace::autoclean;

use constant long_name => 'Params::ValidationCompiler with Type::Tiny';
use constant short_name => 'PVC-TT';

sub get_named_check {
	state $check = validation_for(
		params => {
			integer   => { type => Int },
			hashes    => { type => ArrayRef[HashRef] },
			object    => { type => HasMethods[qw/ print close /] },

lib/Benchmark/Featureset/ParamCheck/Implementation/ParamsCheck/Perl.pm view on Meta::CPAN

use strict;
use warnings;

package Benchmark::Featureset::ParamCheck::Implementation::ParamsCheck::Perl;

our $AUTHORITY = 'cpan:TOBYINK';
our $VERSION   = '0.007';

use parent qw(Benchmark::Featureset::ParamCheck::Base::ParamsCheck);
use Scalar::Util qw(blessed);
use namespace::autoclean;

use constant long_name  => 'Params::Check with coderefs';
use constant short_name => 'PC-PurePerl';

sub get_named_check {
	state $check = +{
		integer => { required => 1, allow => qr/\A-?[0-9]+\z/ },
		hashes  => { required => 1, allow => sub {
			return unless ref($_[0]) eq 'ARRAY';
			for my $arr (@{ $_[0] }) {

lib/Benchmark/Featureset/ParamCheck/Implementation/ParamsCheck/TypeTiny.pm view on Meta::CPAN

use warnings;

package Benchmark::Featureset::ParamCheck::Implementation::ParamsCheck::TypeTiny;

our $AUTHORITY = 'cpan:TOBYINK';
our $VERSION   = '0.007';

use parent qw(Benchmark::Featureset::ParamCheck::Base::ParamsCheck);
use Types::Standard 1.001_009 -types;
use Type::Tiny::XS 0.012 ();
use namespace::autoclean;

use constant long_name  => 'Params::Check with Type::Tiny';
use constant short_name => 'PC-TT';

sub get_named_check {
	state $check = +{
		integer => { required => 1, allow => Int->compiled_check },
		hashes  => { required => 1, allow => ArrayRef->of(HashRef)->compiled_check },
		object  => { required => 1, allow => HasMethods->of(qw/ print close /)->compiled_check },
	};

lib/Benchmark/Featureset/ParamCheck/Implementation/Perl.pm view on Meta::CPAN

use strict;
use warnings;

package Benchmark::Featureset::ParamCheck::Implementation::Perl;

our $AUTHORITY = 'cpan:TOBYINK';
our $VERSION   = '0.007';

use parent qw(Benchmark::Featureset::ParamCheck::Base);
use Scalar::Util qw(blessed);
use namespace::autoclean;

use constant long_name  => 'Naive Pure Perl Implementation';
use constant short_name => 'PurePerl';

sub get_named_check {
	state $check = sub {
		my %args = (@_==1 && ref($_[0]) eq 'HASH') ? %{$_[0]} : @_;
		die 'invalid key' if grep !/\A(integer|object|hashes)\z/, keys %args;
		
		die 'bad integer' unless

lib/Benchmark/Featureset/ParamCheck/Implementation/RefUtilXS.pm view on Meta::CPAN

use strict;
use warnings;

package Benchmark::Featureset::ParamCheck::Implementation::RefUtilXS;

our $AUTHORITY = 'cpan:TOBYINK';
our $VERSION   = '0.007';

use parent qw(Benchmark::Featureset::ParamCheck::Base);
use Ref::Util::XS 0.116 qw(is_blessed_ref is_plain_hashref is_plain_arrayref is_ref);
use namespace::autoclean;

use constant long_name  => 'Pure Perl Implementation with Ref::Util::XS';
use constant short_name => 'RefUtilXS';

sub get_named_check {
	state $check = sub {
		my %args = (@_==1 && ref($_[0]) eq 'HASH') ? %{$_[0]} : @_;
		die 'invalid key' if grep !/\A(integer|object|hashes)\z/, keys %args;
		
		die 'bad integer' unless

lib/Benchmark/Featureset/ParamCheck/Implementation/TypeParams/Moose.pm view on Meta::CPAN

use warnings;

package Benchmark::Featureset::ParamCheck::Implementation::TypeParams::Moose;

our $AUTHORITY = 'cpan:TOBYINK';
our $VERSION   = '0.007';

use parent qw(Benchmark::Featureset::ParamCheck::Base);
use Type::Params 1.016004 qw(compile_named compile);
use Moose::Util::TypeConstraints 2.2002;
use namespace::autoclean;

use constant long_name => 'Type::Params with Moose';
use constant short_name => 'TP-Moose';

my $t = \&Moose::Util::TypeConstraints::find_or_parse_type_constraint;

sub get_named_check {
	state $check = compile_named(
		integer   => $t->('Int'),
		hashes    => $t->('ArrayRef[HashRef]'),

lib/Benchmark/Featureset/ParamCheck/Implementation/TypeParams/Mouse.pm view on Meta::CPAN

use warnings;

package Benchmark::Featureset::ParamCheck::Implementation::TypeParams::Mouse;

our $AUTHORITY = 'cpan:TOBYINK';
our $VERSION   = '0.007';

use parent qw(Benchmark::Featureset::ParamCheck::Base);
use Type::Params 1.016004 qw(compile_named compile);
use Mouse::Util::TypeConstraints;
use namespace::autoclean;

use constant long_name => 'Type::Params with Mouse';
use constant short_name => 'TP-Mouse';

my $t = \&Mouse::Util::TypeConstraints::find_or_parse_type_constraint;

sub get_named_check {
	state $check = compile_named(
		integer   => $t->('Int'),
		hashes    => $t->('ArrayRef[HashRef]'),

lib/Benchmark/Featureset/ParamCheck/Implementation/TypeParams/Specio.pm view on Meta::CPAN


our $AUTHORITY = 'cpan:TOBYINK';
our $VERSION   = '0.007';

use parent qw(Benchmark::Featureset::ParamCheck::Base);
use Ref::Util 0.203 ();
use Ref::Util::XS 0.116 ();
use Type::Params 1.016004 qw(compile_named compile);
use Specio::Declare 0.37;
use Specio::Library::Builtins 0.37;
use namespace::autoclean;

use constant long_name => 'Type::Params with Specio';
use constant short_name => 'TP-Specio';

sub get_named_check {
	state $check = compile_named(
		integer   => t('Int'),
		hashes    => t('ArrayRef', of => t('HashRef')),
		object    => object_can_type('Printable', methods => [qw/ print close /]),
	);

lib/Benchmark/Featureset/ParamCheck/Implementation/TypeParams/TypeNano.pm view on Meta::CPAN

use warnings;

package Benchmark::Featureset::ParamCheck::Implementation::TypeParams::TypeNano;

our $AUTHORITY = 'cpan:TOBYINK';
our $VERSION   = '0.007';

use parent qw(Benchmark::Featureset::ParamCheck::Base);
use Type::Params 1.016004 qw(compile_named compile);
use Type::Nano qw( Int ArrayRef HashRef duck_type );
use namespace::autoclean;

use constant long_name => 'Type::Params with Type::Nano';
use constant short_name => 'TP-Nano';

my $ArrayRef_of_HashRef = Type::Nano->new(
	name       => 'ArrayRef[HashRef]',
	parent     => ArrayRef,
	constraint => sub { HashRef->check($_) || return !!0 for @$_; !!1 },
);

lib/Benchmark/Featureset/ParamCheck/Implementation/TypeParams/TypeTiny.pm view on Meta::CPAN


our $AUTHORITY = 'cpan:TOBYINK';
our $VERSION   = '0.007';

use parent qw(Benchmark::Featureset::ParamCheck::Base);
use Ref::Util 0.203 ();
use Ref::Util::XS 0.116 ();
use Type::Params 1.016004 qw(compile_named compile);
use Types::Standard 1.016004 -types;
use Type::Tiny::XS 0.012 ();
use namespace::autoclean;

use constant long_name => 'Type::Params with Type::Tiny';
use constant short_name => 'TP-TT';

sub get_named_check {
	state $check = compile_named(
		integer   => Int,
		hashes    => ArrayRef[HashRef],
		object    => HasMethods[qw/ print close /],
	);

lib/Benchmark/Featureset/ParamCheck/Implementation/TypeParams2/Moose.pm view on Meta::CPAN

use warnings;

package Benchmark::Featureset::ParamCheck::Implementation::TypeParams2::Moose;

our $AUTHORITY = 'cpan:TOBYINK';
our $VERSION   = '0.007';

use parent qw(Benchmark::Featureset::ParamCheck::Base);
use Type::Params 2.000000 qw(signature);
use Moose::Util::TypeConstraints 2.2002;
use namespace::autoclean;

use constant long_name => 'Type::Params v2 API with Moose';
use constant short_name => 'TP2-Moose';

my $t = \&Moose::Util::TypeConstraints::find_or_parse_type_constraint;

sub get_named_check {
	state $check = signature named => [
		integer   => $t->('Int'),
		hashes    => $t->('ArrayRef[HashRef]'),

lib/Benchmark/Featureset/ParamCheck/Implementation/TypeParams2/Mouse.pm view on Meta::CPAN

use warnings;

package Benchmark::Featureset::ParamCheck::Implementation::TypeParams2::Mouse;

our $AUTHORITY = 'cpan:TOBYINK';
our $VERSION   = '0.007';

use parent qw(Benchmark::Featureset::ParamCheck::Base);
use Type::Params 2.000000 qw(signature);
use Mouse::Util::TypeConstraints;
use namespace::autoclean;

use constant long_name => 'Type::Params v2 API with Mouse';
use constant short_name => 'TP2-Mouse';

my $t = \&Mouse::Util::TypeConstraints::find_or_parse_type_constraint;

sub get_named_check {
	state $check = signature named => [
		integer   => $t->('Int'),
		hashes    => $t->('ArrayRef[HashRef]'),

lib/Benchmark/Featureset/ParamCheck/Implementation/TypeParams2/Specio.pm view on Meta::CPAN


our $AUTHORITY = 'cpan:TOBYINK';
our $VERSION   = '0.007';

use parent qw(Benchmark::Featureset::ParamCheck::Base);
use Ref::Util 0.203 ();
use Ref::Util::XS 0.116 ();
use Type::Params 2.000000 qw(signature);
use Specio::Declare 0.37;
use Specio::Library::Builtins 0.37;
use namespace::autoclean;

use constant long_name => 'Type::Params v2 API with Specio';
use constant short_name => 'TP2-Specio';

sub get_named_check {
	state $check = signature named => [
		integer   => t('Int'),
		hashes    => t('ArrayRef', of => t('HashRef')),
		object    => object_can_type('Printable', methods => [qw/ print close /]),
	];

lib/Benchmark/Featureset/ParamCheck/Implementation/TypeParams2/TypeNano.pm view on Meta::CPAN

use warnings;

package Benchmark::Featureset::ParamCheck::Implementation::TypeParams2::TypeNano;

our $AUTHORITY = 'cpan:TOBYINK';
our $VERSION   = '0.007';

use parent qw(Benchmark::Featureset::ParamCheck::Base);
use Type::Params 2.000000 qw(signature);
use Type::Nano qw( Int ArrayRef HashRef duck_type );
use namespace::autoclean;

use constant long_name => 'Type::Params v2 API with Type::Nano';
use constant short_name => 'TP2-Nano';

my $ArrayRef_of_HashRef = Type::Nano->new(
	name       => 'ArrayRef[HashRef]',
	parent     => ArrayRef,
	constraint => sub { HashRef->check($_) || return !!0 for @$_; !!1 },
);

view all matches for this distribution
view release on metacpan - search on metacpan

( run in 0.973 second using v1.00-cache-2.02-grep-82fe00e-cpan-c98054f2a92 )