The London Perl and Raku Workshop takes place on 26th Oct 2024. If your company depends on Perl, please consider sponsoring and/or attending.

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

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.

84 POD Errors

The following errors were encountered while parsing the POD:

Around line 469:

Unknown directive: =type

Around line 482:

Unknown directive: =type

Around line 495:

Unknown directive: =type

Around line 508:

Unknown directive: =type

Around line 521:

Unknown directive: =type

Around line 534:

Unknown directive: =type

Around line 547:

Unknown directive: =type

Around line 560:

Unknown directive: =type

Around line 573:

Unknown directive: =type

Around line 586:

Unknown directive: =type

Around line 599:

Unknown directive: =type

Around line 612:

Unknown directive: =type

Around line 625:

Unknown directive: =type

Around line 638:

Unknown directive: =type

Around line 651:

Unknown directive: =type

Around line 664:

Unknown directive: =type

Around line 677:

Unknown directive: =type

Around line 690:

Unknown directive: =type

Around line 703:

Unknown directive: =type

Around line 716:

Unknown directive: =type

Around line 729:

Unknown directive: =type

Around line 742:

Unknown directive: =type

Around line 755:

Unknown directive: =type

Around line 768:

Unknown directive: =type

Around line 781:

Unknown directive: =type

Around line 794:

Unknown directive: =type

Around line 807:

Unknown directive: =type

Around line 820:

Unknown directive: =type

Around line 833:

Unknown directive: =type

Around line 846:

Unknown directive: =type

Around line 859:

Unknown directive: =type

Around line 872:

Unknown directive: =type

Around line 886:

Unknown directive: =type

Around line 899:

Unknown directive: =type

Around line 912:

Unknown directive: =type

Around line 925:

Unknown directive: =type

Around line 938:

Unknown directive: =type

Around line 951:

Unknown directive: =type

Around line 965:

Unknown directive: =type

Around line 979:

Unknown directive: =type

Around line 993:

Unknown directive: =type

Around line 1006:

Unknown directive: =type

Around line 1019:

Unknown directive: =type

Around line 1032:

Unknown directive: =type

Around line 1045:

Unknown directive: =type

Around line 1058:

Unknown directive: =type

Around line 1071:

Unknown directive: =type

Around line 1084:

Unknown directive: =type

Around line 1097:

Unknown directive: =type

Around line 1110:

Unknown directive: =type

Around line 1123:

Unknown directive: =type

Around line 1136:

Unknown directive: =type

Around line 1149:

Unknown directive: =type

Around line 1162:

Unknown directive: =type

Around line 1175:

Unknown directive: =type

Around line 1189:

Unknown directive: =type

Around line 1203:

Unknown directive: =type

Around line 1216:

Unknown directive: =type

Around line 1229:

Unknown directive: =type

Around line 1242:

Unknown directive: =type

Around line 1255:

Unknown directive: =type

Around line 1268:

Unknown directive: =type

Around line 1281:

Unknown directive: =type

Around line 1294:

Unknown directive: =type

Around line 1307:

Unknown directive: =type

Around line 1320:

Unknown directive: =type

Around line 1333:

Unknown directive: =type

Around line 1346:

Unknown directive: =type

Around line 1359:

Unknown directive: =type

Around line 1372:

Unknown directive: =type

Around line 1385:

Unknown directive: =type

Around line 1398:

Unknown directive: =type

Around line 1411:

Unknown directive: =type

Around line 1424:

Unknown directive: =type

Around line 1437:

Unknown directive: =type

Around line 1450:

Unknown directive: =type

Around line 1463:

Unknown directive: =type

Around line 1476:

Unknown directive: =type

Around line 1489:

Unknown directive: =type

Around line 1502:

Unknown directive: =type

Around line 1515:

Unknown directive: =type

Around line 1528:

Unknown directive: =type

Around line 1542:

Unknown directive: =type

Around line 1555:

Unknown directive: =type