• NAME
• ABSTRACT
• SYNOPSIS
• DESCRIPTION
• INHERITANCE
• FUNCTIONS
  • doargs
  • doarray
  • doboolean
  • docli
  • docode
  • dodata
  • dodumpable
  • doexception
  • dofloat
  • dofunc
  • dohash
  • doimmutable
  • donumber
  • doopts
  • doregexp
  • doreplace
  • doscalar
  • dosearch
  • dospace
  • dostashable
  • dostate
  • dostring
  • dostruct
  • dothrowable
  • doundef
  • dovars
  • generatecoercion
  • generateconstraint
  • generateexplanation
  • library
  • options
  • register
  • registerall
• CONSTRAINTS
  • any
  • arraylike
  • argsobj
  • argsobject
  • arrayobj
  • arrayobject
  • arrayref
  • bool
  • boolobj
  • boolobject
  • booleanobj
  • booleanobject
  • classname
  • codelike
  • cliobj
  • cliobject
  • codeobj
  • codeobject
  • coderef
  • consumerof
  • dataobj
  • dataobject
  • defined
  • dict
  • dumpable
  • enum
  • exceptionobj
  • exceptionobject
  • filehandle
  • floatobj
  • floatobject
  • funcobj
  • funcobject
  • globref
  • hasmethods
  • hashlike
  • hashobj
  • hashobject
  • hashref
  • immutable
  • instanceof
  • int
  • intobj
  • intobject
  • intrange
  • integerobj
  • integerobject
  • item
  • laxnum
  • lowercasesimplestr
  • lowercasestr
  • map
  • maybe
  • negativeint
  • negativenum
  • negativeorzeroint
  • negativeorzeronum
  • nonemptysimplestr
  • nonemptystr
  • num
  • numberlike
  • numobj
  • numobject
  • numrange
  • numberobject
  • numericcode
  • object
  • optsobj
  • optsobject
  • optlist
  • optional
  • overload
  • password
  • positiveint
  • positivenum
  • positiveorzeroint
  • positiveorzeronum
  • ref
  • regexpobj
  • regexpobject
  • regexpref
  • replaceobj
  • replaceobject
  • rolename
  • scalarobj
  • scalarobject
  • scalarref
  • searchobj
  • searchobject
  • simplestr
  • singledigit
  • spaceobj
  • spaceobject
  • stashable
  • stateobj
  • stateobject
  • str
  • strmatch
  • strobj
  • strobject
  • strictnum
  • stringlike
  • stringobj
  • stringobject
  • strongpassword
  • structobj
  • structobject
  • throwable
  • tied
  • tuple
  • typetiny
  • undef
  • undefobj
  • undefobject
  • uppercasesimplestr
  • uppercasestr
  • value
  • varsobj
  • varsobject
• CREDITS
• AUTHOR
• LICENSE
• PROJECT
• SEE ALSO

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();

doboolean

  DoBoolean() : HashRef

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

DoBoolean example

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

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.

boolobj

  # BoolObj

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

boolobject

  # BoolObject

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

booleanobj

  # BooleanObj

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

booleanobject

  # BooleanObject

The BooleanObject type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Boolean object. The assert_BooleanObject function can be used to throw an exception if the argument can not be validated. The is_BooleanObject 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, +319

Anthony Brummett, +10

Adam Hopkins, +2

José Joaquín Atria, +1

AUTHOR

Al Newkirk, awncorp@cpan.org

LICENSE

Copyright (C) 2011-2019, Al Newkirk, et al.

This is free software; you can redistribute it and/or modify it under the terms of the The Apache License, Version 2.0, as elucidated here, https://github.com/iamalnewkirk/do/blob/master/LICENSE.

PROJECT

Wiki

Project

Initiatives

Milestones

Contributing

Issues

SEE ALSO

To get the most out of this distribution, consider reading the following:

Do

Data::Object

Data::Object::Class

Data::Object::ClassHas

Data::Object::Role

Data::Object::RoleHas

Data::Object::Library