Validation

sealed trait Validation[+E] extends Product with Serializable

Represents the result of a validation, either the object Pass if the validation succeeded, else an instance of Fail containing an error value describing the validation failure.

Validations are used to filter Ors in for expressions or filter method calls. For example, consider these methods:

import org.scalactic._

def isRound(i: Int): Validation[ErrorMessage] =
 if (i % 10 == 0) Pass else Fail(i + " was not a round number")

def isDivBy3(i: Int): Validation[ErrorMessage] =
 if (i % 3 == 0) Pass else Fail(i + " was not divisible by 3")

Because isRound and isDivBy3 take an Int and return a Validation[ErrorMessage], you can use them in filters in for expressions involving Ors of type Int Or ErrorMessage. Here's an example:

for (i <- Good(3) if isRound(i) && isDivBy3(i)) yield i
// Result: Bad(3 was not a round number)

Validations can also be used to accumulate error using when, a method that's made available by trait Accumulation on accumualting Ors (Ors whose Bad type is an Every[T]). Here are some examples:

import Accumulation._

for (i <- Good(3) when (isRound, isDivBy3)) yield i
// Result: Bad(One(3 was not a round number))

for (i <- Good(4) when (isRound, isDivBy3)) yield i
// Result: Bad(Many(4 was not a round number, 4 was not divisible by 3))

Note: You can think of Validation as an “Option with attitude,” where Pass is a None that indicates validation success and Fail is a Some whose value describes the validation failure.

Type parameters:
E

the type of error value describing a validation failure for this Validation

Source:
Validation.scala
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
class Fail[E]
object Pass.type

Value members

Abstract methods

def &&[F >: E](other: => Validation[F]): Validation[F]

Ands this Validation with another, passed, Validation.

Ands this Validation with another, passed, Validation.

The result of and-ing two Validations is:

ExpressionResult
Pass && PassPass
Pass && Fail(right)Fail(right)
Fail(left) && PassFail(left)
Fail(left) && Fail(right)Fail(left)

As you can see in the above table, no attempt is made by && to accumulate errors, which in turn means that no constraint is placed on the E type (it need not be an Every). Instead, && short circuits and returns the first Fail it encounters. This makes it useful in filters in for expressions involving Ors. Here's an example:

import org.scalactic._

def isRound(i: Int): Validation[ErrorMessage] =
 if (i % 10 != 0) Fail(i + " was not a round number") else Pass

def isDivBy3(i: Int): Validation[ErrorMessage] =
 if (i % 3 != 0) Fail(i + " was not divisible by 3") else Pass

for (i <- Good(3) if isRound(i) && isDivBy3(i)) yield i
// Result: Bad(3 was not a round number)
Value parameters:
other

the other validation to and with this one

Returns:

the result of anding this Validation with the other, passed, Validation

Source:
Validation.scala

Inherited methods

def canEqual(that: Any): Boolean
Inherited from:
Equals
def productArity: Int
Inherited from:
Product
def productElement(n: Int): Any
Inherited from:
Product
def productElementName(n: Int): String
Inherited from:
Product
def productElementNames: Iterator[String]
Inherited from:
Product
def productIterator: Iterator[Any]
Inherited from:
Product
def productPrefix: String
Inherited from:
Product