//arrow-core/arrow.core/Validated

Validated

common sealed class Validated<out E, out A>

Types

Name Summary
Companion common object Companion
Invalid common data class Invalid<out E>(val value: E) : Validated<E, Nothing>
Valid common data class Valid<out A>(val value: A) : Validated<Nothing, A>

Functions

Name Summary
all common inline fun all(predicate: (A) -> Boolean): Boolean
bifoldLeft common inline fun <B> bifoldLeft(c: B, fe: (B, E) -> B, fa: (B, A) -> B): B
bifoldMap common inline fun <B> bifoldMap(MN: Monoid<B>, g: (E) -> B, f: (A) -> B): B
bimap common inline fun <EE, B> bimap(fe: (E) -> EE, fa: (A) -> B): Validated<EE, B>
From arrow.typeclasses.Bifunctor, maps both types of this Validated.
bitraverse common inline fun <EE, B> bitraverse(fe: (E) -> Iterable<EE>, fa: (A) -> Iterable<B>): List<Validated<EE, B»
bitraverseEither common inline fun <EE, B, C> bitraverseEither(fe: (E) -> Either<EE, B>, fa: (A) -> Either<EE, C>): Either<EE, Validated<B, C»
bitraverseNullable common inline fun <B, C> bitraverseNullable(fe: (E) -> B?, fa: (A) -> C?): Validated<B, C>?
bitraverseOption common inline fun <B, C> bitraverseOption(fe: (E) -> Option<B>, fa: (A) -> Option<C>): Option<Validated<B, C»
exist common inline fun exist(predicate: (A) -> Boolean): Boolean
Is this Valid and matching the given predicate
findOrNull common inline fun findOrNull(predicate: (A) -> Boolean): A?
fold common inline fun <B> fold(fe: (E) -> B, fa: (A) -> B): B
foldLeft common inline fun <B> foldLeft(b: B, f: (B, A) -> B): B
apply the given function to the value with the given B when valid, otherwise return the given B
foldMap common inline fun <B> foldMap(MB: Monoid<B>, f: (A) -> B): B
isEmpty common fun isEmpty(): Boolean
isNotEmpty common fun isNotEmpty(): Boolean
map common inline fun <B> map(f: (A) -> B): Validated<E, B>
Apply a function to a Valid value, returning a new Valid value
mapLeft common inline fun <EE> mapLeft(f: (E) -> EE): Validated<EE, A>
Apply a function to an Invalid value, returning a new Invalid value. Or, if the original valid was Valid, return it.
swap common fun swap(): Validated<A, E>
tap common inline fun tap(f: (A) -> Unit): Validated<E, A>
The given function is applied as a fire and forget effect if this is Valid. When applied the result is ignored and the original Validated value is returned
tapInvalid common inline fun tapInvalid(f: (E) -> Unit): Validated<E, A>
The given function is applied as a fire and forget effect if this is Invalid. When applied the result is ignored and the original Validated value is returned
toEither common fun toEither(): Either<E, A>
Converts the value to an Either
toList common fun toList(): List<A>
Convert this value to a single element List if it is Valid, otherwise return an empty List
toOption common fun toOption(): Option<A>
Returns Valid values wrapped in Some, and None for Invalid values
toString common open override fun toString(): String
toValidatedNel common fun toValidatedNel(): ValidatedNel<E, A>
Lift the Invalid value into a NonEmptyList.
traverse common inline fun <B> traverse(fa: (A) -> Iterable<B>): List<Validated<E, B»
traverseEither common inline fun <EE, B> traverseEither(fa: (A) -> Either<EE, B>): Either<EE, Validated<E, B»
traverseNullable common inline fun <B> traverseNullable(fa: (A) -> B?): Validated<E, B>?
traverseOption common inline fun <B> traverseOption(fa: (A) -> Option<B>): Option<Validated<E, B»
void common fun void(): Validated<E, Unit>
Discards the A value inside Validated signaling this container may be pointing to a noop or an effect whose return value is deliberately ignored. The singleton value Unit serves as signal.
withEither common inline fun <EE, B> withEither(f: (Either<E, A>) -> Either<EE, B>): Validated<EE, B>
Convert to an Either, apply a function, convert back. This is handy when you want to use the Monadic properties of the Either type.

Properties

Name Summary
isInvalid common val isInvalid: Boolean
isValid common val isValid: Boolean

Inheritors

Name
Valid
Invalid

Extensions

Name Summary
andThen common inline fun <E, A, B> Validated<E, A>.andThen(f: (A) -> Validated<E, B>): Validated<E, B>
Apply a function to a Valid value, returning a new Validation that may be valid or invalid
attempt common fun <E, A> Validated<E, A>.attempt(): Validated<Nothing, Either<E, A»
bind common fun <A> Validated<Throwable, A>.bind(): A
bisequence common fun <E, A> Validated<Iterable<E>, Iterable<A».bisequence(): List<Validated<E, A»
bisequenceEither common fun <E, A, B> Validated<Either<E, A>, Either<E, B».bisequenceEither(): Either<E, Validated<A, B»
bisequenceNullable common fun <A, B> Validated<A?, B?>.bisequenceNullable(): Validated<A, B>?
bisequenceOption common fun <A, B> Validated<Option<A>, Option<B».bisequenceOption(): Option<Validated<A, B»
combine common fun <E, A> Validated<E, A>.combine(SE: Semigroup<E>, SA: Semigroup<A>, y: Validated<E, A>): Validated<E, A>
combineAll common fun <E, A> Validated<E, A>.combineAll(MA: Monoid<A>): A
combineK common fun <E, A> Validated<E, A>.combineK(SE: Semigroup<E>, y: Validated<E, A>): Validated<E, A>
compareTo common operator fun <E : Comparable<E>, A : Comparable<A» Validated<E, A>.compareTo(other: Validated<E, A>): Int
findValid common inline fun <E, A> Validated<E, A>.findValid(SE: Semigroup<E>, that: () -> Validated<E, A>): Validated<E, A>
If this is valid return this, otherwise if that is valid return that, otherwise combine the failures. This is similar to orElse except that here failures are accumulated.
fold common fun <E, A> Validated<E, A>.fold(MA: Monoid<A>): A
getOrElse common inline fun <E, A> Validated<E, A>.getOrElse(default: () -> A): A
Return the Valid value, or the default if Invalid
handleError common inline fun <E, A> Validated<E, A>.handleError(f: (E) -> A): Validated<Nothing, A>
handleErrorWith common inline fun <E, A> Validated<E, A>.handleErrorWith(f: (E) -> Validated<E, A>): Validated<E, A>
leftWiden common fun <EE, E : EE, A> Validated<E, A>.leftWiden(): Validated<EE, A>
orElse common inline fun <E, A> Validated<E, A>.orElse(default: () -> Validated<E, A>): Validated<E, A>
Return this if it is Valid, or else fall back to the given default. The functionality is similar to that of findValid except for failure accumulation, where here only the error on the right is preserved and the error on the left is ignored.
orNone common fun <E, A> Validated<E, A>.orNone(): Option<A>
orNull common fun <E, A> Validated<E, A>.orNull(): A?
Return the Valid value, or null if Invalid
redeem common inline fun <E, A, B> Validated<E, A>.redeem(fe: (E) -> B, fa: (A) -> B): Validated<E, B>
replicate common fun <E, A> Validated<E, A>.replicate(SE: Semigroup<E>, n: Int): Validated<E, List<A»
fun <E, A> Validated<E, A>.replicate(SE: Semigroup<E>, n: Int, MA: Monoid<A>): Validated<E, A>
sequence common fun <E, A> Validated<E, Iterable<A».sequence(): List<Validated<E, A»
sequenceEither common fun <E, A, B> Validated<A, Either<E, B».sequenceEither(): Either<E, Validated<A, B»
sequenceNullable common fun <A, B> Validated<A, B?>.sequenceNullable(): Validated<A, B>?
sequenceOption common fun <A, B> Validated<A, Option<B».sequenceOption(): Option<Validated<A, B»
toIor common fun <E, A> Validated<E, A>.toIor(): Ior<E, A>
Converts the value to an Ior
valueOr common inline fun <E, A> Validated<E, A>.valueOr(f: (E) -> A): A
Return the Valid value, or the result of f if Invalid
widen common fun <E, B, A : B> Validated<E, A>.widen(): Validated<E, B>
Given A is a sub type of B, re-type this value from Validated to Validated
zip common fun <E, A, B> Validated<E, A>.zip(SE: Semigroup<E>, fb: Validated<E, B>): Validated<E, Pair<A, B»
inline fun <E, A, B, Z> Validated<E, A>.zip(SE: Semigroup<E>, b: Validated<E, B>, f: (A, B) -> Z): Validated<E, Z>
inline fun <E, A, B, C, Z> Validated<E, A>.zip(SE: Semigroup<E>, b: Validated<E, B>, c: Validated<E, C>, f: (A, B, C) -> Z): Validated<E, Z>
inline fun <E, A, B, C, D, Z> Validated<E, A>.zip(SE: Semigroup<E>, b: Validated<E, B>, c: Validated<E, C>, d: Validated<E, D>, f: (A, B, C, D) -> Z): Validated<E, Z>
inline fun <E, A, B, C, D, EE, Z> Validated<E, A>.zip(SE: Semigroup<E>, b: Validated<E, B>, c: Validated<E, C>, d: Validated<E, D>, e: Validated<E, EE>, f: (A, B, C, D, EE) -> Z): Validated<E, Z>
inline fun <E, A, B, C, D, EE, FF, Z> Validated<E, A>.zip(SE: Semigroup<E>, b: Validated<E, B>, c: Validated<E, C>, d: Validated<E, D>, e: Validated<E, EE>, ff: Validated<E, FF>, f: (A, B, C, D, EE, FF) -> Z): Validated<E, Z>
inline fun <E, A, B, C, D, EE, F, G, Z> Validated<E, A>.zip(SE: Semigroup<E>, b: Validated<E, B>, c: Validated<E, C>, d: Validated<E, D>, e: Validated<E, EE>, ff: Validated<E, F>, g: Validated<E, G>, f: (A, B, C, D, EE, F, G) -> Z): Validated<E, Z>
inline fun <E, A, B, C, D, EE, F, G, H, Z> Validated<E, A>.zip(SE: Semigroup<E>, b: Validated<E, B>, c: Validated<E, C>, d: Validated<E, D>, e: Validated<E, EE>, ff: Validated<E, F>, g: Validated<E, G>, h: Validated<E, H>, f: (A, B, C, D, EE, F, G, H) -> Z): Validated<E, Z>
inline fun <E, A, B, C, D, EE, F, G, H, I, Z> Validated<E, A>.zip(SE: Semigroup<E>, b: Validated<E, B>, c: Validated<E, C>, d: Validated<E, D>, e: Validated<E, EE>, ff: Validated<E, F>, g: Validated<E, G>, h: Validated<E, H>, i: Validated<E, I>, f: (A, B, C, D, EE, F, G, H, I) -> Z): Validated<E, Z>
inline fun <E, A, B, C, D, EE, F, G, H, I, J, Z> Validated<E, A>.zip(SE: Semigroup<E>, b: Validated<E, B>, c: Validated<E, C>, d: Validated<E, D>, e: Validated<E, EE>, ff: Validated<E, F>, g: Validated<E, G>, h: Validated<E, H>, i: Validated<E, I>, j: Validated<E, J>, f: (A, B, C, D, EE, F, G, H, I, J) -> Z): Validated<E, Z>

Do you like Arrow?

Arrow Org
<