fields-cats/jap.fields/CatsInteropInstances0/FromCatsValidated

FromCatsValidated

class FromCatsValidated[L[_]](implicit A: Applicative[L], SK: SemigroupK[L], F: Foldable[L]) extends AccumulateLike[[_] =>> ValidatedUK[L, _$4]]

Validated instance for cats.data.Validated where error is collection type like cats.data.NonEmptyList or cats.data.NonEmptyChain

trait AccumulateLike[[_] =>> ValidatedUK[L, _$4]]
trait Validated[[_] =>> ValidatedUK[L, _$4]]
class Object
trait Matchable
class Any

Type members

Inherited types

type TypeClass[E] = V[E]
Inherited from:
Validated

Value members

Concrete methods

def and[E](a: TypeClass[E], b: TypeClass[E]): TypeClass[E]
def errors[E](vr: TypeClass[E]): List[E]
def invalid[E](e: E): TypeClass[E]
def isValid[E](e: TypeClass[E]): Boolean
def map[E, B](a: TypeClass[E])(f: E => B): TypeClass[B]
def valid[E]: TypeClass[E]

Inherited methods

def andAll[E](list: List[ValidatedUK[L, E]]): ValidatedUK[L, E]

Combiness all list using AND

Combiness all list using AND

Inherited from:
Validated
def asError[E](v: ValidatedUK[L, E])(error: E): ValidatedUK[L, E]

Returns error if v is invalid

Returns error if v is invalid

Inherited from:
Validated
def asInvalid[E](v: ValidatedUK[L, E])(invalid: ValidatedUK[L, E]): ValidatedUK[L, E]

Returns invalid if v is invalid

Returns invalid if v is invalid

Inherited from:
Validated
def fold[E, B](v: ValidatedUK[L, E])(fe: ValidatedUK[L, E] => B, fa: => B): B

Folds V[E] into B using provided functions for valid and invalid cases

Folds V[E] into B using provided functions for valid and invalid cases

Inherited from:
Validated
def isInvalid[E](v: ValidatedUK[L, E]): Boolean

Checks if v is invalid

Checks if v is invalid

Inherited from:
Validated
def or[E](va: ValidatedUK[L, E], vb: ValidatedUK[L, E]): ValidatedUK[L, E]

Combines a and b using OR

Combines a and b using OR

Inherited from:
Validated
def orAll[E](list: List[ValidatedUK[L, E]]): ValidatedUK[L, E]

Combiness all list using OR

Combiness all list using OR

Inherited from:
Validated
def sequence[E](list: List[ValidatedUK[L, E]]): ValidatedUK[L, E]

Combiness all list using AND

Combiness all list using AND

Inherited from:
Validated
def traverse[A, E](list: A*)(error: A => ValidatedUK[L, E]): ValidatedUK[L, E]
Inherited from:
Validated
def traverse[A, E](list: List[A])(error: A => ValidatedUK[L, E]): ValidatedUK[L, E]
Inherited from:
Validated
def unless[E](cond: Boolean)(v: => ValidatedUK[L, E]): ValidatedUK[L, E]

Returns v if cond is false else returns valid

Returns v if cond is false else returns valid

Inherited from:
Validated
def when[E](cond: Boolean)(v: => ValidatedUK[L, E]): ValidatedUK[L, E]

Returns v if cond is true else returns valid

Returns v if cond is true else returns valid

Inherited from:
Validated
def whenInvalid[E](v: ValidatedUK[L, E])(f: ValidatedUK[L, E] => ValidatedUK[L, E]): ValidatedUK[L, E]

Returns f applied to a if a is invalid else returns a

Returns f applied to a if a is invalid else returns a

Inherited from:
Validated
def whenValid[E](va: ValidatedUK[L, E])(vb: => ValidatedUK[L, E]): ValidatedUK[L, E]

Returns o if a is valid else returns a

Returns o if a is valid else returns a

Inherited from:
Validated

Inherited fields