com.github.tonivade.purefun.type

Interface Validation<E,T>

All Superinterfaces:

FlatMap2<Validation.µ,E,T>, Higher1<Higher1<Validation.µ,E>,T>, Higher2<Validation.µ,E,T>, Holder<T>, Kind, Mappable<Higher1<Validation.µ,E>,T>

All Known Implementing Classes:

Validation.Invalid, Validation.Valid

public interface Validation<E,T>
extends Holder<T>, FlatMap2<Validation.µ,E,T>

Nested Class Summary

Nested Classes

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

Method Summary

Modifier and Type	Method and Description
default <R> Validation<Sequence<E>,R>	ap(Validation<Sequence<E>,Function1<T,R>> other)
default Option<Validation<E,T>>	filter(Matcher1<T> matcher)
default Validation<E,T>	filterOrElse(Matcher1<T> matcher, Producer<Validation<E,T>> orElse)
default <R> Validation<E,R>	flatMap(Function1<T,? extends Higher2<Validation.µ,E,R>> mapper)
default <V> Validation<E,V>	flatten()
default <U> U	fold(Function1<T,U> validMap, Function1<E,U> invalidMap)
E	getError()
static <E,T> Validation<E,T>	invalid(E error)
boolean	isInvalid()
boolean	isValid()
default <R> Validation<E,R>	map(Function1<T,R> mapper)
static <E,T1,T2,R> Validation<Sequence<E>,R>	map2(Validation<E,T1> validation1, Validation<E,T2> validation2, Function2<T1,T2,R> mapper)
static <E,T1,T2,T3,R> Validation<Sequence<E>,R>	map3(Validation<E,T1> validation1, Validation<E,T2> validation2, Validation<E,T3> validation3, Function3<T1,T2,T3,R> mapper)
static <E,T1,T2,T3,T4,R> Validation<Sequence<E>,R>	map4(Validation<E,T1> validation1, Validation<E,T2> validation2, Validation<E,T3> validation3, Validation<E,T4> validation4, Function4<T1,T2,T3,T4,R> mapper)
static <E,T1,T2,T3,T4,T5,R> Validation<Sequence<E>,R>	map5(Validation<E,T1> validation1, Validation<E,T2> validation2, Validation<E,T3> validation3, Validation<E,T4> validation4, Validation<E,T5> validation5, Function5<T1,T2,T3,T4,T5,R> mapper)
default <U> Validation<U,T>	mapError(Function1<E,U> mapper)
com.github.tonivade.purefun.type.ValidationModule	module()
static <E> Monad<Higher1<Validation.µ,E>>	monad()
static <E,T> Validation<E,T>	narrowK(Higher1<Higher1<Validation.µ,E>,T> hkt)
static <E,T> Validation<E,T>	narrowK(Higher2<Validation.µ,E,T> hkt)
default T	orElse(Producer<T> orElse)
default T	orElse(T value)
default Either<E,T>	toEither()
static <E,T> Validation<E,T>	valid(T value)

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

get

Method Detail

valid

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

invalid

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

narrowK

static <E,T> Validation<E,T> narrowK(Higher2<Validation.µ,E,T> hkt)

narrowK

static <E,T> Validation<E,T> narrowK(Higher1<Higher1<Validation.µ,E>,T> hkt)

isValid

boolean isValid()

isInvalid

boolean isInvalid()

getError

E getError()

map

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

Specified by:

map in interface Mappable<Higher1<Validation.µ,E>,T>

mapError

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

flatMap

default <R> Validation<E,R> flatMap(Function1<T,? extends Higher2<Validation.µ,E,R>> mapper)

Specified by:

flatMap in interface FlatMap2<Validation.µ,E,T>

filter

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

filterOrElse

default Validation<E,T> filterOrElse(Matcher1<T> matcher,
                                     Producer<Validation<E,T>> orElse)

orElse

default T orElse(T value)

orElse

default T orElse(Producer<T> orElse)

fold

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

ap

default <R> Validation<Sequence<E>,R> ap(Validation<Sequence<E>,Function1<T,R>> other)

toEither

default Either<E,T> toEither()

flatten

default <V> Validation<E,V> flatten()

Specified by:

flatten in interface Holder<T>

monad

static <E> Monad<Higher1<Validation.µ,E>> monad()

module

com.github.tonivade.purefun.type.ValidationModule module()

map2

static <E,T1,T2,R> Validation<Sequence<E>,R> map2(Validation<E,T1> validation1,
                                                  Validation<E,T2> validation2,
                                                  Function2<T1,T2,R> mapper)

map3

static <E,T1,T2,T3,R> Validation<Sequence<E>,R> map3(Validation<E,T1> validation1,
                                                     Validation<E,T2> validation2,
                                                     Validation<E,T3> validation3,
                                                     Function3<T1,T2,T3,R> mapper)

map4

static <E,T1,T2,T3,T4,R> Validation<Sequence<E>,R> map4(Validation<E,T1> validation1,
                                                        Validation<E,T2> validation2,
                                                        Validation<E,T3> validation3,
                                                        Validation<E,T4> validation4,
                                                        Function4<T1,T2,T3,T4,R> mapper)

map5

static <E,T1,T2,T3,T4,T5,R> Validation<Sequence<E>,R> map5(Validation<E,T1> validation1,
                                                           Validation<E,T2> validation2,
                                                           Validation<E,T3> validation3,
                                                           Validation<E,T4> validation4,
                                                           Validation<E,T5> validation5,
                                                           Function5<T1,T2,T3,T4,T5,R> mapper)