Package com.github.tonivade.purefun.type

Interface Validation<E,T>

Type Parameters:

E - type of the error when invalid

T - type of the value when valid

All Superinterfaces:

Bindable<Validation<E,?>,T>, Kind<Validation<E,?>,T>, Mappable<Validation<E,?>,T>, ValidationOf<E,T>

All Known Implementing Classes:

Validation.Invalid, Validation.Valid

public sealed interface Validation<E,T>
extends ValidationOf<E,T>, Bindable<Validation<E,?>,T>
permits Validation.Valid<E,T>, Validation.Invalid<E,T>

This type represents the validity or not of a value. There are two possible values:

• Validation.valid(value): when the value is valid
• Validation.invalid(error): when the value is invalid

You can combine different values using mapN methods. Only when all values are valid, the final method is invoked, otherwise a combination of all errors is returned

Nested Class Summary

Nested Classes

Modifier and Type	Interface	Description
static final record	Validation.Invalid<E,T>
static final class	Validation.Result<E>
static final record	Validation.Valid<E,T>

Method Summary

Modifier and Type	Method	Description
default <R> Validation<Validation.Result<E>,R>	ap(Validation<Validation.Result<E>,Function1<? super T,? extends R>> other)
default <U, R> Validation<U,R>	bimap(Function1<? super E,? extends U> error, Function1<? super T,? extends R> mapper)
default Option<Validation<E,T>>	filter(Matcher1<? super T> matcher)
default Option<Validation<E,T>>	filterNot(Matcher1<? super T> matcher)
default Validation<E,T>	filterOrElse(Matcher1<? super T> matcher, Producer<? extends Kind<Validation<E,?>,T>> orElse)
default <R> Validation<E,R>	flatMap(Function1<? super T,? extends Kind<Validation<E,?>,? extends R>> mapper)
default <U> U	fold(Function1<? super E,? extends U> invalidMap, Function1<? super T,? extends U> validMap)
T	get()	Returns the valid value if available.
E	getError()	Returns the invalid value if available.
default T	getOrElse(Producer<? extends T> orElse)
default T	getOrElse(T value)
default T	getOrElseNull()
default T	getOrElseThrow()
default <X extends Throwable> T	getOrElseThrow(Function1<? super E,? extends X> mapper)
static <E, T> Validation<E,T>	invalid(E error)
static <E, T> Validation<Validation.Result<E>,T>	invalidOf(E error, E... errors)
boolean	isInvalid()
boolean	isValid()
default <R> Validation<E,R>	map(Function1<? super T,? extends R> mapper)
default <U> Validation<U,T>	mapError(Function1<? super E,? extends U> mapper)
static <E, T1, T2, R> Validation<Validation.Result<E>,R>	mapN(Validation<E,T1> validation1, Validation<E,T2> validation2, Function2<? super T1,? super T2,? extends R> mapper)
static <E, T1, T2, T3, R> Validation<Validation.Result<E>,R>	mapN(Validation<E,T1> validation1, Validation<E,T2> validation2, Validation<E,T3> validation3, Function3<? super T1,? super T2,? super T3,? extends R> mapper)
static <E, T1, T2, T3, T4, R> Validation<Validation.Result<E>,R>	mapN(Validation<E,T1> validation1, Validation<E,T2> validation2, Validation<E,T3> validation3, Validation<E,T4> validation4, Function4<? super T1,? super T2,? super T3,? super T4,? extends R> mapper)
static <E, T1, T2, T3, T4, T5, R> Validation<Validation.Result<E>,R>	mapN(Validation<E,T1> validation1, Validation<E,T2> validation2, Validation<E,T3> validation3, Validation<E,T4> validation4, Validation<E,T5> validation5, Function5<? super T1,? super T2,? super T3,? super T4,? super T5,? extends R> mapper)
default Validation<E,T>	or(Producer<Kind<Validation<E,?>,T>> orElse)
default Validation<E,T>	orElse(Kind<Validation<E,?>,T> orElse)
static Validation<String,Integer>	requireGreaterThan(Integer value, int x)
static Validation<String,Integer>	requireGreaterThanOrEqual(Integer value, int x)
static Validation<String,Integer>	requireLowerThan(Integer value, int x)
static Validation<String,Integer>	requireLowerThanOrEqual(Integer value, int x)
static Validation<String,String>	requireNonEmpty(String value)
static Validation<String,Integer>	requireNonEquals(Integer value, int x)
static <T> Validation<String,T>	requireNonNull(T value)
static Validation<String,Integer>	requirePositive(Integer value)
static <E, T, R> Validation<E,R>	select(Validation<E,Either<T,R>> validation, Validation<E,Function1<? super T,? extends R>> apply)
default Either<E,T>	toEither()
static <E, T> Validation<E,T>	valid(T value)

Methods inherited from interface com.github.tonivade.purefun.core.Bindable

andThen

Methods inherited from interface com.github.tonivade.purefun.Kind

fix, kind

Method Details

valid

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

invalid

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

invalidOf

@SafeVarargs
static <E,
T> Validation<Validation.Result<E>,T> invalidOf(E error,
 E... errors)

isValid

boolean isValid()

isInvalid

boolean isInvalid()

get

T get()

Returns the valid value if available. If not, it throws NoSuchElementException

Returns:

the valid value

Throws:

NoSuchElementException - if value is not available

getError

E getError()

Returns the invalid value if available. If not, it throws NoSuchElementException

Returns:

the invalid value

Throws:

NoSuchElementException - if value is not available

map

default <R> Validation<E,R> map(Function1<? super T,? extends R> mapper)

Specified by:

map in interface Bindable<E,T>

Specified by:

map in interface Mappable<E,T>

mapError

default <U> Validation<U,T> mapError(Function1<? super E,? extends U> mapper)

bimap

default <U,
R> Validation<U,R> bimap(Function1<? super E,? extends U> error,
 Function1<? super T,? extends R> mapper)

flatMap

default <R> Validation<E,R> flatMap(Function1<? super T,? extends Kind<Validation<E,?>,? extends R>> mapper)

Specified by:

flatMap in interface Bindable<E,T>

filter

default Option<Validation<E,T>> filter(Matcher1<? super T> matcher)

filterNot

default Option<Validation<E,T>> filterNot(Matcher1<? super T> matcher)

filterOrElse

default Validation<E,T> filterOrElse(Matcher1<? super T> matcher,
 Producer<? extends Kind<Validation<E,?>,T>> orElse)

or

default Validation<E,T> or(Producer<Kind<Validation<E,?>,T>> orElse)

orElse

default Validation<E,T> orElse(Kind<Validation<E,?>,T> orElse)

getOrElse

default T getOrElse(T value)

getOrElseNull

@Nullable
default T getOrElseNull()

getOrElse

default T getOrElse(Producer<? extends T> orElse)

getOrElseThrow

default T getOrElseThrow()

getOrElseThrow

default <X extends Throwable> T getOrElseThrow(Function1<? super E,? extends X> mapper)
                                        throws X

Throws:

X

fold

default <U> U fold(Function1<? super E,? extends U> invalidMap,
 Function1<? super T,? extends U> validMap)

ap

default <R> Validation<Validation.Result<E>,R> ap(Validation<Validation.Result<E>,Function1<? super T,? extends R>> other)

toEither

default Either<E,T> toEither()

select

static <E,
T,
R> Validation<E,R> select(Validation<E,Either<T,R>> validation,
 Validation<E,Function1<? super T,? extends R>> apply)

mapN

static <E,
T1,
T2,
R>
Validation<Validation.Result<E>,R> mapN(Validation<E,T1> validation1,
 Validation<E,T2> validation2,
 Function2<? super T1,? super T2,? extends R> mapper)

mapN

static <E,
T1,
T2,
T3,
R>
Validation<Validation.Result<E>,R> mapN(Validation<E,T1> validation1,
 Validation<E,T2> validation2,
 Validation<E,T3> validation3,
 Function3<? super T1,? super T2,? super T3,? extends R> mapper)

mapN

static <E,
T1,
T2,
T3,
T4,
R>
Validation<Validation.Result<E>,R> mapN(Validation<E,T1> validation1,
 Validation<E,T2> validation2,
 Validation<E,T3> validation3,
 Validation<E,T4> validation4,
 Function4<? super T1,? super T2,? super T3,? super T4,? extends R> mapper)

mapN

static <E,
T1,
T2,
T3,
T4,
T5,
R>
Validation<Validation.Result<E>,R> mapN(Validation<E,T1> validation1,
 Validation<E,T2> validation2,
 Validation<E,T3> validation3,
 Validation<E,T4> validation4,
 Validation<E,T5> validation5,
 Function5<? super T1,? super T2,? super T3,? super T4,? super T5,? extends R> mapper)

requireNonNull

static <T> Validation<String,T> requireNonNull(T value)

requireNonEmpty

static Validation<String,String> requireNonEmpty(String value)

requireNonEquals

static Validation<String,Integer> requireNonEquals(Integer value,
 int x)

requirePositive

static Validation<String,Integer> requirePositive(Integer value)

requireGreaterThan

static Validation<String,Integer> requireGreaterThan(Integer value,
 int x)

requireGreaterThanOrEqual

static Validation<String,Integer> requireGreaterThanOrEqual(Integer value,
 int x)

requireLowerThan

static Validation<String,Integer> requireLowerThan(Integer value,
 int x)

requireLowerThanOrEqual

static Validation<String,Integer> requireLowerThanOrEqual(Integer value,
 int x)