Data::Object::Library

Data-Object Type Library

use Data::Object::Library;

Type::Library Types::Standard Types::Common::String Types::Common::Numeric

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

+=head1 CONSTRAINTS

This package provides the following type constraints.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

+=head2 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.

cpanm Do

perl -MCPAN -e shell
install Do