Validated

abstract def canEqual(that: Any): Boolean

abstract def productArity: Int

abstract def productElement(n: Int): Any

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]

Apply a function (that returns a Validated) in the valid case.

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

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

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.

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

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

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

Is this Valid and matching the given predicate

def finalize(): Unit

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[_]

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

Return the Valid value, or the default if Invalid

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

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.

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

Apply a function to a Valid value, returning a new Valid value

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]

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]

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]

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

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

Lift the Invalid value into a NonEmptyList.

def toXor: Xor[E, A]

Convert this value to RightOr if Valid or LeftOr if Invalid

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

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def withXor[EE, B](f: (Xor[E, A]) ⇒ Xor[EE, B]): Validated[EE, B]

Convert to an Xor, apply a function, convert back.