Validated

Abstract Value Members

abstract def canEqual(that: Any): Boolean

Definition Classes
Equals
abstract def productArity: Int

Definition Classes
Product
abstract def productElement(n: Int): Any

Definition Classes
Product

Concrete Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def ===[EE >: E, AA >: A](that: Validated[EE, AA])(implicit EE: Eq[EE], AA: Eq[AA]): Boolean
def andThen[EE >: E, B](f: (A) ⇒ Validated[EE, B]): Validated[EE, B]

Apply a function (that returns a Validated) in the valid case.
Apply a function (that returns a Validated) in the valid case. Otherwise return the original Validated.
This allows "chained" validation: the output of one validation can be fed into another validation function.
This function is similar to flatMap on Either. It's not called flatMap, because by Cats convention, flatMap is a monadic bind that is consistent with ap. This method is not consistent with ap (or other Apply-based methods), because it has "fail-fast" behavior as opposed to accumulating validation failures.
def ap[EE >: E, B](f: Validated[EE, (A) ⇒ B])(implicit EE: Semigroup[EE]): Validated[EE, B]

From Apply: if both the function and this value are Valid, apply the function
final def asInstanceOf[T0]: T0

Definition Classes
Any
def bimap[EE, AA](fe: (E) ⇒ EE, fa: (A) ⇒ AA): Validated[EE, AA]

Validated is a functor.Bifunctor, this method applies one of the given functions.
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def combine[EE >: E, AA >: A](that: Validated[EE, AA])(implicit EE: Semigroup[EE], AA: Semigroup[AA]): Validated[EE, AA]

Combine this Validated with another Validated, using the Semigroup instances of the underlying E and A instances.
Combine this Validated with another Validated, using the Semigroup instances of the underlying E and A instances. The resultant Validated will be Valid, if, and only if, both this Validated instance and the supplied Validated instance are also Valid.
def compare[EE >: E, AA >: A](that: Validated[EE, AA])(implicit EE: Order[EE], AA: Order[AA]): Int
def ensure[EE >: E](onFailure: ⇒ EE)(f: (A) ⇒ Boolean): Validated[EE, A]

Ensure that a successful result passes the given predicate, falling back to an Invalid of onFailure if the predicate returns false.
Ensure that a successful result passes the given predicate, falling back to an Invalid of onFailure if the predicate returns false.
For example:
```
scala> Validated.valid("").ensure(new IllegalArgumentException("Must not be empty"))(_.nonEmpty)
res0: Validated[IllegalArgumentException, String] = Invalid(java.lang.IllegalArgumentException: Must not be empty)
```
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def exists(predicate: (A) ⇒ Boolean): Boolean

Is this Valid and matching the given predicate
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def fold[B](fe: (E) ⇒ B, fa: (A) ⇒ B): B
def foldLeft[B](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
def foldRight[B](lb: Eval[B])(f: (A, Eval[B]) ⇒ Eval[B]): Eval[B]

Lazily-apply the given function to the value with the given B when valid, otherwise return the given B.
def forall(f: (A) ⇒ Boolean): Boolean

Is this Invalid or matching the predicate
def foreach(f: (A) ⇒ Unit): Unit

Run the side-effecting function on the value if it is Valid
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def getOrElse[B >: A](default: ⇒ B): B

Return the Valid value, or the default if Invalid
def hashCode(): Int

Definition Classes
AnyRef → Any
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def isInvalid: Boolean
def isValid: Boolean
def leftMap[EE](f: (E) ⇒ EE): Validated[EE, A]

Apply a function to an Invalid value, returning a new Invalid value.
Apply a function to an Invalid value, returning a new Invalid value. Or, if the original valid was Valid, return it.
def map[B](f: (A) ⇒ B): Validated[E, B]

Apply a function to a Valid value, returning a new Valid value
def merge[EE >: E](implicit ev: <:<[A, EE]): EE
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def orElse[EE, AA >: A](default: ⇒ Validated[EE, AA]): Validated[EE, AA]

Return this if it is Valid, or else fall back to the given default.
def partialCompare[EE >: E, AA >: A](that: Validated[EE, AA])(implicit EE: PartialOrder[EE], AA: PartialOrder[AA]): Double
def product[EE >: E, B](fb: Validated[EE, B])(implicit EE: Semigroup[EE]): Validated[EE, (A, B)]

From Product
def productIterator: Iterator[Any]

Definition Classes
Product
def productPrefix: String

Definition Classes
Product
def show[EE >: E, AA >: A](implicit EE: Show[EE], AA: Show[AA]): String
def swap: Validated[A, E]
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toEither: Either[E, A]

Converts the value to an Either[E, A]
def toList: List[A]

Convert this value to a single element List if it is Valid, otherwise return an empty List
def toOption: Option[A]

Returns Valid values wrapped in Some, and None for Invalid values
def toString(): String

Definition Classes
AnyRef → Any
def toValidatedNel[EE >: E, AA >: A]: ValidatedNel[EE, AA]

Lift the Invalid value into a NonEmptyList.
def traverse[F[_], EE >: E, B](f: (A) ⇒ F[B])(implicit F: Applicative[F]): F[Validated[EE, B]]

When Valid, apply the function, marking the result as valid inside the Applicative's context, when Invalid, lift the Error into the Applicative's context
def valueOr[B >: A](f: (E) ⇒ B): B

Return the Valid value, or the result of f if Invalid
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
def withEither[EE, B](f: (Either[E, A]) ⇒ Either[EE, B]): Validated[EE, B]

Convert to an Either, apply a function, convert back.
Convert to an Either, apply a function, convert back. This is handy when you want to use the Monadic properties of the Either type.

Related Docs: object Validated | package data

sealed abstract class Validated[+E, +A] extends Product with Serializable

Abstract Value Members

abstract def canEqual(that: Any): Boolean

abstract def productArity: Int

abstract def productElement(n: Int): Any

Concrete Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def ===[EE >: E, AA >: A](that: Validated[EE, AA])(implicit EE: Eq[EE], AA: Eq[AA]): Boolean

def andThen[EE >: E, B](f: (A) ⇒ Validated[EE, B]): Validated[EE, B]

def ap[EE >: E, B](f: Validated[EE, (A) ⇒ B])(implicit EE: Semigroup[EE]): Validated[EE, B]

final def asInstanceOf[T0]: T0

def bimap[EE, AA](fe: (E) ⇒ EE, fa: (A) ⇒ AA): Validated[EE, AA]

def clone(): AnyRef

def combine[EE >: E, AA >: A](that: Validated[EE, AA])(implicit EE: Semigroup[EE], AA: Semigroup[AA]): Validated[EE, AA]

def compare[EE >: E, AA >: A](that: Validated[EE, AA])(implicit EE: Order[EE], AA: Order[AA]): Int

def ensure[EE >: E](onFailure: ⇒ EE)(f: (A) ⇒ Boolean): Validated[EE, A]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def exists(predicate: (A) ⇒ Boolean): Boolean

def finalize(): Unit

def fold[B](fe: (E) ⇒ B, fa: (A) ⇒ B): B

def foldLeft[B](b: B)(f: (B, A) ⇒ B): B

def foldRight[B](lb: Eval[B])(f: (A, Eval[B]) ⇒ Eval[B]): Eval[B]

def forall(f: (A) ⇒ Boolean): Boolean

def foreach(f: (A) ⇒ Unit): Unit

final def getClass(): Class[_]

def getOrElse[B >: A](default: ⇒ B): B

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def isInvalid: Boolean

def isValid: Boolean

def leftMap[EE](f: (E) ⇒ EE): Validated[EE, A]

def map[B](f: (A) ⇒ B): Validated[E, B]

def merge[EE >: E](implicit ev: <:<[A, EE]): EE

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def orElse[EE, AA >: A](default: ⇒ Validated[EE, AA]): Validated[EE, AA]

def partialCompare[EE >: E, AA >: A](that: Validated[EE, AA])(implicit EE: PartialOrder[EE], AA: PartialOrder[AA]): Double

def product[EE >: E, B](fb: Validated[EE, B])(implicit EE: Semigroup[EE]): Validated[EE, (A, B)]

def productIterator: Iterator[Any]

def productPrefix: String

def show[EE >: E, AA >: A](implicit EE: Show[EE], AA: Show[AA]): String

def swap: Validated[A, E]

final def synchronized[T0](arg0: ⇒ T0): T0

def toEither: Either[E, A]

def toList: List[A]

def toOption: Option[A]

def toString(): String

def toValidatedNel[EE >: E, AA >: A]: ValidatedNel[EE, AA]

def traverse[F[_], EE >: E, B](f: (A) ⇒ F[B])(implicit F: Applicative[F]): F[Validated[EE, B]]

def valueOr[B >: A](f: (E) ⇒ B): B

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def withEither[EE, B](f: (Either[E, A]) ⇒ Either[EE, B]): Validated[EE, B]

Inherited from Serializable

Inherited from Serializable

Inherited from Product

Inherited from Equals

Inherited from AnyRef

Inherited from Any

Ungrouped