io.vavr.control

Class Validation<E,T>

java.lang.Object

io.vavr.control.Validation<E,T>

Type Parameters:

E - value type in the case of invalid

T - value type in the case of valid

All Implemented Interfaces:

Value<T>, java.io.Serializable, java.lang.Iterable<T>

Direct Known Subclasses:

Validation.Invalid, Validation.Valid

public abstract class Validation<E,T>
extends java.lang.Object
implements java.lang.Iterable<T>, Value<T>, java.io.Serializable

An implementation similar to scalaz's Validation control.

The Validation type is different from a Monad type, it is an applicative functor. Whereas a Monad will short circuit after the first error, the applicative functor will continue on, accumulating ALL errors. This is especially helpful in cases such as validation, where you want to know all the validation errors that have occurred, not just the first one.

 
 Validation construction:

 Valid:
 Validation<String,Integer> valid = Validation.valid(5);

 Invalid:
 Validation<List<String>,Integer> invalid = Validation.invalid(List.of("error1","error2"));

 Validation combination:

 Validation<String,String> valid1 = Validation.valid("John");
 Validation<String,Integer> valid2 = Validation.valid(5);
 Validation<String,Option<String>> valid3 = Validation.valid(Option.of("123 Fake St."));
 Function3<String,Integer,Option<String>,Person> f = ...;

 Validation<List<String>,String> result = valid1.combine(valid2).ap((name,age) -> "Name: "+name+" Age: "+age);
 Validation<List<String>,Person> result2 = valid1.combine(valid2).combine(valid3).ap(f);

 Another form of combining validations:

 Validation<List<String>,Person> result3 = Validation.combine(valid1, valid2, valid3).ap(f);
 
 

See Also:

Validation, Serialized Form

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	Validation.Builder<E,T1,T2>
static class	Validation.Builder3<E,T1,T2,T3>
static class	Validation.Builder4<E,T1,T2,T3,T4>
static class	Validation.Builder5<E,T1,T2,T3,T4,T5>
static class	Validation.Builder6<E,T1,T2,T3,T4,T5,T6>
static class	Validation.Builder7<E,T1,T2,T3,T4,T5,T6,T7>
static class	Validation.Builder8<E,T1,T2,T3,T4,T5,T6,T7,T8>
static class	Validation.Invalid<E,T> Deprecated. will be removed from the public API
static class	Validation.Valid<E,T> Deprecated. will be removed from the public API

Method Summary

Modifier and Type	Method and Description
<U> Validation<Seq<E>,U>	ap(Validation<Seq<E>,? extends java.util.function.Function<? super T,? extends U>> validation)
<E2,T2> Validation<E2,T2>	bimap(java.util.function.Function<? super E,? extends E2> errorMapper, java.util.function.Function<? super T,? extends T2> valueMapper) Whereas map only performs a mapping on a valid Validation, and mapError performs a mapping on an invalid Validation, bimap allows you to provide mapping actions for both, and will give you the result based on what type of Validation this is.
static <E,T1,T2> Validation.Builder<E,T1,T2>	combine(Validation<E,T1> validation1, Validation<E,T2> validation2) Combines two Validations into a Validation.Builder.
static <E,T1,T2,T3> Validation.Builder3<E,T1,T2,T3>	combine(Validation<E,T1> validation1, Validation<E,T2> validation2, Validation<E,T3> validation3) Combines three Validations into a Validation.Builder3.
static <E,T1,T2,T3,T4> Validation.Builder4<E,T1,T2,T3,T4>	combine(Validation<E,T1> validation1, Validation<E,T2> validation2, Validation<E,T3> validation3, Validation<E,T4> validation4) Combines four Validations into a Validation.Builder4.
static <E,T1,T2,T3,T4,T5> Validation.Builder5<E,T1,T2,T3,T4,T5>	combine(Validation<E,T1> validation1, Validation<E,T2> validation2, Validation<E,T3> validation3, Validation<E,T4> validation4, Validation<E,T5> validation5) Combines five Validations into a Validation.Builder5.
static <E,T1,T2,T3,T4,T5,T6> Validation.Builder6<E,T1,T2,T3,T4,T5,T6>	combine(Validation<E,T1> validation1, Validation<E,T2> validation2, Validation<E,T3> validation3, Validation<E,T4> validation4, Validation<E,T5> validation5, Validation<E,T6> validation6) Combines six Validations into a Validation.Builder6.
static <E,T1,T2,T3,T4,T5,T6,T7> Validation.Builder7<E,T1,T2,T3,T4,T5,T6,T7>	combine(Validation<E,T1> validation1, Validation<E,T2> validation2, Validation<E,T3> validation3, Validation<E,T4> validation4, Validation<E,T5> validation5, Validation<E,T6> validation6, Validation<E,T7> validation7) Combines seven Validations into a Validation.Builder7.
static <E,T1,T2,T3,T4,T5,T6,T7,T8> Validation.Builder8<E,T1,T2,T3,T4,T5,T6,T7,T8>	combine(Validation<E,T1> validation1, Validation<E,T2> validation2, Validation<E,T3> validation3, Validation<E,T4> validation4, Validation<E,T5> validation5, Validation<E,T6> validation6, Validation<E,T7> validation7, Validation<E,T8> validation8) Combines eight Validations into a Validation.Builder8.
<U> Validation.Builder<E,T,U>	combine(Validation<E,U> validation) Combines two Validations to form a Validation.Builder, which can then be used to perform further combines, or apply a function to it in order to transform the Validation.Builder into a Validation.
Option<Validation<E,T>>	filter(java.util.function.Predicate<? super T> predicate)
<U> Validation<E,U>	flatMap(java.util.function.Function<? super T,? extends Validation<E,? extends U>> mapper)
<U> U	fold(java.util.function.Function<? super E,? extends U> ifInvalid, java.util.function.Function<? super T,? extends U> ifValid) Transforms this Validation to a value of type U.
void	forEach(java.util.function.Consumer<? super T> action) Performs the given action for the value contained in Valid, or does nothing if this is an Invalid.
static <E,T> Validation<E,T>	fromEither(Either<E,T> either) Creates a Validation of an Either.
static <T> Validation<java.lang.Throwable,T>	fromTry(Try<? extends T> t) Creates a Validation of an Try.
abstract T	get() Gets the value of this Validation if is a Valid or throws if this is an Invalid.
abstract E	getError() Gets the error of this Validation if it is an Invalid or throws if this is a Valid.
T	getOrElseGet(java.util.function.Function<? super E,? extends T> other) Gets the value if it is a Valid or an value calculated from the error.
static <E,T> Validation<E,T>	invalid(E error) Creates an Validation.Invalid that contains the given error.
boolean	isAsync() A Validation's value is computed synchronously.
boolean	isEmpty() Checks, this Value is empty, i.e.
abstract boolean	isInvalid() Check whether this is of type Invalid
boolean	isLazy() A Validation's value is computed eagerly.
boolean	isSingleValued() States whether this is a single-valued type.
abstract boolean	isValid() Check whether this is of type Valid
Iterator<T>	iterator() Returns a rich io.vavr.collection.Iterator.
<U> Validation<E,U>	map(java.util.function.Function<? super T,? extends U> f) Maps the underlying value to a different component type.
<U> Validation<U,T>	mapError(java.util.function.Function<? super E,? extends U> f) Applies a function f to the error of this Validation if this is an Invalid.
static <E,T> Validation<E,T>	narrow(Validation<? extends E,? extends T> validation) Narrows a widened Validation<? extends E, ? extends T> to Validation<E, T> by performing a type-safe cast.
Validation<E,T>	orElse(java.util.function.Supplier<Validation<? extends E,? extends T>> supplier) Returns this Validation if it is valid, otherwise return the result of evaluating supplier.
Validation<E,T>	orElse(Validation<? extends E,? extends T> other) Returns this Validation if it is valid, otherwise return the alternative.
Validation<E,T>	peek(java.util.function.Consumer<? super E> invalidAction, java.util.function.Consumer<? super T> validAction) Applies the validAction to the value if this is valid otherwise applies the invalidAction to the cause of error.
Validation<E,T>	peek(java.util.function.Consumer<? super T> action) Performs the given action on the first element if this is an eager implementation.
Validation<E,T>	peekError(java.util.function.Consumer<? super E> action)
static <E,T> Validation<Seq<E>,Seq<T>>	sequence(java.lang.Iterable<? extends Validation<? extends Seq<? extends E>,? extends T>> values) Reduces many Validation instances into a single Validation by transforming an Iterable<Validation<? extends T>> into a Validation<Seq<T>>.
Validation<T,E>	swap() Flip the valid/invalid values for this Validation.
Either<E,T>	toEither() Converts this Validation to an Either.
<U> U	transform(java.util.function.Function<? super Validation<E,T>,? extends U> f) Transforms this Validation.
static <E,T,U> Validation<Seq<E>,Seq<U>>	traverse(java.lang.Iterable<? extends T> values, java.util.function.Function<? super T,? extends Validation<? extends Seq<? extends E>,? extends U>> mapper) Maps the values of an iterable to a sequence of mapped values into a single Validation by transforming an Iterable<? extends T> into a Validation<Seq<U>>.
static <E,T> Validation<E,T>	valid(T value) Creates a Validation.Valid that contains the given value.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface io.vavr.Value

collect, collect, contains, corresponds, eq, equals, exists, forAll, getOrElse, getOrElse, getOrElseThrow, getOrElseTry, getOrNull, hashCode, narrow, out, out, spliterator, stderr, stdout, stringPrefix, toArray, toCharSeq, toCompletableFuture, toEither, toEither, toInvalid, toInvalid, toJavaArray, toJavaArray, toJavaArray, toJavaCollection, toJavaList, toJavaList, toJavaMap, toJavaMap, toJavaMap, toJavaOptional, toJavaParallelStream, toJavaSet, toJavaSet, toJavaStream, toLeft, toLeft, toLinkedMap, toLinkedMap, toLinkedSet, toList, toMap, toMap, toOption, toPriorityQueue, toPriorityQueue, toQueue, toRight, toRight, toSet, toSortedMap, toSortedMap, toSortedMap, toSortedMap, toSortedSet, toSortedSet, toStream, toString, toTree, toTree, toTry, toTry, toValid, toValid, toValidation, toValidation, toVector

Method Detail

valid

public static <E,T> Validation<E,T> valid(T value)

Creates a Validation.Valid that contains the given value.

Type Parameters:

E - type of the error

T - type of the given value

Parameters:

value - A value

Returns:

Valid(value)

invalid

public static <E,T> Validation<E,T> invalid(E error)

Creates an Validation.Invalid that contains the given error.

Type Parameters:

E - type of the given error

T - type of the value

Parameters:

error - An error

Returns:

Invalid(error)

Throws:

java.lang.NullPointerException - if error is null

fromEither

public static <E,T> Validation<E,T> fromEither(Either<E,T> either)

Creates a Validation of an Either.

 // validates the either type if either is right then validation
 // contains right value otherwise throws NoSuchElementException
 // Creates Validation instance with the value "vavr"
 Validation<?, String> validation = Validation.fromEither(Either.right("vavr"));
 // throws NoSuchElementException
 Validation<String, ?> validation = Validation.fromEither(Either.left("vavr"));
 

Type Parameters:

E - error type

T - value type

Parameters:

either - An Either

Returns:

A Valid(either.get()) if either is a Right, otherwise Invalid(either.getLeft()).

Throws:

java.lang.NullPointerException - if either is null

fromTry

public static <T> Validation<java.lang.Throwable,T> fromTry(Try<? extends T> t)

Creates a Validation of an Try.

 // validates the Try types if Try is success then validation will contain the
 // success value otherwise throws NoSuchElementException.
 // Creates Validation instance with the value "vavr"
 Validation<? super Exception, ?> validation = Validation.fromTry(Try.success("vavr"));
 // throws NoSuchElementException
 Validation<? super Exception, ?> validation = Validation.fromTry(Try.failure(new Throwable("Bad")));
 

Type Parameters:

T - type of the valid value

Parameters:

t - A Try

Returns:

A Valid(t.get()) if t is a Success, otherwise Invalid(t.getCause()).

Throws:

java.lang.NullPointerException - if t is null

sequence

public static <E,T> Validation<Seq<E>,Seq<T>> sequence(java.lang.Iterable<? extends Validation<? extends Seq<? extends E>,? extends T>> values)

Reduces many Validation instances into a single Validation by transforming an Iterable<Validation<? extends T>> into a Validation<Seq<T>>.

 // creates a sequence of validation from list of validations or throws NullPointerException
 // when validations are null.
 // following code results in sequence of List.of(1, 2))
 Validation.sequence(List.of(Validation.valid(1), Validation.valid(2)));
 // throws NullPointerException
 Validation.sequence(null);
 

Type Parameters:

E - value type in the case of invalid

T - value type in the case of valid

Parameters:

values - An iterable of Validation instances.

Returns:

A valid Validation of a sequence of values if all Validation instances are valid or an invalid Validation containing an accumulated List of errors.

Throws:

java.lang.NullPointerException - if values is null

transform

public final <U> U transform(java.util.function.Function<? super Validation<E,T>,? extends U> f)

Transforms this Validation.

Type Parameters:

U - Type of transformation result

Parameters:

f - A transformation

Returns:

An instance of type U

Throws:

java.lang.NullPointerException - if f is null

traverse

public static <E,T,U> Validation<Seq<E>,Seq<U>> traverse(java.lang.Iterable<? extends T> values,
                                                         java.util.function.Function<? super T,? extends Validation<? extends Seq<? extends E>,? extends U>> mapper)

Maps the values of an iterable to a sequence of mapped values into a single Validation by transforming an Iterable<? extends T> into a Validation<Seq<U>>.

 // following code transforms each element into a sequence of validation. Validation.valid(List.of(1, 2));
 Validation<?, ?> validation = Validation.traverse(List.of(1, 2), t -> Validation.valid(t));
 // throws NullPointerException when values and mapper are null
 Validation.traverse(null, null);
 

Type Parameters:

T - The type of the given values.

E - The mapped error value type.

U - The mapped valid value type.

Parameters:

values - An Iterable of values.

mapper - A mapper of values to Validations

Returns:

A Validation of a Seq of results.

Throws:

java.lang.NullPointerException - if values or f is null.

narrow

public static <E,T> Validation<E,T> narrow(Validation<? extends E,? extends T> validation)

Narrows a widened Validation<? extends E, ? extends T> to Validation<E, T> by performing a type-safe cast. This is eligible because immutable/read-only collections are covariant.

 // following code narrows Validation<String, Integer> to Validation<CharSequence, Number>
 Validation<String, Integer> validation = Validation.valid(42);
 // following code throws an error with the error message "vavr"
 Validation<String, Integer> validation = Validation.invalid("vavr");
 

Type Parameters:

E - type of error

T - type of valid value

Parameters:

validation - A Validation.

Returns:

the given validation instance as narrowed type Validation<E, T>.

combine

public static <E,T1,T2> Validation.Builder<E,T1,T2> combine(Validation<E,T1> validation1,
                                                            Validation<E,T2> validation2)

Combines two Validations into a Validation.Builder.

 // following code joins two validations into one which result in Validation.Builder2
 Validation<? super Exception, ?> validation1 = Validation.valid("vavr1");
 Validation<? super Exception, ?> validation2 = Validation.valid("vavr2");
 validation1.combine(validation2);
 // throws NullPointerException if one of the validation is null.
 

Type Parameters:

E - type of error

T1 - type of first valid value

T2 - type of second valid value

Parameters:

validation1 - first validation

validation2 - second validation

Returns:

an instance of Builder<E,T1,T2>

Throws:

java.lang.NullPointerException - if validation1 or validation2 is null

combine

public static <E,T1,T2,T3> Validation.Builder3<E,T1,T2,T3> combine(Validation<E,T1> validation1,
                                                                   Validation<E,T2> validation2,
                                                                   Validation<E,T3> validation3)

Combines three Validations into a Validation.Builder3.

 // following code joins three validations into one which result in Validation.Builder3
 Validation<? super Exception, ?> validation1 = Validation.valid("vavr1");
 Validation<? super Exception, ?> validation2 = Validation.valid("vavr2");
 Validation<? super Exception, ?> validation3 = Validation.valid("vavr3");
 validation1.combine(validation2, validation3);
 // throws NullPointerException if one of the validation is null.
 

Type Parameters:

E - type of error

T1 - type of first valid value

T2 - type of second valid value

T3 - type of third valid value

Parameters:

validation1 - first validation

validation2 - second validation

validation3 - third validation

Returns:

an instance of Builder3<E,T1,T2,T3>

Throws:

java.lang.NullPointerException - if validation1, validation2 or validation3 is null

combine

public static <E,T1,T2,T3,T4> Validation.Builder4<E,T1,T2,T3,T4> combine(Validation<E,T1> validation1,
                                                                         Validation<E,T2> validation2,
                                                                         Validation<E,T3> validation3,
                                                                         Validation<E,T4> validation4)

Combines four Validations into a Validation.Builder4.

 // following code joins four validations into one which result in Validation.Builder4
 Validation<? super Exception, ?> validation1 = Validation.valid("vavr1");
 Validation<? super Exception, ?> validation2 = Validation.valid("vavr2");
 Validation<? super Exception, ?> validation3 = Validation.valid("vavr3");
 Validation<? super Exception, ?> validation4 = Validation.valid("vavr4");
 validation1.combine(validation2, validation3, validation4);
 // throws NullPointerException if one of the validation is null.
 

Type Parameters:

E - type of error

T1 - type of first valid value

T2 - type of second valid value

T3 - type of third valid value

T4 - type of fourth valid value

Parameters:

validation1 - first validation

validation2 - second validation

validation3 - third validation

validation4 - fourth validation

Returns:

an instance of Builder3<E,T1,T2,T3,T4>

Throws:

java.lang.NullPointerException - if validation1, validation2, validation3 or validation4 is null

combine

public static <E,T1,T2,T3,T4,T5> Validation.Builder5<E,T1,T2,T3,T4,T5> combine(Validation<E,T1> validation1,
                                                                               Validation<E,T2> validation2,
                                                                               Validation<E,T3> validation3,
                                                                               Validation<E,T4> validation4,
                                                                               Validation<E,T5> validation5)

Combines five Validations into a Validation.Builder5.

 Validation.sequence(List.of(Validation.valid(1), Validation.valid(2)))
 // following code joins five validations into one which result in Validation.Builder5
 Validation<? super Exception, ?> validation1 = Validation.valid("vavr1");
 Validation<? super Exception, ?> validation2 = Validation.valid("vavr2");
 Validation<? super Exception, ?> validation3 = Validation.valid("vavr3");
 Validation<? super Exception, ?> validation4 = Validation.valid("vavr4");
 Validation<? super Exception, ?> validation5 = Validation.valid("vavr5");
 validation1.combine(validation2, validation3, validation4, validation5);
 // throws NullPointerException if one of the validation is null.
 

Type Parameters:

E - type of error

T1 - type of first valid value

T2 - type of second valid value

T3 - type of third valid value

T4 - type of fourth valid value

T5 - type of fifth valid value

Parameters:

validation1 - first validation

validation2 - second validation

validation3 - third validation

validation4 - fourth validation

validation5 - fifth validation

Returns:

an instance of Builder3<E,T1,T2,T3,T4,T5>

Throws:

java.lang.NullPointerException - if validation1, validation2, validation3, validation4 or validation5 is null

combine

public static <E,T1,T2,T3,T4,T5,T6> Validation.Builder6<E,T1,T2,T3,T4,T5,T6> combine(Validation<E,T1> validation1,
                                                                                     Validation<E,T2> validation2,
                                                                                     Validation<E,T3> validation3,
                                                                                     Validation<E,T4> validation4,
                                                                                     Validation<E,T5> validation5,
                                                                                     Validation<E,T6> validation6)

Combines six Validations into a Validation.Builder6.

 // following code joins six validations into one which result in Validation.Builder6
 Validation<? super Exception, ?> validation1 = Validation.valid("vavr1");
 Validation<? super Exception, ?> validation2 = Validation.valid("vavr2");
 Validation<? super Exception, ?> validation3 = Validation.valid("vavr3");
 Validation<? super Exception, ?> validation4 = Validation.valid("vavr4");
 Validation<? super Exception, ?> validation5 = Validation.valid("vavr5");
 Validation<? super Exception, ?> validation6 = Validation.valid("vavr6");
 validation1.combine(validation2, validation3, validation4, validation5, validation6);
 // throws NullPointerException if one of the validation is null.
 

Type Parameters:

E - type of error

T1 - type of first valid value

T2 - type of second valid value

T3 - type of third valid value

T4 - type of fourth valid value

T5 - type of fifth valid value

T6 - type of sixth valid value

Parameters:

validation1 - first validation

validation2 - second validation

validation3 - third validation

validation4 - fourth validation

validation5 - fifth validation

validation6 - sixth validation

Returns:

an instance of Builder3<E,T1,T2,T3,T4,T5,T6>

Throws:

java.lang.NullPointerException - if validation1, validation2, validation3, validation4, validation5 or validation6 is null

combine

public static <E,T1,T2,T3,T4,T5,T6,T7> Validation.Builder7<E,T1,T2,T3,T4,T5,T6,T7> combine(Validation<E,T1> validation1,
                                                                                           Validation<E,T2> validation2,
                                                                                           Validation<E,T3> validation3,
                                                                                           Validation<E,T4> validation4,
                                                                                           Validation<E,T5> validation5,
                                                                                           Validation<E,T6> validation6,
                                                                                           Validation<E,T7> validation7)

Combines seven Validations into a Validation.Builder7.

 // following code joins seven validations into one which result in Validation.Builder7
 Validation<? super Exception, ?> validation1 = Validation.valid("vavr1");
 Validation<? super Exception, ?> validation2 = Validation.valid("vavr2");
 Validation<? super Exception, ?> validation3 = Validation.valid("vavr3");
 Validation<? super Exception, ?> validation4 = Validation.valid("vavr4");
 Validation<? super Exception, ?> validation5 = Validation.valid("vavr5");
 Validation<? super Exception, ?> validation6 = Validation.valid("vavr6");
 Validation<? super Exception, ?> validation7 = Validation.valid("vavr7");
 validation1.combine(validation2, validation3, validation4, validation5, validation6, validation7);
 // throws NullPointerException if one of the validation is null.
 

Type Parameters:

E - type of error

T1 - type of first valid value

T2 - type of second valid value

T3 - type of third valid value

T4 - type of fourth valid value

T5 - type of fifth valid value

T6 - type of sixth valid value

T7 - type of seventh valid value

Parameters:

validation1 - first validation

validation2 - second validation

validation3 - third validation

validation4 - fourth validation

validation5 - fifth validation

validation6 - sixth validation

validation7 - seventh validation

Returns:

an instance of Builder3<E,T1,T2,T3,T4,T5,T6,T7>

Throws:

java.lang.NullPointerException - if validation1, validation2, validation3, validation4, validation5, validation6 or validation7 is null

combine

public static <E,T1,T2,T3,T4,T5,T6,T7,T8> Validation.Builder8<E,T1,T2,T3,T4,T5,T6,T7,T8> combine(Validation<E,T1> validation1,
                                                                                                 Validation<E,T2> validation2,
                                                                                                 Validation<E,T3> validation3,
                                                                                                 Validation<E,T4> validation4,
                                                                                                 Validation<E,T5> validation5,
                                                                                                 Validation<E,T6> validation6,
                                                                                                 Validation<E,T7> validation7,
                                                                                                 Validation<E,T8> validation8)

Combines eight Validations into a Validation.Builder8.

 // following code joins eight validations into one which result in Validation.Builder8
 Validation<? super Exception, ?> validation1 = Validation.valid("vavr1");
 Validation<? super Exception, ?> validation2 = Validation.valid("vavr2");
 Validation<? super Exception, ?> validation3 = Validation.valid("vavr3");
 Validation<? super Exception, ?> validation4 = Validation.valid("vavr4");
 Validation<? super Exception, ?> validation5 = Validation.valid("vavr5");
 Validation<? super Exception, ?> validation6 = Validation.valid("vavr6");
 Validation<? super Exception, ?> validation7 = Validation.valid("vavr7");
 Validation<? super Exception, ?> validation8 = Validation.valid("vavr8");
 validation1.combine(validation2, validation3, validation4, validation5, validation6, validation7, validation8);
 // throws NullPointerException if one of the validation is null.
 

Type Parameters:

E - type of error

T1 - type of first valid value

T2 - type of second valid value

T3 - type of third valid value

T4 - type of fourth valid value

T5 - type of fifth valid value

T6 - type of sixth valid value

T7 - type of seventh valid value

T8 - type of eighth valid value

Parameters:

validation1 - first validation

validation2 - second validation

validation3 - third validation

validation4 - fourth validation

validation5 - fifth validation

validation6 - sixth validation

validation7 - seventh validation

validation8 - eighth validation

Returns:

an instance of Builder3<E,T1,T2,T3,T4,T5,T6,T7,T8>

Throws:

java.lang.NullPointerException - if validation1, validation2, validation3, validation4, validation5, validation6, validation7 or validation8 is null

isValid

public abstract boolean isValid()

Check whether this is of type Valid

Returns:

true if is a Valid, false if is an Invalid

isInvalid

public abstract boolean isInvalid()

Check whether this is of type Invalid

Returns:

true if is an Invalid, false if is a Valid

orElse

public final Validation<E,T> orElse(Validation<? extends E,? extends T> other)

Returns this Validation if it is valid, otherwise return the alternative.

 // following code return an alternative validation("vavr") when there is an error in first validation
 Validation<? super Exception, ?> errorInValidation = Validation.invalid(Error.class);
 Validation<? super Exception, ?> alternativeValidation = Validation.valid("vavr");
 Validation<? super Exception, ?> validation = errorInValidation.orElse(alternativeValidation);
 

Parameters:

other - An alternative Validation

Returns:

this Validation if it is valid, otherwise return the alternative.

orElse

public final Validation<E,T> orElse(java.util.function.Supplier<Validation<? extends E,? extends T>> supplier)

Returns this Validation if it is valid, otherwise return the result of evaluating supplier.

 // following code return an alternative Supplier validation("vavr") when there is an error in first validation
 Validation<? super Exception, ?> errorInValidation = Validation.invalid(Error.class);
 Validation<? super Exception, ?> validation = errorInValidation.orElse(() -> Validation.valid("vavr"));
 

Parameters:

supplier - An alternative Validation supplier

Returns:

this Validation if it is valid, otherwise return the result of evaluating supplier.

isEmpty

public final boolean isEmpty()

Description copied from interface: Value

Checks, this Value is empty, i.e. if the underlying value is absent.

Specified by:

isEmpty in interface Value<T>

Returns:

false, if no underlying value is present, true otherwise.

get

public abstract T get()

Gets the value of this Validation if is a Valid or throws if this is an Invalid.

Specified by:

get in interface Value<T>

Returns:

The value of this Validation

Throws:

java.util.NoSuchElementException - if this is an Invalid

getOrElseGet

public final T getOrElseGet(java.util.function.Function<? super E,? extends T> other)

Gets the value if it is a Valid or an value calculated from the error.

 // following code applies a function if the validation contains invalid data.
 Validation<? super Exception, ?> validation =  Validation.invalid(1);
 Function<Integer, Integer> function = number -> number + 1;
 validation.getOrElseGet(function);
 // otherwise if the validation contains valid then it returns valid data.
 

Parameters:

other - a function which converts an error to an alternative value

Returns:

the value, if the underlying Validation is a Valid, or else the alternative value provided by other by applying the error.

getError

public abstract E getError()

Gets the error of this Validation if it is an Invalid or throws if this is a Valid.

Returns:

The error, if present

Throws:

java.lang.RuntimeException - if this is a Valid

toEither

public final Either<E,T> toEither()

Converts this Validation to an Either.

 // following code converts validations of valid type to Either right type.
 Validation<? super Exception, ?> validation =  Validation.valid(1);
 Either<? super Exception, ?> either = validation.toEither();
 // otherwise if the validation contains invalid then it returns Either left type.
 

Returns:

Either.right(get()) if this is valid, otherwise Either.left(getError()).

forEach

public final void forEach(java.util.function.Consumer<? super T> action)

Performs the given action for the value contained in Valid, or does nothing if this is an Invalid.

Specified by:

forEach in interface Value<T>

Specified by:

forEach in interface java.lang.Iterable<T>

Parameters:

action - the action to be performed on the contained value

Throws:

java.lang.NullPointerException - if action is null

fold

public final <U> U fold(java.util.function.Function<? super E,? extends U> ifInvalid,
                        java.util.function.Function<? super T,? extends U> ifValid)

Transforms this Validation to a value of type U.

Example:

 Validation<List<String>, String> valid = ...;<br>
 int i = valid.fold(List::length, String::length);
 

Type Parameters:

U - the fold result type

Parameters:

ifInvalid - an error mapper

ifValid - an mapper for a valid value

Returns:

ifValid.apply(get()) if this is valid, otherwise ifInvalid.apply(getError()).

Throws:

java.lang.NullPointerException - if one of the given mappers ifInvalid or ifValid is null

swap

public final Validation<T,E> swap()

Flip the valid/invalid values for this Validation. If this is a Valid<E,T>, returns Invalid<T,E>. Or if this is an Invalid<E,T>, return a Valid<T,E>.

Returns:

a flipped instance of Validation

map

public final <U> Validation<E,U> map(java.util.function.Function<? super T,? extends U> f)

Description copied from interface: Value

Maps the underlying value to a different component type.

Specified by:

map in interface Value<T>

Type Parameters:

U - The new component type

Parameters:

f - A mapper

Returns:

A new value

bimap

public final <E2,T2> Validation<E2,T2> bimap(java.util.function.Function<? super E,? extends E2> errorMapper,
                                             java.util.function.Function<? super T,? extends T2> valueMapper)

Whereas map only performs a mapping on a valid Validation, and mapError performs a mapping on an invalid Validation, bimap allows you to provide mapping actions for both, and will give you the result based on what type of Validation this is. Without this, you would have to do something like: validation.map(...).mapError(...);

Type Parameters:

E2 - type of the mapping result if this is an invalid

T2 - type of the mapping result if this is a valid

Parameters:

errorMapper - the invalid mapping operation

valueMapper - the valid mapping operation

Returns:

an instance of Validation<U,R>

Throws:

java.lang.NullPointerException - if invalidMapper or validMapper is null

mapError

public final <U> Validation<U,T> mapError(java.util.function.Function<? super E,? extends U> f)

Applies a function f to the error of this Validation if this is an Invalid. Otherwise does nothing if this is a Valid.

Type Parameters:

U - type of the error resulting from the mapping

Parameters:

f - a function that maps the error in this Invalid

Returns:

an instance of Validation<U,T>

Throws:

java.lang.NullPointerException - if mapping operation f is null

ap

public final <U> Validation<Seq<E>,U> ap(Validation<Seq<E>,? extends java.util.function.Function<? super T,? extends U>> validation)

combine

public final <U> Validation.Builder<E,T,U> combine(Validation<E,U> validation)

Combines two Validations to form a Validation.Builder, which can then be used to perform further combines, or apply a function to it in order to transform the Validation.Builder into a Validation.

Type Parameters:

U - type of the value contained in validation

Parameters:

validation - the validation object to combine this with

Returns:

an instance of Builder

filter

public final Option<Validation<E,T>> filter(java.util.function.Predicate<? super T> predicate)

flatMap

public final <U> Validation<E,U> flatMap(java.util.function.Function<? super T,? extends Validation<E,? extends U>> mapper)

peek

public final Validation<E,T> peek(java.util.function.Consumer<? super E> invalidAction,
                                  java.util.function.Consumer<? super T> validAction)

Applies the validAction to the value if this is valid otherwise applies the invalidAction to the cause of error.

Parameters:

invalidAction - A Consumer for the Failure case

validAction - A Consumer for the Success case

Returns:

this Validation

peek

public final Validation<E,T> peek(java.util.function.Consumer<? super T> action)

Description copied from interface: Value

Performs the given action on the first element if this is an eager implementation. Performs the given action on all elements (the first immediately, successive deferred), if this is a lazy implementation.

Specified by:

peek in interface Value<T>

Parameters:

action - The action that will be performed on the element(s).

Returns:

this instance

peekError

public final Validation<E,T> peekError(java.util.function.Consumer<? super E> action)

isAsync

public final boolean isAsync()

A Validation's value is computed synchronously.

Specified by:

isAsync in interface Value<T>

Returns:

false

isLazy

public final boolean isLazy()

A Validation's value is computed eagerly.

Specified by:

isLazy in interface Value<T>

Returns:

false

isSingleValued

public final boolean isSingleValued()

Description copied from interface: Value

States whether this is a single-valued type.

Specified by:

isSingleValued in interface Value<T>

Returns:

true if this is single-valued, false otherwise.

iterator

public final Iterator<T> iterator()

Description copied from interface: Value

Returns a rich io.vavr.collection.Iterator.

Specified by:

iterator in interface Value<T>

Specified by:

iterator in interface java.lang.Iterable<T>

Returns:

A new Iterator