File Coverage

blib/lib/Bubblegum/Constraints.pm

Criterion	Covered	Total	%
statement	13	15	86.6
branch			n/a
condition			n/a
subroutine	5	5	100.0
pod			n/a
total	18	20	90.0

# ABSTRACT: Type and Constraints Library for Bubblegum
package Bubblegum::Constraints;

use 5.10.0;

use strict;
use utf8::all;
use warnings;

use Types::Standard ();

use base 'Exporter::Tiny';

our $VERSION = '0.40'; # VERSION

our @EXPORT_OK;
our %EXPORT_TAGS;

my $arrayref   = Types::Standard->get_type('ArrayRef');
my $boolean    = Types::Standard->get_type('Bool');
my $classname  = Types::Standard->get_type('ClassName');
my $coderef    = Types::Standard->get_type('CodeRef');
my $defined    = Types::Standard->get_type('Defined');
my $filehandle = Types::Standard->get_type('FileHandle');
my $globref    = Types::Standard->get_type('GlobRef');
my $hashref    = Types::Standard->get_type('HashRef');
my $integer    = Types::Standard->get_type('Int');
my $number     = Types::Standard->get_type('Num');
my $object     = Types::Standard->get_type('Object');
my $reference  = Types::Standard->get_type('Ref');
my $regexpref  = Types::Standard->get_type('RegexpRef');
my $scalarref  = Types::Standard->get_type('ScalarRef');
my $string     = Types::Standard->get_type('Str');
my $undefined  = Types::Standard->get_type('Undef');
my $value      = Types::Standard->get_type('Value');

no warnings 'once';

# EXPORT: ISAS

push @EXPORT_OK, 'isa_aref';
push @{$EXPORT_TAGS{isas}}, 'isa_aref';
*isa_aref = $arrayref->compiled_check;

push @EXPORT_OK, 'isa_arrayref';
push @{$EXPORT_TAGS{isas}}, 'isa_arrayref';
*isa_arrayref = $arrayref->compiled_check;

push @EXPORT_OK, 'isa_bool';
push @{$EXPORT_TAGS{isas}}, 'isa_bool';
*isa_bool = $boolean->compiled_check;

push @EXPORT_OK, 'isa_boolean';
push @{$EXPORT_TAGS{isas}}, 'isa_boolean';
*isa_boolean = $boolean->compiled_check;

push @EXPORT_OK, 'isa_class';
push @{$EXPORT_TAGS{isas}}, 'isa_class';
*isa_class = $classname->compiled_check;

push @EXPORT_OK, 'isa_classname';
push @{$EXPORT_TAGS{isas}}, 'isa_classname';
*isa_classname = $classname->compiled_check;

push @EXPORT_OK, 'isa_coderef';
push @{$EXPORT_TAGS{isas}}, 'isa_coderef';
*isa_coderef = $coderef->compiled_check;

push @EXPORT_OK, 'isa_cref';
push @{$EXPORT_TAGS{isas}}, 'isa_cref';
*isa_cref = $coderef->compiled_check;

push @EXPORT_OK, 'isa_def';
push @{$EXPORT_TAGS{isas}}, 'isa_def';
*isa_def = $defined->compiled_check;

push @EXPORT_OK, 'isa_defined';
push @{$EXPORT_TAGS{isas}}, 'isa_defined';
*isa_defined = $defined->compiled_check;

push @EXPORT_OK, 'isa_fh';
push @{$EXPORT_TAGS{isas}}, 'isa_fh';
*isa_fh = $filehandle->compiled_check;

push @EXPORT_OK, 'isa_filehandle';
push @{$EXPORT_TAGS{isas}}, 'isa_filehandle';
*isa_filehandle = $filehandle->compiled_check;

push @EXPORT_OK, 'isa_glob';
push @{$EXPORT_TAGS{isas}}, 'isa_glob';
*isa_glob = $globref->compiled_check;

push @EXPORT_OK, 'isa_globref';
push @{$EXPORT_TAGS{isas}}, 'isa_globref';
*isa_globref = $globref->compiled_check;

push @EXPORT_OK, 'isa_hashref';
push @{$EXPORT_TAGS{isas}}, 'isa_hashref';
*isa_hashref = $hashref->compiled_check;

push @EXPORT_OK, 'isa_href';
push @{$EXPORT_TAGS{isas}}, 'isa_href';
*isa_href = $hashref->compiled_check;

push @EXPORT_OK, 'isa_int';
push @{$EXPORT_TAGS{isas}}, 'isa_int';
*isa_int = $integer->compiled_check;

push @EXPORT_OK, 'isa_integer';
push @{$EXPORT_TAGS{isas}}, 'isa_integer';
*isa_integer = $integer->compiled_check;

push @EXPORT_OK, 'isa_num';
push @{$EXPORT_TAGS{isas}}, 'isa_num';
*isa_num = $number->compiled_check;

push @EXPORT_OK, 'isa_number';
push @{$EXPORT_TAGS{isas}}, 'isa_number';
*isa_number = $number->compiled_check;

push @EXPORT_OK, 'isa_obj';
push @{$EXPORT_TAGS{isas}}, 'isa_obj';
*isa_obj = $object->compiled_check;

push @EXPORT_OK, 'isa_object';
push @{$EXPORT_TAGS{isas}}, 'isa_object';
*isa_object = $object->compiled_check;

push @EXPORT_OK, 'isa_ref';
push @{$EXPORT_TAGS{isas}}, 'isa_ref';
*isa_ref = $reference->compiled_check;

push @EXPORT_OK, 'isa_reference';
push @{$EXPORT_TAGS{isas}}, 'isa_reference';
*isa_reference = $reference->compiled_check;

push @EXPORT_OK, 'isa_regexpref';
push @{$EXPORT_TAGS{isas}}, 'isa_regexpref';
*isa_regexpref = $regexpref->compiled_check;

push @EXPORT_OK, 'isa_rref';
push @{$EXPORT_TAGS{isas}}, 'isa_rref';
*isa_rref = $regexpref->compiled_check;

push @EXPORT_OK, 'isa_scalarref';
push @{$EXPORT_TAGS{isas}}, 'isa_scalarref';
*isa_scalarref = $scalarref->compiled_check;

push @EXPORT_OK, 'isa_sref';
push @{$EXPORT_TAGS{isas}}, 'isa_sref';
*isa_sref = $scalarref->compiled_check;

push @EXPORT_OK, 'isa_str';
push @{$EXPORT_TAGS{isas}}, 'isa_str';
*isa_str = $string->compiled_check;

push @EXPORT_OK, 'isa_string';
push @{$EXPORT_TAGS{isas}}, 'isa_string';
*isa_string = $string->compiled_check;

push @EXPORT_OK, 'isa_nil';
push @{$EXPORT_TAGS{isas}}, 'isa_nil';
*isa_nil = $undefined->compiled_check;

push @EXPORT_OK, 'isa_null';
push @{$EXPORT_TAGS{isas}}, 'isa_null';
*isa_null = $undefined->compiled_check;

push @EXPORT_OK, 'isa_undef';
push @{$EXPORT_TAGS{isas}}, 'isa_undef';
*isa_undef = $undefined->compiled_check;

push @EXPORT_OK, 'isa_undefined';
push @{$EXPORT_TAGS{isas}}, 'isa_undefined';
*isa_undefined = $undefined->compiled_check;

push @EXPORT_OK, 'isa_val';
push @{$EXPORT_TAGS{isas}}, 'isa_val';
*isa_val = $value->compiled_check;

push @EXPORT_OK, 'isa_value';
push @{$EXPORT_TAGS{isas}}, 'isa_value';
*isa_value = $value->compiled_check;

# EXPORT: NOTS

push @EXPORT_OK, 'not_aref';
push @{$EXPORT_TAGS{nots}}, 'not_aref';
*not_aref = $arrayref->complementary_type->compiled_check;

push @EXPORT_OK, 'not_arrayref';
push @{$EXPORT_TAGS{nots}}, 'not_arrayref';
*not_arrayref = $arrayref->complementary_type->compiled_check;

push @EXPORT_OK, 'not_bool';
push @{$EXPORT_TAGS{nots}}, 'not_bool';
*not_bool = $boolean->complementary_type->compiled_check;

push @EXPORT_OK, 'not_boolean';
push @{$EXPORT_TAGS{nots}}, 'not_boolean';
*not_boolean = $boolean->complementary_type->compiled_check;

push @EXPORT_OK, 'not_class';
push @{$EXPORT_TAGS{nots}}, 'not_class';
*not_class = $classname->complementary_type->compiled_check;

push @EXPORT_OK, 'not_classname';
push @{$EXPORT_TAGS{nots}}, 'not_classname';
*not_classname = $classname->complementary_type->compiled_check;

push @EXPORT_OK, 'not_coderef';
push @{$EXPORT_TAGS{nots}}, 'not_coderef';
*not_coderef = $coderef->complementary_type->compiled_check;

push @EXPORT_OK, 'not_cref';
push @{$EXPORT_TAGS{nots}}, 'not_cref';
*not_cref = $coderef->complementary_type->compiled_check;

push @EXPORT_OK, 'not_def';
push @{$EXPORT_TAGS{nots}}, 'not_def';
*not_def = $defined->complementary_type->compiled_check;

push @EXPORT_OK, 'not_defined';
push @{$EXPORT_TAGS{nots}}, 'not_defined';
*not_defined = $defined->complementary_type->compiled_check;

push @EXPORT_OK, 'not_fh';
push @{$EXPORT_TAGS{nots}}, 'not_fh';
*not_fh = $filehandle->complementary_type->compiled_check;

push @EXPORT_OK, 'not_filehandle';
push @{$EXPORT_TAGS{nots}}, 'not_filehandle';
*not_filehandle = $filehandle->complementary_type->compiled_check;

push @EXPORT_OK, 'not_glob';
push @{$EXPORT_TAGS{nots}}, 'not_glob';
*not_glob = $globref->complementary_type->compiled_check;

push @EXPORT_OK, 'not_globref';
push @{$EXPORT_TAGS{nots}}, 'not_globref';
*not_globref = $globref->complementary_type->compiled_check;

push @EXPORT_OK, 'not_hashref';
push @{$EXPORT_TAGS{nots}}, 'not_hashref';
*not_hashref = $hashref->complementary_type->compiled_check;

push @EXPORT_OK, 'not_href';
push @{$EXPORT_TAGS{nots}}, 'not_href';
*not_href = $hashref->complementary_type->compiled_check;

push @EXPORT_OK, 'not_int';
push @{$EXPORT_TAGS{nots}}, 'not_int';
*not_int = $integer->complementary_type->compiled_check;

push @EXPORT_OK, 'not_integer';
push @{$EXPORT_TAGS{nots}}, 'not_integer';
*not_integer = $integer->complementary_type->compiled_check;

push @EXPORT_OK, 'not_num';
push @{$EXPORT_TAGS{nots}}, 'not_num';
*not_num = $number->complementary_type->compiled_check;

push @EXPORT_OK, 'not_number';
push @{$EXPORT_TAGS{nots}}, 'not_number';
*not_number = $number->complementary_type->compiled_check;

push @EXPORT_OK, 'not_obj';
push @{$EXPORT_TAGS{nots}}, 'not_obj';
*not_obj = $object->complementary_type->compiled_check;

push @EXPORT_OK, 'not_object';
push @{$EXPORT_TAGS{nots}}, 'not_object';
*not_object = $object->complementary_type->compiled_check;

push @EXPORT_OK, 'not_ref';
push @{$EXPORT_TAGS{nots}}, 'not_ref';
*not_ref = $reference->complementary_type->compiled_check;

push @EXPORT_OK, 'not_reference';
push @{$EXPORT_TAGS{nots}}, 'not_reference';
*not_reference = $reference->complementary_type->compiled_check;

push @EXPORT_OK, 'not_regexpref';
push @{$EXPORT_TAGS{nots}}, 'not_regexpref';
*not_regexpref = $regexpref->complementary_type->compiled_check;

push @EXPORT_OK, 'not_rref';
push @{$EXPORT_TAGS{nots}}, 'not_rref';
*not_rref = $regexpref->complementary_type->compiled_check;

push @EXPORT_OK, 'not_scalarref';
push @{$EXPORT_TAGS{nots}}, 'not_scalarref';
*not_scalarref = $scalarref->complementary_type->compiled_check;

push @EXPORT_OK, 'not_sref';
push @{$EXPORT_TAGS{nots}}, 'not_sref';
*not_sref = $scalarref->complementary_type->compiled_check;

push @EXPORT_OK, 'not_str';
push @{$EXPORT_TAGS{nots}}, 'not_str';
*not_str = $string->complementary_type->compiled_check;

push @EXPORT_OK, 'not_string';
push @{$EXPORT_TAGS{nots}}, 'not_string';
*not_string = $string->complementary_type->compiled_check;

push @EXPORT_OK, 'not_nil';
push @{$EXPORT_TAGS{nots}}, 'not_nil';
*not_nil = $undefined->complementary_type->compiled_check;

push @EXPORT_OK, 'not_null';
push @{$EXPORT_TAGS{nots}}, 'not_null';
*not_null = $undefined->complementary_type->compiled_check;

push @EXPORT_OK, 'not_undef';
push @{$EXPORT_TAGS{nots}}, 'not_undef';
*not_undef = $undefined->complementary_type->compiled_check;

push @EXPORT_OK, 'not_undefined';
push @{$EXPORT_TAGS{nots}}, 'not_undefined';
*not_undefined = $undefined->complementary_type->compiled_check;

push @EXPORT_OK, 'not_val';
push @{$EXPORT_TAGS{nots}}, 'not_val';
*not_val = $value->complementary_type->compiled_check;

push @EXPORT_OK, 'not_value';
push @{$EXPORT_TAGS{nots}}, 'not_value';
*not_value = $value->complementary_type->compiled_check;

# EXPORT: TYPES

push @EXPORT_OK, 'type_aref';
push @{$EXPORT_TAGS{types}}, 'type_aref';
*type_aref = $arrayref->_overload_coderef;

push @EXPORT_OK, 'type_arrayref';
push @{$EXPORT_TAGS{types}}, 'type_arrayref';
*type_arrayref = $arrayref->_overload_coderef;

push @EXPORT_OK, 'type_bool';
push @{$EXPORT_TAGS{types}}, 'type_bool';
*type_bool = $boolean->_overload_coderef;

push @EXPORT_OK, 'type_boolean';
push @{$EXPORT_TAGS{types}}, 'type_boolean';
*type_boolean = $boolean->_overload_coderef;

push @EXPORT_OK, 'type_class';
push @{$EXPORT_TAGS{types}}, 'type_class';
*type_class = $classname->_overload_coderef;

push @EXPORT_OK, 'type_classname';
push @{$EXPORT_TAGS{types}}, 'type_classname';
*type_classname = $classname->_overload_coderef;

push @EXPORT_OK, 'type_coderef';
push @{$EXPORT_TAGS{types}}, 'type_coderef';
*type_coderef = $coderef->_overload_coderef;

push @EXPORT_OK, 'type_cref';
push @{$EXPORT_TAGS{types}}, 'type_cref';
*type_cref = $coderef->_overload_coderef;

push @EXPORT_OK, 'type_def';
push @{$EXPORT_TAGS{types}}, 'type_def';
*type_def = $defined->_overload_coderef;

push @EXPORT_OK, 'type_defined';
push @{$EXPORT_TAGS{types}}, 'type_defined';
*type_defined = $defined->_overload_coderef;

push @EXPORT_OK, 'type_fh';
push @{$EXPORT_TAGS{types}}, 'type_fh';
*type_fh = $filehandle->_overload_coderef;

push @EXPORT_OK, 'type_filehandle';
push @{$EXPORT_TAGS{types}}, 'type_filehandle';
*type_filehandle = $filehandle->_overload_coderef;

push @EXPORT_OK, 'type_glob';
push @{$EXPORT_TAGS{types}}, 'type_glob';
*type_glob = $globref->_overload_coderef;

push @EXPORT_OK, 'type_globref';
push @{$EXPORT_TAGS{types}}, 'type_globref';
*type_globref = $globref->_overload_coderef;

push @EXPORT_OK, 'type_hashref';
push @{$EXPORT_TAGS{types}}, 'type_hashref';
*type_hashref = $hashref->_overload_coderef;

push @EXPORT_OK, 'type_href';
push @{$EXPORT_TAGS{types}}, 'type_href';
*type_href = $hashref->_overload_coderef;

push @EXPORT_OK, 'type_int';
push @{$EXPORT_TAGS{types}}, 'type_int';
*type_int = $integer->_overload_coderef;

push @EXPORT_OK, 'type_integer';
push @{$EXPORT_TAGS{types}}, 'type_integer';
*type_integer = $integer->_overload_coderef;

push @EXPORT_OK, 'type_num';
push @{$EXPORT_TAGS{types}}, 'type_num';
*type_num = $number->_overload_coderef;

push @EXPORT_OK, 'type_number';
push @{$EXPORT_TAGS{types}}, 'type_number';
*type_number = $number->_overload_coderef;

push @EXPORT_OK, 'type_obj';
push @{$EXPORT_TAGS{types}}, 'type_obj';
*type_obj = $object->_overload_coderef;

push @EXPORT_OK, 'type_object';
push @{$EXPORT_TAGS{types}}, 'type_object';
*type_object = $object->_overload_coderef;

push @EXPORT_OK, 'type_ref';
push @{$EXPORT_TAGS{types}}, 'type_ref';
*type_ref = $reference->_overload_coderef;

push @EXPORT_OK, 'type_reference';
push @{$EXPORT_TAGS{types}}, 'type_reference';
*type_reference = $reference->_overload_coderef;

push @EXPORT_OK, 'type_regexpref';
push @{$EXPORT_TAGS{types}}, 'type_regexpref';
*type_regexpref = $regexpref->_overload_coderef;

push @EXPORT_OK, 'type_rref';
push @{$EXPORT_TAGS{types}}, 'type_rref';
*type_rref = $regexpref->_overload_coderef;

push @EXPORT_OK, 'type_scalarref';
push @{$EXPORT_TAGS{types}}, 'type_scalarref';
*type_scalarref = $scalarref->_overload_coderef;

push @EXPORT_OK, 'type_sref';
push @{$EXPORT_TAGS{types}}, 'type_sref';
*type_sref = $scalarref->_overload_coderef;

push @EXPORT_OK, 'type_str';
push @{$EXPORT_TAGS{types}}, 'type_str';
*type_str = $string->_overload_coderef;

push @EXPORT_OK, 'type_string';
push @{$EXPORT_TAGS{types}}, 'type_string';
*type_string = $string->_overload_coderef;

push @EXPORT_OK, 'type_nil';
push @{$EXPORT_TAGS{types}}, 'type_nil';
*type_nil = $undefined->_overload_coderef;

push @EXPORT_OK, 'type_null';
push @{$EXPORT_TAGS{types}}, 'type_null';
*type_null = $undefined->_overload_coderef;

push @EXPORT_OK, 'type_undef';
push @{$EXPORT_TAGS{types}}, 'type_undef';
*type_undef = $undefined->_overload_coderef;

push @EXPORT_OK, 'type_undefined';
push @{$EXPORT_TAGS{types}}, 'type_undefined';
*type_undefined = $undefined->_overload_coderef;

push @EXPORT_OK, 'type_val';
push @{$EXPORT_TAGS{types}}, 'type_val';
*type_val = $value->_overload_coderef;

push @EXPORT_OK, 'type_value';
push @{$EXPORT_TAGS{types}}, 'type_value';
*type_value = $value->_overload_coderef;

# EXPORT: TYPESOF

push @EXPORT_OK, 'typeof_aref';
push @{$EXPORT_TAGS{typesof}}, 'typeof_aref';
*typeof_aref = sub () {
    require Type::Params;
    Type::Params::compile($arrayref);
};

push @EXPORT_OK, 'typeof_arrayref';
push @{$EXPORT_TAGS{typesof}}, 'typeof_arrayref';
*typeof_arrayref = sub () {
    require Type::Params;
    Type::Params::compile($arrayref);
};

push @EXPORT_OK, 'typeof_bool';
push @{$EXPORT_TAGS{typesof}}, 'typeof_bool';
*typeof_bool = sub () {
    require Type::Params;
    Type::Params::compile($boolean);
};

push @EXPORT_OK, 'typeof_boolean';
push @{$EXPORT_TAGS{typesof}}, 'typeof_boolean';
*typeof_boolean = sub () {
    require Type::Params;
    Type::Params::compile($boolean);
};

push @EXPORT_OK, 'typeof_class';
push @{$EXPORT_TAGS{typesof}}, 'typeof_class';
*typeof_class = sub () {
    require Type::Params;
    Type::Params::compile($classname);
};

push @EXPORT_OK, 'typeof_classname';
push @{$EXPORT_TAGS{typesof}}, 'typeof_classname';
*typeof_classname = sub () {
    require Type::Params;
    Type::Params::compile($classname);
};

push @EXPORT_OK, 'typeof_coderef';
push @{$EXPORT_TAGS{typesof}}, 'typeof_coderef';
*typeof_coderef = sub () {
    require Type::Params;
    Type::Params::compile($coderef);
};

push @EXPORT_OK, 'typeof_cref';
push @{$EXPORT_TAGS{typesof}}, 'typeof_cref';
*typeof_cref = sub () {
    require Type::Params;
    Type::Params::compile($coderef);
};

push @EXPORT_OK, 'typeof_def';
push @{$EXPORT_TAGS{typesof}}, 'typeof_def';
*typeof_def = sub () {
    require Type::Params;
    Type::Params::compile($defined);
};

push @EXPORT_OK, 'typeof_defined';
push @{$EXPORT_TAGS{typesof}}, 'typeof_defined';
*typeof_defined = sub () {
    require Type::Params;
    Type::Params::compile($defined);
};

push @EXPORT_OK, 'typeof_fh';
push @{$EXPORT_TAGS{typesof}}, 'typeof_fh';
*typeof_fh = sub () {
    require Type::Params;
    Type::Params::compile($filehandle);
};

push @EXPORT_OK, 'typeof_filehandle';
push @{$EXPORT_TAGS{typesof}}, 'typeof_filehandle';
*typeof_filehandle = sub () {
    require Type::Params;
    Type::Params::compile($filehandle);
};

push @EXPORT_OK, 'typeof_glob';
push @{$EXPORT_TAGS{typesof}}, 'typeof_glob';
*typeof_glob = sub () {
    require Type::Params;
    Type::Params::compile($globref);
};

push @EXPORT_OK, 'typeof_globref';
push @{$EXPORT_TAGS{typesof}}, 'typeof_globref';
*typeof_globref = sub () {
    require Type::Params;
    Type::Params::compile($globref);
};

push @EXPORT_OK, 'typeof_hashref';
push @{$EXPORT_TAGS{typesof}}, 'typeof_hashref';
*typeof_hashref = sub () {
    require Type::Params;
    Type::Params::compile($hashref);
};

push @EXPORT_OK, 'typeof_href';
push @{$EXPORT_TAGS{typesof}}, 'typeof_href';
*typeof_href = sub () {
    require Type::Params;
    Type::Params::compile($hashref);
};

push @EXPORT_OK, 'typeof_int';
push @{$EXPORT_TAGS{typesof}}, 'typeof_int';
*typeof_int = sub () {
    require Type::Params;
    Type::Params::compile($integer);
};

push @EXPORT_OK, 'typeof_integer';
push @{$EXPORT_TAGS{typesof}}, 'typeof_integer';
*typeof_integer = sub () {
    require Type::Params;
    Type::Params::compile($integer);
};

push @EXPORT_OK, 'typeof_num';
push @{$EXPORT_TAGS{typesof}}, 'typeof_num';
*typeof_num = sub () {
    require Type::Params;
    Type::Params::compile($number);
};

push @EXPORT_OK, 'typeof_number';
push @{$EXPORT_TAGS{typesof}}, 'typeof_number';
*typeof_number = sub () {
    require Type::Params;
    Type::Params::compile($number);
};

push @EXPORT_OK, 'typeof_obj';
push @{$EXPORT_TAGS{typesof}}, 'typeof_obj';
*typeof_obj = sub () {
    require Type::Params;
    Type::Params::compile($object);
};

push @EXPORT_OK, 'typeof_object';
push @{$EXPORT_TAGS{typesof}}, 'typeof_object';
*typeof_object = sub () {
    require Type::Params;
    Type::Params::compile($object);
};

push @EXPORT_OK, 'typeof_ref';
push @{$EXPORT_TAGS{typesof}}, 'typeof_ref';
*typeof_ref = sub () {
    require Type::Params;
    Type::Params::compile($reference);
};

push @EXPORT_OK, 'typeof_reference';
push @{$EXPORT_TAGS{typesof}}, 'typeof_reference';
*typeof_reference = sub () {
    require Type::Params;
    Type::Params::compile($reference);
};

push @EXPORT_OK, 'typeof_regexpref';
push @{$EXPORT_TAGS{typesof}}, 'typeof_regexpref';
*typeof_regexpref = sub () {
    require Type::Params;
    Type::Params::compile($regexpref);
};

push @EXPORT_OK, 'typeof_rref';
push @{$EXPORT_TAGS{typesof}}, 'typeof_rref';
*typeof_rref = sub () {
    require Type::Params;
    Type::Params::compile($regexpref);
};

push @EXPORT_OK, 'typeof_scalarref';
push @{$EXPORT_TAGS{typesof}}, 'typeof_scalarref';
*typeof_scalarref = sub () {
    require Type::Params;
    Type::Params::compile($scalarref);
};

push @EXPORT_OK, 'typeof_sref';
push @{$EXPORT_TAGS{typesof}}, 'typeof_sref';
*typeof_sref = sub () {
    require Type::Params;
    Type::Params::compile($scalarref);
};

push @EXPORT_OK, 'typeof_str';
push @{$EXPORT_TAGS{typesof}}, 'typeof_str';
*typeof_str = sub () {
    require Type::Params;
    Type::Params::compile($string);
};

push @EXPORT_OK, 'typeof_string';
push @{$EXPORT_TAGS{typesof}}, 'typeof_string';
*typeof_string = sub () {
    require Type::Params;
    Type::Params::compile($string);
};

push @EXPORT_OK, 'typeof_nil';
push @{$EXPORT_TAGS{typesof}}, 'typeof_nil';
*typeof_nil = sub () {
    require Type::Params;
    Type::Params::compile($undefined);
};

push @EXPORT_OK, 'typeof_null';
push @{$EXPORT_TAGS{typesof}}, 'typeof_null';
*typeof_null = sub () {
    require Type::Params;
    Type::Params::compile($undefined);
};

push @EXPORT_OK, 'typeof_undef';
push @{$EXPORT_TAGS{typesof}}, 'typeof_undef';
*typeof_undef = sub () {
    require Type::Params;
    Type::Params::compile($undefined);
};

push @EXPORT_OK, 'typeof_undefined';
push @{$EXPORT_TAGS{typesof}}, 'typeof_undefined';
*typeof_undefined = sub () {
    require Type::Params;
    Type::Params::compile($undefined);
};

push @EXPORT_OK, 'typeof_val';
push @{$EXPORT_TAGS{typesof}}, 'typeof_val';
*typeof_val = sub () {
    require Type::Params;
    Type::Params::compile($value);
};

push @EXPORT_OK, 'typeof_value';
push @{$EXPORT_TAGS{typesof}}, 'typeof_value';
*typeof_value = sub () {
    require Type::Params;
    Type::Params::compile($value);
};

1;

__END__