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

inline fun tapInvalid(f: (Nothing) -> Unit): Validated<Nothing, 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

fun toEither(): Either<Nothing, A>

Converts the value to an Either

toList

fun toList(): List<A>

Convert this value to a single element List if it is Valid, otherwise return an empty List

toOption

fun toOption(): Option<A>

Returns Valid values wrapped in Some, and None for Invalid values

toString

open override fun toString(): String

toValidatedNel

fun toValidatedNel(): ValidatedNel<Nothing, A>

Lift the Invalid value into a NonEmptyList.

traverse

inline fun <EE, B> traverse(fa: (A) -> Either<EE, B>): Either<EE, Validated<Nothing, B>>

inline fun traverse(fa: (A) -> Option): Option<Validated<Nothing, B>>

inline fun traverse(fa: (A) -> Iterable): List<Validated<Nothing, B>>

traverseEither

inline fun <EE, B> ~~traverseEither~~(fa: (A) -> Either<EE, B>): Either<EE, Validated<Nothing, B>>

traverseNullable

inline fun traverseNullable(fa: (A) -> B?): Validated<Nothing, B>?

traverseOption

inline fun ~~traverseOption~~(fa: (A) -> Option): Option<Validated<Nothing, B>>

void

fun void(): Validated<Nothing, 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

inline fun <EE, B> withEither(f: (Either<Nothing, 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

isInvalid

val isInvalid: Boolean

isValid

val isValid: Boolean

value

val value: A

Extensions

andThen

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

fun <E, A> Validated<E, A>.attempt(): Validated<Nothing, Either<E, A>>

bind

fun <A> Validated<Throwable, A>.~~bind~~(): A

bisequence

fun <E, A> Validated<Iterable<E>, Iterable<A>>.bisequence(): List<Validated<E, A>>

bisequenceEither

fun <E, A, B> Validated<Either<E, A>, Either<E, B>>.bisequenceEither(): Either<E, Validated<A, B>>

bisequenceNullable

fun <A, B> Validated<A?, B?>.bisequenceNullable(): Validated<A, B>?

bisequenceOption

fun <A, B> Validated<Option<A>, Option>.bisequenceOption(): Option<Validated<A, B>>

combine

fun <E, A> Validated<E, A>.combine(SE: Semigroup<E>, SA: Semigroup<A>, y: Validated<E, A>): Validated<E, A>

combineAll

fun <E, A> Validated<E, A>.~~combineAll~~(MA: Monoid<A>): A

combineK

fun <E, A> Validated<E, A>.combineK(SE: Semigroup<E>, y: Validated<E, A>): Validated<E, A>

compareTo

operator fun <E : Comparable<E>, A : Comparable<A>> Validated<E, A>.compareTo(other: Validated<E, A>): Int

findValid

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

fun <E, A> Validated<E, A>.fold(MA: Monoid<A>): A

getOrElse

inline fun <E, A> Validated<E, A>.getOrElse(default: () -> A): A

Return the Valid value, or the default if Invalid

handleError

inline fun <E, A> Validated<E, A>.handleError(f: (E) -> A): Validated<Nothing, A>

handleErrorWith

inline fun <E, A> Validated<E, A>.handleErrorWith(f: (E) -> Validated<E, A>): Validated<E, A>

leftWiden

fun <EE, E : EE, A> Validated<E, A>.leftWiden(): Validated<EE, A>

merge

inline fun <A> Validated<A, A>.merge(): A

orElse

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

fun <E, A> Validated<E, A>.orNone(): Option<A>

orNull

fun <E, A> Validated<E, A>.orNull(): A?

Return the Valid value, or null if Invalid

redeem

inline fun <E, A, B> Validated<E, A>.redeem(fe: (E) -> B, fa: (A) -> B): Validated<E, B>

replicate

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

fun <E, A> Validated<E, Iterable<A>>.sequence(): List<Validated<E, A>>

fun <E, A, B> Validated<A, Either<E, B>>.sequence(): Either<E, Validated<A, B>>

fun <A, B> Validated<A, Option>.sequence(): Option<Validated<A, B>>

fun <A, B> Validated<A, B?>.sequence(): Validated<A, B>?

sequenceEither

fun <E, A, B> Validated<A, Either<E, B>>.~~sequenceEither~~(): Either<E, Validated<A, B>>

sequenceNullable

fun <A, B> Validated<A, B?>.~~sequenceNullable~~(): Validated<A, B>?

sequenceOption

fun <A, B> Validated<A, Option>.~~sequenceOption~~(): Option<Validated<A, B>>

toIor

fun <E, A> Validated<E, A>.toIor(): Ior<E, A>

Converts the value to an Ior

valueOr

inline fun <E, A> Validated<E, A>.valueOr(f: (E) -> A): A

Return the Valid value, or the result of f if Invalid

widen

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

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>

inline fun <E, A, B, Z> ValidatedNel<E, A>.zip(b: ValidatedNel<E, B>, f: (A, B) -> Z): ValidatedNel<E, Z>

inline fun <E, A, B, C, Z> ValidatedNel<E, A>.zip(b: ValidatedNel<E, B>, c: ValidatedNel<E, C>, f: (A, B, C) -> Z): ValidatedNel<E, Z>

inline fun <E, A, B, C, D, Z> ValidatedNel<E, A>.zip(b: ValidatedNel<E, B>, c: ValidatedNel<E, C>, d: ValidatedNel<E, D>, f: (A, B, C, D) -> Z): ValidatedNel<E, Z>

inline fun <E, A, B, C, D, EE, Z> ValidatedNel<E, A>.zip(b: ValidatedNel<E, B>, c: ValidatedNel<E, C>, d: ValidatedNel<E, D>, e: ValidatedNel<E, EE>, f: (A, B, C, D, EE) -> Z): ValidatedNel<E, Z>

inline fun <E, A, B, C, D, EE, FF, Z> ValidatedNel<E, A>.zip(b: ValidatedNel<E, B>, c: ValidatedNel<E, C>, d: ValidatedNel<E, D>, e: ValidatedNel<E, EE>, ff: ValidatedNel<E, FF>, f: (A, B, C, D, EE, FF) -> Z): ValidatedNel<E, Z>

inline fun <E, A, B, C, D, EE, F, G, Z> ValidatedNel<E, A>.zip(b: ValidatedNel<E, B>, c: ValidatedNel<E, C>, d: ValidatedNel<E, D>, e: ValidatedNel<E, EE>, ff: ValidatedNel<E, F>, g: ValidatedNel<E, G>, f: (A, B, C, D, EE, F, G) -> Z): ValidatedNel<E, Z>

inline fun <E, A, B, C, D, EE, F, G, H, Z> ValidatedNel<E, A>.zip(b: ValidatedNel<E, B>, c: ValidatedNel<E, C>, d: ValidatedNel<E, D>, e: ValidatedNel<E, EE>, ff: ValidatedNel<E, F>, g: ValidatedNel<E, G>, h: ValidatedNel<E, H>, f: (A, B, C, D, EE, F, G, H) -> Z): ValidatedNel<E, Z>

inline fun <E, A, B, C, D, EE, F, G, H, I, Z> ValidatedNel<E, A>.zip(b: ValidatedNel<E, B>, c: ValidatedNel<E, C>, d: ValidatedNel<E, D>, e: ValidatedNel<E, EE>, ff: ValidatedNel<E, F>, g: ValidatedNel<E, G>, h: ValidatedNel<E, H>, i: ValidatedNel<E, I>, f: (A, B, C, D, EE, F, G, H, I) -> Z): ValidatedNel<E, Z>

inline fun <E, A, B, C, D, EE, F, G, H, I, J, Z> ValidatedNel<E, A>.zip(b: ValidatedNel<E, B>, c: ValidatedNel<E, C>, d: ValidatedNel<E, D>, e: ValidatedNel<E, EE>, ff: ValidatedNel<E, F>, g: ValidatedNel<E, G>, h: ValidatedNel<E, H>, i: ValidatedNel<E, I>, j: ValidatedNel<E, J>, f: (A, B, C, D, EE, F, G, H, I, J) -> Z): ValidatedNel<E, Z>