object

# `validated`

Types and predicates for type-checking and handling lists of validation terms. Inspired by Scala Cats and Kotlin Arrow.

Availability:
`logtalk_load(validations(loader))`
Author: Paulo Moura
Version: 1:0:0
Date: 2026-02-22
Compilation flags:
`static, context_switching_calls`
Provides:
type::type/1
type::check/2
arbitrary::arbitrary/1
arbitrary::arbitrary/2
arbitrary::shrinker/1
arbitrary::shrink/3
arbitrary::edge_case/2
Uses:
list
random
type
Remarks:

> - Type-checking support: Defines a `validated(ValueType, ErrorType)` type for checking validation terms where the value and error terms must be of the given types.

> - QuickCheck support: Defines clauses for the `type::arbitrary/1-2`, `arbitrary::shrinker/1`, `arbitrary::shrink/3`, and `arbitrary::edge_case/2` predicates to allow generating random values for the `validated(ValueType, ErrorType)` type.

Inherited public predicates:
(none)

## Public predicates

### `valids/2`

Returns the values stored in validation terms that hold valid values.

Compilation flags:
`static`
Template:
`valids(Validations,Values)`
Mode and number of proofs:
`valids(+list(validation),-list)` - `one`

### `invalids/2`

Returns a flattened list with all errors stored in invalid validation terms.

Compilation flags:
`static`
Template:
`invalids(Validations,Errors)`
Mode and number of proofs:
`invalids(+list(validation),-list)` - `one`

### `partition/3`

Retrieves and partitions valid values and flattened accumulated errors from validation terms.

Compilation flags:
`static`
Template:
`partition(Validations,Values,Errors)`
Mode and number of proofs:
`partition(+list(validation),-list,-list)` - `one`

### `map/3`

Applies a closure to each list element to generate validation terms and returns a pair `Values-Errors` accumulating all valid values and all errors in one pass.

Compilation flags:
`static`
Template:
`map(Closure,Terms,ValuesErrors)`
Meta-predicate template:
`map(2,*,*)`
Mode and number of proofs:
`map(+callable,+list,--compound)` - `one`

### `map/4`

Applies a closure to each list element to generate validation terms and returns valid values and accumulated errors in one pass.

Compilation flags:
`static`
Template:
`map(Closure,Terms,Values,Errors)`
Meta-predicate template:
`map(2,*,*,*)`
Mode and number of proofs:
`map(+callable,+list,-list,-list)` - `one`

### `sequence/2`

Sequences a list of validation terms into a single validation term, accumulating all errors.

Compilation flags:
`static`
Template:
`sequence(Validations,Validation)`
Mode and number of proofs:
`sequence(+list(validation),--nonvar)` - `one`

### `traverse/3`

Applies a closure to each list element to generate validation terms and then sequences them, accumulating all errors.

Compilation flags:
`static`
Template:
`traverse(Closure,Terms,Validation)`
Meta-predicate template:
`traverse(2,*,*)`
Mode and number of proofs:
`traverse(+callable,+list,--nonvar)` - `one`

## Protected predicates

(no local declarations; see entity ancestors if any)

## Private predicates

(no local declarations; see entity ancestors if any)

## Operators

(none)

See also

validation, validation(Validation), type, arbitrary