---
name: "Declare::Constraints::Simple::Library::Operators"
section: "3pm"
platform: "linux"
package: "libdeclare-constraints-simple-perl"
version: "0.03-1.1"
release: "Debian 13 (Trixie)"
platforms: ["linux"]
url: "https://new.carta.tech/Declare::Constraints::Simple::Library::Operators"
---

# Declare::Constraints::Simple::Library::Operators(3pm)

Operators

## 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.