NAME

Data::Object::Library - Type Library for Perl 5

VERSION

version 0.61

SYNOPSIS

use Data::Object::Library;

DESCRIPTION

Data::Object::Library is a Type::Tiny type library that extends the Types::Standard, Types::Common::Numeric, and Types::Common::String libraries and adds type constraints and coercions for Data::Object objects.

has data => (
  is  => 'rw',
  isa => 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.

has data => (
  is  => 'rw',
  isa => AnyObj,
);

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

has data => (
  is  => 'rw',
  isa => AnyObject,
);

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

has data => (
  is  => 'rw',
  isa => 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.

has data => (
  is  => 'rw',
  isa => 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.

has data => (
  is  => 'rw',
  isa => 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.

has data => (
  is  => 'rw',
  isa => 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.

has data => (
  is  => 'rw',
  isa => 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.

has data => (
  is  => 'rw',
  isa => 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.

has data => (
  is  => 'rw',
  isa => 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.

has data => (
  is  => 'rw',
  isa => 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.

has data => (
  is  => 'rw',
  isa => 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.

has data => (
  is  => 'rw',
  isa => 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.

has data => (
  is  => 'rw',
  isa => 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.

has data => (
  is  => 'rw',
  isa => Enum,
);

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.

has data => (
  is  => 'rw',
  isa => 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.

has data => (
  is  => 'rw',
  isa => 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.

has data => (
  is  => 'rw',
  isa => 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.

has data => (
  is  => 'rw',
  isa => 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.

has data => (
  is  => 'rw',
  isa => HasMethods[...],
);

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.

has data => (
  is  => 'rw',
  isa => 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.

has data => (
  is  => 'rw',
  isa => 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.

has data => (
  is  => 'rw',
  isa => 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.

has data => (
  is  => 'rw',
  isa => 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.

has data => (
  is  => 'rw',
  isa => 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.

has data => (
  is  => 'rw',
  isa => 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.

has data => (
  is  => 'rw',
  isa => 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.

has data => (
  is  => 'rw',
  isa => 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.

has data => (
  is  => 'rw',
  isa => 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.

has data => (
  is  => 'rw',
  isa => 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.

has data => (
  is  => 'rw',
  isa => 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.

has data => (
  is  => 'rw',
  isa => 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.

has data => (
  is  => 'rw',
  isa => 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.

has data => (
  is  => 'rw',
  isa => 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.

has data => (
  is  => 'rw',
  isa => Maybe,
);

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.

has data => (
  is  => 'rw',
  isa => 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.

has data => (
  is  => 'rw',
  isa => 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.

has data => (
  is  => 'rw',
  isa => 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.

has data => (
  is  => 'rw',
  isa => 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.

has data => (
  is  => 'rw',
  isa => 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.

has data => (
  is  => 'rw',
  isa => 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.

has data => (
  is  => 'rw',
  isa => 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.

has data => (
  is  => 'rw',
  isa => 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.

has data => (
  is  => 'rw',
  isa => 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.

has data => (
  is  => 'rw',
  isa => NumberObj,
);

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

has data => (
  is  => 'rw',
  isa => 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.

has data => (
  is  => 'rw',
  isa => 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.

has data => (
  is  => 'rw',
  isa => 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.

has data => (
  is  => 'rw',
  isa => 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.

has data => (
  is  => 'rw',
  isa => 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.

has data => (
  is  => 'rw',
  isa => Overload,
);

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.

has data => (
  is  => 'rw',
  isa => Password,
);

The Password type constraint is provided by the Types::Standard 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.

has data => (
  is  => 'rw',
  isa => 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.

has data => (
  is  => 'rw',
  isa => 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.

has data => (
  is  => 'rw',
  isa => 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.

has data => (
  is  => 'rw',
  isa => 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.

has data => (
  is  => 'rw',
  isa => 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.

has data => (
  is  => 'rw',
  isa => 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.

has data => (
  is  => 'rw',
  isa => 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.

has data => (
  is  => 'rw',
  isa => 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.

has data => (
  is  => 'rw',
  isa => 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.

has data => (
  is  => 'rw',
  isa => 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.

has data => (
  is  => 'rw',
  isa => 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.

has data => (
  is  => 'rw',
  isa => 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.

has data => (
  is  => 'rw',
  isa => 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.

has data => (
  is  => 'rw',
  isa => 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.

has data => (
  is  => 'rw',
  isa => 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.

has data => (
  is  => 'rw',
  isa => StrMatch,
);

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.

has data => (
  is  => 'rw',
  isa => 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.

has data => (
  is  => 'rw',
  isa => 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.

has data => (
  is  => 'rw',
  isa => 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.

has data => (
  is  => 'rw',
  isa => 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.

has data => (
  is  => 'rw',
  isa => 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.

has data => (
  is  => 'rw',
  isa => 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.

has data => (
  is  => 'rw',
  isa => 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.

has data => (
  is  => 'rw',
  isa => 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.

has data => (
  is  => 'rw',
  isa => 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.

has data => (
  is  => 'rw',
  isa => 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.

has data => (
  is  => 'rw',
  isa => 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.

has data => (
  is  => 'rw',
  isa => UniversalObj,
);

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

has data => (
  is  => 'rw',
  isa => UniversalObject,
);

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

has data => (
  is  => 'rw',
  isa => 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.

has data => (
  is  => 'rw',
  isa => UpperCaseStr,
);

The UpperCaseStr 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.

has data => (
  is  => 'rw',
  isa => 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.

SEE ALSO

• Data::Object::Array

• Data::Object::Class

• Data::Object::Class::Syntax

• Data::Object::Code

• Data::Object::Float

• Data::Object::Hash

• Data::Object::Integer

• Data::Object::Number

• Data::Object::Role

• Data::Object::Role::Syntax

• Data::Object::Regexp

• Data::Object::Scalar

• Data::Object::String

• Data::Object::Undef

• Data::Object::Universal

• Data::Object::Autobox

• Data::Object::Immutable

• Data::Object::Library

• Data::Object::Prototype

• Data::Object::Signatures

AUTHOR

Al Newkirk <al@iamalnewkirk.com>

COPYRIGHT AND LICENSE

This software is copyright (c) 2018 by Al Newkirk.

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

cpanm Data::Object

perl -MCPAN -e shell
install Data::Object