NAME

Data::Object::Library

ABSTRACT

Data-Object Type Library

SYNOPSIS

use Data::Object::Library;

DESCRIPTION

This package provides a core type library for the Do framework.

INHERITANCE

This package inherits behaviors from:

Type::Library

Types::Standard

Types::Common::String

Types::Common::Numeric

FUNCTIONS

This package implements the following functions.

doargs

DoArgs() : HashRef

This function returns the type configuration for a Data::Object::Args object.

DoArgs example

Data::Object::Library::DoArgs();

doarray

DoArray() : HashRef

This function returns the type configuration for a Data::Object::Array object.

DoArray example

Data::Object::Library::DoArray();

docli

DoCli() : HashRef

This function returns the type configuration for a Data::Object::Cli object.

DoCli example

Data::Object::Library::DoCli();

docode

DoCode() : HashRef

This function returns the type configuration for a Data::Object::Code object.

DoCode example

Data::Object::Library::DoCode();

dodata

DoData() : HashRef

This function returns the type configuration for a Data::Object::Data object.

DoData example

Data::Object::Library::DoData();

dodumpable

DoDumpable() : HashRef

This function returns the type configuration for an object with the Data::Object::Role::Dumpable role.

DoDumpable example

Data::Object::Library::DoDumpable();

doexception

DoException() : HashRef

This function returns the type configuration for a Data::Object::Exception object.

DoException example

Data::Object::Library::DoException();

dofloat

DoFloat() : HashRef

This function returns the type configuration for a Data::Object::Float object.

DoFloat example

Data::Object::Library::DoFloat();

dofunc

DoFunc() : HashRef

This function returns the type configuration for a Data::Object::Func object.

DoFunc example

Data::Object::Library::DoFunc();

dohash

DoHash() : HashRef

This function returns the type configuration for a Data::Object::Hash object.

DoHash example

Data::Object::Library::DoHash();

doimmutable

DoImmutable() : HashRef

This function returns the type configuration for an object with the Data::Object::Role::Immutable role.

DoImmutable example

Data::Object::Library::DoImmutable();

donumber

DoNumber() : HashRef

This function returns the type configuration for a Data::Object::Number object.

DoNumber example

Data::Object::Library::DoNumber();

doopts

DoOpts() : HashRef

This function returns the type configuration for a Data::Object::Opts object.

DoOpts example

Data::Object::Library::DoOpts();

doregexp

DoRegexp() : HashRef

This function returns the type configuration for a Data::Object::Regexp object.

DoRegexp example

Data::Object::Library::DoRegexp();

doreplace

DoReplace() : HashRef

This function returns the type configuration for a Data::Object::Replace object.

DoReplace example

Data::Object::Library::DoReplace();

doscalar

DoScalar() : HashRef

This function returns the type configuration for a Data::Object::Scalar object.

DoScalar example

Data::Object::Library::DoScalar();

dosearch

DoSearch() : HashRef

This function returns the type configuration for a Data::Object::Search object.

DoSearch example

Data::Object::Library::DoSearch();

dospace

DoSpace() : HashRef

This function returns the type configuration for a Data::Object::Space object.

DoSpace example

Data::Object::Library::DoSpace();

dostashable

DoStashable() : HashRef

This function returns the type configuration for an object with the Data::Object::Role::Stashable role.

DoStashable example

Data::Object::Library::DoStashable();

dostate

DoState() : HashRef

This function returns the type configuration for a Data::Object::State object.

DoState example

Data::Object::Library::DoState();

dostring

DoString() : HashRef

This function returns the type configuration for a Data::Object::String object.

DoString example

Data::Object::Library::DoString();

dostruct

DoStruct() : HashRef

This function returns the type configuration for a Data::Object::Struct object.

DoStruct example

Data::Object::Library::DoStruct();

dothrowable

DoThrowable() : HashRef

This function returns the type configuration for an object with the Data::Object::Role::Throwable role.

DoThrowable example

Data::Object::Library::DoThrowable();

doundef

DoUndef() : HashRef

This function returns the type configuration for a Data::Object::Undef object.

DoUndef example

Data::Object::Library::DoUndef();

dovars

DoVars() : HashRef

This function returns the type configuration for a Data::Object::Vars object.

DoVars example

Data::Object::Library::DoVars();

generatecoercion

GenerateCoercion(HashRef $config) : InstanceOf["Type::Coercion"]

This function takes a type configuration hashref, then generates and returns a type coercion based on its configuration.

GenerateCoercion example

Data::Object::Library::GenerateCoercion({...});

generateconstraint

GenerateConstraint(HashRef $config) : CodeRef

This function takes a type configuration hashref, then generates and returns a coderef which validates the type based on its configuration.

GenerateConstraint example

Data::Object::Library::GenerateConstraint({...});

generateexplanation

GenerateExplanation(HashRef $config) : CodeRef

This function takes a type configuration hashref, then generates and returns a coderef which returns a deep-explanation of the type failure based on its configuration.

GenerateExplanation example

Data::Object::Library::GenerateExplanation({...});

library

Library() : InstanceOf["Type::Library"]

This function returns the core type library object.

Library example

Data::Object::Library::Library();

options

Options(HashRef $config) : (Any)

This function takes a type configuration hashref, then generates and returns a set of options relevant to creating Type::Tiny objects.

Options example

Data::Object::Library::Options({...});

register

Register(HashRef $config) : InstanceOf["Type::Tiny"]

This function takes a type configuration hashref, then generates and returns a Type::Tiny object based on its configuration.

Register example

Data::Object::Library::Register({...});

registerall

RegisterAll(HashRef $config) : InstanceOf["Type::Tiny"]

This function takes a type configuration hashref, then generates and returns a Type::Tiny object based on its configuration. This method also registers aliases as stand-alone types in the library.

RegisterAll example

Data::Object::Library::RegisterAll({...});

CONSTRAINTS

This package provides the following type constraints.

any

# Any

The Any type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_Any function can be used to throw an exception is the argument can not be validated. The is_Any function can be used to return true or false if the argument can not be validated.

arraylike

# ArrayLike

The ArrayLike type constraint is provided by the Types::TypeTiny library. Please see that documentation for more information. The assert_ArrayLike function can be used to throw an exception if the argument can not be validated. The is_ArrayLike function can be used to return true or false if the argument can not be validated.

argsobj

# ArgsObj

The ArgsObj type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Args object. The assert_ArgsObj function can be used to throw an exception if the argument can not be validated. The is_ArgsObj function can be used to return true or false if the argument can not be validated.

argsobject

# ArgsObject

The ArgsObject type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Args object. The assert_ArgsObject function can be used to throw an exception if the argument can not be validated. The is_ArgsObject function can be used to return true or false if the argument can not be validated.

arrayobj

# ArrayObj

The ArrayObj type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Array object. The assert_ArrayObj function can be used to throw an exception if the argument can not be validated. The is_ArrayObj function can be used to return true or false if the argument can not be validated.

arrayobject

# ArrayObject

The ArrayObject type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Array object. The assert_ArrayObject function can be used to throw an exception if the argument can not be validated. The is_ArrayObject function can be used to return true or false if the argument can not be validated.

arrayref

# ArrayRef

The ArrayRef type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_ArrayRef function can be used to throw an exception if the argument can not be validated. The is_ArrayRef function can be used to return true or false if the argument can not be validated.

bool

# Bool

The Bool type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_Bool function can be used to throw an exception if the argument can not be validated. The is_Bool function can be used to return true or false if the argument can not be validated.

classname

# ClassName["MyClass"]

The ClassName type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_ClassName function can be used to throw an exception if the argument can not be validated. The is_ClassName function can be used to return true or false if the argument can not be validated.

codelike

# CodeLike

The CodeLike type constraint is provided by the Types::TypeTiny library. Please see that documentation for more information. The assert_CodeLike function can be used to throw an exception if the argument can not be validated. The is_CodeLike function can be used to return true or false if the argument can not be validated.

cliobj

# CliObj

The CliObj type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Cli object. The assert_CliObj function can be used to throw an exception if the argument can not be validated. The is_CliObj function can be used to return true or false if the argument can not be validated.

cliobject

# CliObject

The CliObject type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Cli object. The assert_CliObject function can be used to throw an exception if the argument can not be validated. The is_CliObject function can be used to return true or false if the argument can not be validated.

codeobj

# CodeObj

The CodeObj type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Code object. The assert_CodeObj function can be used to throw an exception if the argument can not be validated. The is_CodeObj function can be used to return true or false if the argument can not be validated.

codeobject

# CodeObject

The CodeObject type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Code object. The assert_CodeObject function can be used to throw an exception if the argument can not be validated. The is_CodeObject function can be used to return true or false if the argument can not be validated.

coderef

# CodeRef

The CodeRef type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_CodeRef function can be used to throw an exception if the argument can not be validated. The is_CodeRef function can be used to return true or false if the argument can not be validated.

consumerof

# ConsumerOf["MyRole"]

The ConsumerOf type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_ConsumerOf function can be used to throw an exception if the argument can not be validated. The is_ConsumerOf function can be used to return true or false if the argument can not be validated.

dataobj

# DataObj

The DataObj type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Data object. The assert_DataObj function can be used to throw an exception if the argument can not be validated. The is_DataObj function can be used to return true or false if the argument can not be validated.

dataobject

# DataObject

The DataObject type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Data object. The assert_DataObject function can be used to throw an exception if the argument can not be validated. The is_DataObject function can be used to return true or false if the argument can not be validated.

defined

# Defined

The Defined type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_Defined function can be used to throw an exception if the argument can not be validated. The is_Defined function can be used to return true or false if the argument can not be validated.

dict

# Dict

The Dict type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_Dict function can be used to throw an exception if the argument can not be validated. The is_Dict function can be used to return true or false if the argument can not be validated.

dumpable

# Dumpable

The Dumpable type constraint is provided by this library and accepts any object that is a consumer of the Data::Object::Role::Dumpable role. The assert_Dumpable function can be used to throw an exception if the argument can not be validated. The is_Dumpable function can be used to return true or false if the argument can not be validated.

enum

# Enum[qw(A B C)]

The Enum type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_Enum function can be used to throw an exception if the argument can not be validated. The is_Enum function can be used to return true or false if the argument can not be validated.

exceptionobj

# ExceptionObj

The ExceptionObj type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Exception object. The assert_ExceptionObj function can be used to throw an exception if the argument can not be validated. The is_ExceptionObj function can be used to return true or false if the argument can not be validated.

exceptionobject

# ExceptionObject

The ExceptionObject type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Exception object. The assert_ExceptionObject function can be used to throw an exception if the argument can not be validated. The is_ExceptionObject function can be used to return true or false if the argument can not be validated.

filehandle

# FileHandle

The FileHandle type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_FileHandle function can be used to throw an exception if the argument can not be validated. The is_FileHandle function can be used to return true or false if the argument can not be validated.

floatobj

# FloatObj

The FloatObj type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Float object. The assert_FloatObj function can be used to throw an exception if the argument can not be validated. The is_FloatObj function can be used to return true or false if the argument can not be validated.

floatobject

# FloatObject

The FloatObject type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Float object. The assert_FloatObject function can be used to throw an exception if the argument can not be validated. The is_FloatObject function can be used to return true or false if the argument can not be validated.

funcobj

# FuncObj

The FuncObj type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Func object. The assert_FuncObj function can be used to throw an exception if the argument can not be validated. The is_FuncObj function can be used to return true or false if the argument can not be validated.

funcobject

# FuncObject

The FuncObject type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Func object. The assert_FuncObject function can be used to throw an exception if the argument can not be validated. The is_FuncObject function can be used to return true or false if the argument can not be validated.

globref

# GlobRef

The GlobRef type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_GlobRef function can be used to throw an exception if the argument can not be validated. The is_GlobRef function can be used to return true or false if the argument can not be validated.

hasmethods

# HasMethods["new"]

The HasMethods type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_HasMethods function can be used to throw an exception if the argument can not be validated. The is_HasMethods function can be used to return true or false if the argument can not be validated.

hashlike

# HashLike

The HashLike type constraint is provided by the Types::TypeTiny library. Please see that documentation for more information. The assert_HashLike function can be used to throw an exception if the argument can not be validated. The is_HashLike function can be used to return true or false if the argument can not be validated.

hashobj

# HashObj

The HashObj type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Hash object. The assert_HashObj function can be used to throw an exception if the argument can not be validated. The is_HashObj function can be used to return true or false if the argument can not be validated.

hashobject

# HashObject

The HashObject type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Hash object. The assert_HashObject function can be used to throw an exception if the argument can not be validated. The is_HashObject function can be used to return true or false if the argument can not be validated.

hashref

# HashRef

The HashRef type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_HashRef function can be used to throw an exception if the argument can not be validated. The is_HashRef function can be used to return true or false if the argument can not be validated.

immutable

# Immutable

The Immutable type constraint is provided by this library and accepts any object that is a consumer of the Data::Object::Role::Immutable role. The assert_Immutable function can be used to throw an exception if the argument can not be validated. The is_Immutable function can be used to return true or false if the argument can not be validated.

instanceof

# InstanceOf[MyClass]

The InstanceOf type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_InstanceOf function can be used to throw an exception if the argument can not be validated. The is_InstanceOf function can be used to return true or false if the argument can not be validated.

int

# Int

The Int type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_Int function can be used to throw an exception if the argument can not be validated. The is_Int function can be used to return true or false if the argument can not be validated.

intobj

# IntObj

The IntObj type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Integer object. The assert_IntObj function can be used to throw an exception if the argument can not be validated. The is_IntObj function can be used to return true or false if the argument can not be validated.

intobject

# IntObject

The IntObject type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Integer object. The assert_IntObject function can be used to throw an exception if the argument can not be validated. The is_IntObject function can be used to return true or false if the argument can not be validated.

intrange

# IntRange[0, 25]

The IntRange type constraint is provided by the Types::TypeTiny library. Please see that documentation for more information. The assert_IntRange function can be used to throw an exception if the argument can not be validated. The is_IntRange function can be used to return true or false if the argument can not be validated.

integerobj

# IntegerObj

The IntegerObj type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Integer object. The assert_IntegerObj function can be used to throw an exception if the argument can not be validated. The is_IntegerObj function can be used to return true or false if the argument can not be validated.

integerobject

# IntegerObject

The IntegerObject type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Integer object. The assert_IntegerObject function can be used to throw an exception if the argument can not be validated. The is_IntegerObject function can be used to return true or false if the argument can not be validated.

item

# Item

The Item type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_Item function can be used to throw an exception if the argument can not be validated. The is_Item function can be used to return true or false if the argument can not be validated.

laxnum

# LaxNum

The LaxNum type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_LaxNum function can be used to throw an exception if the argument can not be validated. The is_LaxNum function can be used to return true or false if the argument can not be validated.

lowercasesimplestr

# LowerCaseSimpleStr

The LowerCaseSimpleStr type constraint is provided by the Types::Common::String library. Please see that documentation for more The assert_LowerCaseSimpleStr function can be used to throw an exception if the argument can not be validated. The is_LowerCaseSimpleStr function can be used to return true or false if the argument can not be validated. information.

lowercasestr

# LowerCaseStr

The LowerCaseStr type constraint is provided by the Types::Common::String library. Please see that documentation for more information. The assert_type function can be used to throw an exception if the argument can not be validated. The is_type function can be used to return true or false if the argument can not be validated.

map

# Map[Int, HashRef]

The Map type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_Map function can be used to throw an exception if the argument can not be validated. The is_Map function can be used to return true or false if the argument can not be validated.

maybe

# Maybe[Object]

The Maybe type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_Maybe function can be used to throw an exception if the argument can not be validated. The is_Maybe function can be used to return true or false if the argument can not be validated.

negativeint

# NegativeInt

The NegativeInt type constraint is provided by the Types::Common::Numeric library. Please see that documentation for more information. The assert_NegativeInt function can be used to throw an exception if the argument can not be validated. The is_NegativeInt function can be used to return true or false if the argument can not be validated.

negativenum

# NegativeNum

The NegativeNum type constraint is provided by the Types::Common::Numeric library. Please see that documentation for more information. The assert_NegativeNum function can be used to throw an exception if the argument can not be validated. The is_NegativeNum function can be used to return true or false if the argument can not be validated.

negativeorzeroint

# NegativeOrZeroInt

The NegativeOrZeroInt type constraint is provided by the Types::Common::Numeric library. Please see that documentation for more The assert_NegativeOrZeroInt function can be used to throw an exception if the argument can not be validated. The is_NegativeOrZeroInt function can be used to return true or false if the argument can not be validated. information.

negativeorzeronum

# NegativeOrZeroNum

The NegativeOrZeroNum type constraint is provided by the Types::Common::Numeric library. Please see that documentation for more The assert_type function can be used to throw an exception if the argument can not be validated. The is_type function can be used to return true or false if the argument can not be validated. information.

nonemptysimplestr

# NonEmptySimpleStr

The NonEmptySimpleStr type constraint is provided by the Types::Common::String library. Please see that documentation for more The assert_type function can be used to throw an exception if the argument can not be validated. The is_type function can be used to return true or false if the argument can not be validated. information.

nonemptystr

# NonEmptyStr

The NonEmptyStr type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_type function can be used to throw an exception if the argument can not be validated. The is_type function can be used to return true or false if the argument can not be validated.

num

# Num

The Num type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_Num function can be used to throw an exception if the argument can not be validated. The is_Num function can be used to return true or false if the argument can not be validated.

numberlike

# NumberLike

The NumberLike type constraint is provided by the this library and accepts any value that looks like a number, or object that overloads stringification and looks like a number stringified. Please see that documentation for more information. The assert_NumberLike function can be used to throw an exception if the argument can not be validated. The is_NumberLike function can be used to return true or false if the argument can not be validated.

numobj

# NumObj

The NumObj type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Number object. The assert_NumObj function can be used to throw an exception if the argument can not be validated. The is_NumObj function can be used to return true or false if the argument can not be validated.

numobject

# NumObject

The NumObject type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Number object. The assert_NumObject function can be used to throw an exception if the argument can not be validated. The is_NumObject function can be used to return true or false if the argument can not be validated.

numrange

# NumRange[0, 25]

The NumRange type constraint is provided by the Types::TypeTiny library. Please see that documentation for more information. The assert_NumRange function can be used to throw an exception if the argument can not be validated. The is_NumRange function can be used to return true or false if the argument can not be validated.

numberobject

# NumberObject

The NumberObject type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Number object. The assert_NumberObject function can be used to throw an exception if the argument can not be validated. The is_NumberObject function can be used to return true or false if the argument can not be validated.

numericcode

# NumericCode

The NumericCode type constraint is provided by the Types::Common::String library. Please see that documentation for more information. The assert_NumericCode function can be used to throw an exception if the argument can not be validated. The is_NumericCode function can be used to return true or false if the argument can not be validated.

object

# Object

The Object type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_Object function can be used to throw an exception if the argument can not be validated. The is_Object function can be used to return true or false if the argument can not be validated.

optsobj

# OptsObj

The OptsObj type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Opts object. The assert_OptsObj function can be used to throw an exception if the argument can not be validated. The is_OptsObj function can be used to return true or false if the argument can not be validated.

optsobject

# OptsObject

The OptsObject type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Opts object. The assert_OptsObject function can be used to throw an exception if the argument can not be validated. The is_OptsObject function can be used to return true or false if the argument can not be validated.

optlist

# OptList

The OptList type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_OptList function can be used to throw an exception if the argument can not be validated. The is_OptList function can be used to return true or false if the argument can not be validated.

optional

# Dict[id => Optional[Int]]

The Optional type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_Optional function can be used to throw an exception if the argument can not be validated. The is_Optional function can be used to return true or false if the argument can not be validated.

overload

# Overload[qw("")]

The Overload type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_Overload function can be used to throw an exception if the argument can not be validated. The is_Overload function can be used to return true or false if the argument can not be validated.

password

# Password

The Password type constraint is provided by the Types::Common::String library. Please see that documentation for more information. The assert_Password function can be used to throw an exception if the argument can not be validated. The is_Password function can be used to return true or false if the argument can not be validated.

positiveint

# PositiveInt

The PositiveInt type constraint is provided by the Types::Common::Numeric library. Please see that documentation for more information. The assert_PositiveInt function can be used to throw an exception if the argument can not be validated. The is_PositiveInt function can be used to return true or false if the argument can not be validated.

positivenum

# PositiveNum

The PositiveNum type constraint is provided by the Types::Common::Numeric library. Please see that documentation for more information. The assert_PositiveNum function can be used to throw an exception if the argument can not be validated. The is_PositiveNum function can be used to return true or false if the argument can not be validated.

positiveorzeroint

# PositiveOrZeroInt

The PositiveOrZeroInt type constraint is provided by the Types::Common::Numeric library. Please see that documentation for more The assert_PositiveOrZeroInt function can be used to throw an exception if the argument can not be validated. The is_PositiveOrZeroInt function can be used to return true or false if the argument can not be validated. information.

positiveorzeronum

# PositiveOrZeroNum

The PositiveOrZeroNum type constraint is provided by the Types::Common::Numeric library. Please see that documentation for more The assert_type function can be used to throw an exception if the argument can not be validated. The is_type function can be used to return true or false if the argument can not be validated. information.

ref

# Ref["SCALAR"]

The Ref type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_type function can be used to throw an exception if the argument can not be validated. The is_type function can be used to return true or false if the argument can not be validated.

regexpobj

# RegexpObj

The RegexpObj type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Regexp object. The assert_RegexpObj function can be used to throw an exception if the argument can not be validated. The is_RegexpObj function can be used to return true or false if the argument can not be validated.

regexpobject

# RegexpObject

The RegexpObject type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Regexp object. The assert_RegexpObject function can be used to throw an exception if the argument can not be validated. The is_RegexpObject function can be used to return true or false if the argument can not be validated.

regexpref

# RegexpRef

The RegexpRef type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_RegexpRef function can be used to throw an exception if the argument can not be validated. The is_RegexpRef function can be used to return true or false if the argument can not be validated.

replaceobj

# ReplaceObj

The ReplaceObj type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Replace object. The assert_ReplaceObj function can be used to throw an exception if the argument can not be validated. The is_ReplaceObj function can be used to return true or false if the argument can not be validated.

replaceobject

# ReplaceObject

The ReplaceObject type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Replace object. The assert_ReplaceObject function can be used to throw an exception if the argument can not be validated. The is_ReplaceObject function can be used to return true or false if the argument can not be validated.

rolename

# RoleName

The RoleName type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_RoleName function can be used to throw an exception if the argument can not be validated. The is_RoleName function can be used to return true or false if the argument can not be validated.

scalarobj

# ScalarObj

The ScalarObj type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Scalar object. The assert_ScalarObj function can be used to throw an exception if the argument can not be validated. The is_ScalarObj function can be used to return true or false if the argument can not be validated.

scalarobject

# ScalarObject

The ScalarObject type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Scalar object. The assert_ScalarObject function can be used to throw an exception if the argument can not be validated. The is_ScalarObject function can be used to return true or false if the argument can not be validated.

scalarref

# ScalarRef

The ScalarRef type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_ScalarRef function can be used to throw an exception if the argument can not be validated. The is_ScalarRef function can be used to return true or false if the argument can not be validated.

searchobj

# SearchObj

The SearchObj type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Search object. The assert_SearchObj function can be used to throw an exception if the argument can not be validated. The is_SearchObj function can be used to return true or false if the argument can not be validated.

searchobject

# SearchObject

The SearchObject type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Search object. The assert_SearchObject function can be used to throw an exception if the argument can not be validated. The is_SearchObject function can be used to return true or false if the argument can not be validated.

simplestr

# SimpleStr

The SimpleStr type constraint is provided by the Types::Common::String library. Please see that documentation for more information. The assert_SimpleStr function can be used to throw an exception if the argument can not be validated. The is_SimpleStr function can be used to return true or false if the argument can not be validated.

singledigit

# SingleDigit

The SingleDigit type constraint is provided by the Types::Common::Numeric library. Please see that documentation for more information. The assert_SingleDigit function can be used to throw an exception if the argument can not be validated. The is_SingleDigit function can be used to return true or false if the argument can not be validated.

spaceobj

# SpaceObj

The SpaceObj type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Space object. The assert_SpaceObj function can be used to throw an exception if the argument can not be validated. The is_SpaceObj function can be used to return true or false if the argument can not be validated.

spaceobject

# SpaceObject

The SpaceObject type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Space object. The assert_SpaceObject function can be used to throw an exception if the argument can not be validated. The is_SpaceObject function can be used to return true or false if the argument can not be validated.

stashable

# Stashable

The Stashable type constraint is provided by this library and accepts any object that is a consumer of the Data::Object::Role::Stashable role. The assert_Stashable function can be used to throw an exception if the argument can not be validated. The is_Stashable function can be used to return true or false if the argument can not be validated.

stateobj

# StateObj

The StateObj type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::State object. The assert_StateObj function can be used to throw an exception if the argument can not be validated. The is_StateObj function can be used to return true or false if the argument can not be validated.

stateobject

# StateObject

The StateObject type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::State object. The assert_StateObject function can be used to throw an exception if the argument can not be validated. The is_StateObject function can be used to return true or false if the argument can not be validated.

str

# Str

The Str type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_Str function can be used to throw an exception if the argument can not be validated. The is_Str function can be used to return true or false if the argument can not be validated.

strmatch

# StrMatch[qr/^[A-Z]+$/]

The StrMatch type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_StrMatch function can be used to throw an exception if the argument can not be validated. The is_StrMatch function can be used to return true or false if the argument can not be validated.

strobj

# StrObj

The StrObj type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::String object. The assert_StrObj function can be used to throw an exception if the argument can not be validated. The is_StrObj function can be used to return true or false if the argument can not be validated.

strobject

# StrObject

The StrObject type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::String object. The assert_StrObject function can be used to throw an exception if the argument can not be validated. The is_StrObject function can be used to return true or false if the argument can not be validated.

strictnum

# StrictNum

The StrictNum type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_StrictNum function can be used to throw an exception if the argument can not be validated. The is_StrictNum function can be used to return true or false if the argument can not be validated.

stringlike

# StringLike

The StringLike type constraint is provided by the Types::TypeTiny library. Please see that documentation for more information. The assert_StringLike function can be used to throw an exception if the argument can not be validated. The is_StringLike function can be used to return true or false if the argument can not be validated.

stringobj

# StringObj

The StringObj type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::String object. The assert_StringObj function can be used to throw an exception if the argument can not be validated. The is_StringObj function can be used to return true or false if the argument can not be validated.

stringobject

# StringObject

The StringObject type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::String object. The assert_StringObject function can be used to throw an exception if the argument can not be validated. The is_StringObject function can be used to return true or false if the argument can not be validated.

strongpassword

# StrongPassword

The StrongPassword type constraint is provided by the Types::Common::String library. Please see that documentation for more information. The assert_StrongPassword function can be used to throw an exception if the argument can not be validated. The is_StrongPassword function can be used to return true or false if the argument can not be validated.

structobj

# StructObj

The StructObj type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Struct object. The assert_StructObj function can be used to throw an exception if the argument can not be validated. The is_StructObj function can be used to return true or false if the argument can not be validated.

structobject

# StructObject

The StructObject type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Struct object. The assert_StructObject function can be used to throw an exception if the argument can not be validated. The is_StructObject function can be used to return true or false if the argument can not be validated.

throwable

# Throwable

The Throwable type constraint is provided by this library and accepts any object that is a consumer of the Data::Object::Role::Throwable role. The assert_Throwable function can be used to throw an exception if the argument can not be validated. The is_Throwable function can be used to return true or false if the argument can not be validated.

tied

# Tied["MyClass"]

The Tied type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_Tied function can be used to throw an exception if the argument can not be validated. The is_Tied function can be used to return true or false if the argument can not be validated.

tuple

# Tuple[Int, Str, Str]

The Tuple type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_Tuple function can be used to throw an exception if the argument can not be validated. The is_Tuple function can be used to return true or false if the argument can not be validated.

typetiny

# TypeTiny

The TypeTiny type constraint is provided by the Types::TypeTiny library. Please see that documentation for more information. The assert_TypeTiny function can be used to throw an exception if the argument can not be validated. The is_TypeTiny function can be used to return true or false if the argument can not be validated.

undef

# Undef

The Undef type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_Undef function can be used to throw an exception if the argument can not be validated. The is_Undef function can be used to return true or false if the argument can not be validated.

undefobj

# UndefObj

The UndefObj type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Undef object. The assert_UndefObj function can be used to throw an exception if the argument can not be validated. The is_UndefObj function can be used to return true or false if the argument can not be validated.

undefobject

# UndefObject

The UndefObject type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Undef object. The assert_UndefObject function can be used to throw an exception if the argument can not be validated. The is_UndefObject function can be used to return true or false if the argument can not be validated.

uppercasesimplestr

# UpperCaseSimpleStr

The UpperCaseSimpleStr type constraint is provided by the Types::Common::String library. Please see that documentation for more The assert_UpperCaseSimpleStr function can be used to throw an exception if the argument can not be validated. The is_UpperCaseSimpleStr function can be used to return true or false if the argument can not be validated. information.

uppercasestr

# UpperCaseStr

The UpperCaseStr type constraint is provided by the Types::Common::String library. Please see that documentation for more information. The assert_UpperCaseStr function can be used to throw an exception if the argument can not be validated. The is_UpperCaseStr function can be used to return true or false if the argument can not be validated.

value

# Value

The Value type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_Value function can be used to throw an exception if the argument can not be validated. The is_Value function can be used to return true or false if the argument can not be validated.

varsobj

# VarsObj

The VarsObj type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Vars object. The assert_VarsObj function can be used to throw an exception if the argument can not be validated. The is_VarsObj function can be used to return true or false if the argument can not be validated.

varsobject

# VarsObject

The VarsObject type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Vars object. The assert_VarsObject function can be used to throw an exception if the argument can not be validated. The is_VarsObject function can be used to return true or false if the argument can not be validated.

CREDITS

Al Newkirk, +296

Anthony Brummett, +10

José Joaquín Atria, +1

AUTHOR

Al Newkirk, awncorp@cpan.org

LICENSE

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

PROJECT

	Global
`s`	Focus search bar
`?`	Bring up this help dialog

	GitHub
`g` `p`	Go to pull requests
`g` `i`	go to github issues (only if github is preferred repository)

	POD
`g` `a`	Go to author
`g` `c`	Go to changes
`g` `i`	Go to issues
`g` `d`	Go to dist
`g` `r`	Go to repository/SCM
`g` `s`	Go to source
`g` `b`	Go to file browse

	Search terms
module: (e.g. module:Plugin)
distribution: (e.g. distribution:Dancer auth)
author: (e.g. author:SONGMU Redis)
version: (e.g. version:1.00)