NAME

       Declare::Constraints::Simple::Library::Operators - Operators

SYNOPSIS

         # all hast to be valid
         my $and_constraint = And( IsInt,
                                   Matches(qr/0$/) );

         # at least one has to be valid
         my $or_constraint = Or( IsInt, HasLength );

         # only one can be valid
         my $xor_constraint = XOr( IsClass, IsObject );

         # reverse validity
         my $not_an_integer = Not( IsInt );

         # case valid, validate 'bar' key depending on 'foo' keys value
         my $struct_prof =
           And( IsHashRef,
                CaseValid( OnHashKeys(foo => IsEq("FooArray")),
                             OnHashKeys(bar => IsArrayRef),
                           OnHashKeys(foo => IsEq("FooHash")),
                             OnHashKeys(bar => IsHashRef) ));

DESCRIPTION

       This module contains the frameworks operators. These constraint like elements act on the validity of
       passed constraints.

OPERATORS

   And(@constraints)
       Is true if all passed @constraints are true on the value. Returns the result of the first failing
       constraint.

   Or(@constraints)
       Is true if at least one of the passed @contraints is true. Returns the last failing constraint's result
       if false.

   XOr(@constraints)
       Valid only if a single one of the passed @constraints is valid. Returns the last failing constraint's
       result if false.

   Not($constraint)
       This is valid if the passed $constraint is false. The main purpose of this operator is to allow the easy
       reversion of a constraint's trueness.

   CaseValid($test, $conseq, $test2, $conseq2, ...)
       This runs every given $test argument on the value, until it finds one that returns true. If none is
       found, false is returned. On a true result, however, the corresponding $conseq constraint is applied to
       the value and it's result returned. This allows validation depending on other properties of the value:

         my $flexible = CaseValid( IsArrayRef,
                                     And( HasArraySize(1,5),
                                          OnArrayElements(0 => IsInt) ),
                                   IsHashRef,
                                     And( HasHashElements(qw( head tail )),
                                          OnHashKeys(head => IsInt) ));

       Of course, you could model most of it probably with the other operators, but this is a bit more readable.
       For default cases use "ReturnTrue" from Declare::Constraints::Simple::Library::General as test.

SEE ALSO

       Declare::Constraints::Simple, Declare::Constraints::Simple::Library

AUTHOR

       Robert 'phaylon' Sedlacek "<phaylon@dunkelheit.at>"

LICENSE AND COPYRIGHT

       This module is free software, you can redistribute it and/or modify it under the same terms as perl
       itself.

perl v5.32.0                                       2021-01-Declare::Constraints::Simple::Library::Operators(3pm)