Good

Instance Constructors

new Good(g: G)

g
the “good” value

Value Members

final def !=(arg0: AnyRef): Boolean

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

Definition Classes
Any
final def ##(): Int

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

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

Definition Classes
Any
def accumulating: Or[G, One[B]]

Converts this Or to an Or with the same Good type and a Bad type consisting of One parameterized by this Or's Bad type.
Converts this Or to an Or with the same Good type and a Bad type consisting of One parameterized by this Or's Bad type.
For example, invoking the accumulating method on an Int Or ErrorMessage would convert it to an Int Or One[ErrorMessage]. This result type, because the Bad type is an Every, can be used with the mechanisms provided in trait Accumulation to accumulate errors.
Note that if this Or is already an accumulating Or, the behavior of this accumulating method does not change. For example, if you invoke accumulating on an Int Or One[ErrorMessage] you will be rewarded with an Int Or One[One[ErrorMessage]].
returns
this Good, if this Or is a Good; or this Bad value wrapped in a One if this Or is a Bad.
Definition Classes Good → Or
final def asInstanceOf[T0]: T0 Definition Classes Any


      
      
      
      
        
        def
      
      
        asOr: Or[G, B]
      
      
      Returns this Good with the type widened to Or.
Returns this Good with the type widened to Or.
This widening method can useful when the compiler infers the more specific Good type and
you need the more general Or type. Here's an example that uses foldLeft on
a List[Int] to calculate a sum, so long as only odd numbers exist in a passed List:
scala> import org.scalautils._
import org.scalautils._
scala> def oddSum(xs: List[Int]): Int Or ErrorMessage =
     |   xs.foldLeft(Good(0).orBad[ErrorMessage]) { (acc, x) =>
     |     acc match {
     |       case Bad(_) => acc
     |       case Good(_) if (x % 2 == 0) => Bad(x + " is not odd")
     |       case Good(sum) => Good(sum + x)
     |     }
     |   }
<console>:13: error: constructor cannot be instantiated to expected type;
 found   : org.scalautils.Bad[G,B]
 required: org.scalautils.Good[Int,org.scalautils.ErrorMessage]
             case Bad(_) => acc
                  ^{<console>:14: error: type mismatch;
 found   : org.scalautils.Bad[Nothing,String]
 required: org.scalautils.Good[Int,org.scalautils.ErrorMessage]
             case Good(_) if (x % 2 == 0) => Bad(x + " is not odd")}
Because the compiler infers the type of the first parameter to foldLeft to be Good[Int, ErrorMessage],
it expects the same type to appear as the result type of function passed as the second, curried parameter. What you really want is
that both types be Int Or ErrorMessage, but the compiler thinks you want them to be the more specific
Good[Int, ErrorMessage]. You can use the asOr method to indicate you want the type to be Or
with minimal boilerplate:
scala> def oddSum(xs: List[Int]): Int Or ErrorMessage =
     |   xs.foldLeft(Good(0).orBad[ErrorMessage].asOr) { (acc, x) =>
     |     acc match {
     |       case Bad(_) => acc
     |       case Good(_) if (x % 2 == 0) => Bad(x + " is not odd")
     |       case Good(sum) => Good(sum + x)
     |     }
     |   }
oddSum: (xs: List[Int])org.scalautils.Or[Int,org.scalautils.ErrorMessage]
Now you can use the method to sum a List of odd numbers:
scala> oddSum(List(1, 2, 3))
res2: org.scalautils.Or[Int,org.scalautils.ErrorMessage] = Bad(2 is not odd)
scala> oddSum(List(1, 3, 5))
res3: org.scalautils.Or[Int,org.scalautils.ErrorMessage] = Good(9)

def clone(): AnyRef Attributes protected[java.lang] Definition Classes AnyRef Annotations @throws()
final def eq(arg0: AnyRef): Boolean Definition Classes AnyRef
def exists(p: (G) ⇒ Boolean): Boolean Returns true if this Or is a Good and the predicate p returns true when applied to this Good's value. Returns true if this Or is a Good and the predicate p returns true when applied to this Good's value. Note: The exists method will return the same result as forall if this Or is a Good, but the opposite result if this Or is a Bad. p the predicate to apply to the Good value, if this is a Good returns the result of applying the passed predicate p to the Good value, if this is a Good, else false Definition Classes Good → Or
def filter[C >: B](f: (G) ⇒ Validation[C]): Or[G, C] Returns this Or if either 1) it is a Bad or 2) it is a Good and applying the validation function f to this Good's value returns Pass; otherwise, returns a new Bad containing the error value contained in the Fail resulting from applying the validation function f to this Good's value. Returns this Or if either 1) it is a Bad or 2) it is a Good and applying the validation function f to this Good's value returns Pass; otherwise, returns a new Bad containing the error value contained in the Fail resulting from applying the validation function f to this Good's value. For examples of filter used in for expressions, see the main documentation for trait Validation. f the validation function to apply returns a Good if this Or is a Good that passes the validation function, else a Bad. Definition Classes Good → Or
def finalize(): Unit Attributes protected[java.lang] Definition Classes AnyRef Annotations @throws()
def flatMap[H, C >: B](f: (G) ⇒ Or[H, C]): Or[H, C] Returns the given function applied to the value contained in this Or if it is a Good, or returns this if it is a Bad. Returns the given function applied to the value contained in this Or if it is a Good, or returns this if it is a Bad. f the function to apply returns if this is a Good, the result of applying the given function to the contained value wrapped in a Good, else this Bad is returned Definition Classes Good → Or
def forall(p: (G) ⇒ Boolean): Boolean Returns true if either this Or is a Bad or if the predicate p returns true when applied to this Good's value. Returns true if either this Or is a Bad or if the predicate p returns true when applied to this Good's value. Note: The forall method will return the same result as exists if this Or is a Good, but the opposite result if this Or is a Bad. p the predicate to apply to the Good value, if this is a Good returns the result of applying the passed predicate p to the Good value, if this is a Good, else true Definition Classes Good → Or
def foreach(f: (G) ⇒ Unit): Unit Applies the given function f to the contained value if this Or is a Good; does nothing if this Or is a Bad. Applies the given function f to the contained value if this Or is a Good; does nothing if this Or is a Bad. f the function to apply Definition Classes Good → Or
val g: G the “good” value the “good” value
def get: G Returns the Or's value if it is a Good or throws NoSuchElementException if it is a Bad. Returns the Or's value if it is a Good or throws NoSuchElementException if it is a Bad. returns the contained value if this is a Good Definition Classes Good → Or Exceptions thrown NoSuchElementExceptionif this is a Bad
final def getClass(): Class[_] Definition Classes AnyRef → Any
def getOrElse[H >: G](default: ⇒ H): G Returns, if this Or is Good, this Good's value; otherwise returns the result of evaluating default. Returns, if this Or is Good, this Good's value; otherwise returns the result of evaluating default. default the default expression to evaluate if this Or is a Bad returns the contained value, if this Or is a Good, else the result of evaluating the given default Definition Classes Good → Or
val isBad: Boolean Indicates whether this Or is a Bad Indicates whether this Or is a Bad returns true if this Or is a Bad, false if it is a Good. Definition Classes Or
val isGood: Boolean Indicates whether this Or is a Good Indicates whether this Or is a Good returns true if this Or is a Good, false if it is a Bad. Definition Classes Good → Or
final def isInstanceOf[T0]: Boolean Definition Classes Any
def map[H](f: (G) ⇒ H): Or[H, B] Maps the given function to this Or's value if it is a Good or returns this if it is a Bad. Maps the given function to this Or's value if it is a Good or returns this if it is a Bad. f the function to apply returns if this is a Good, the result of applying the given function to the contained value wrapped in a Good, else this Bad is returned Definition Classes Good → Or
final def ne(arg0: AnyRef): Boolean Definition Classes AnyRef
final def notify(): Unit Definition Classes AnyRef
final def notifyAll(): Unit Definition Classes AnyRef
def orBad[C](implicit ev: <:<[B, C]): Good[G, C] Narrows the Bad type of this Good to the given type. Narrows the Bad type of this Good to the given type. Because Or has two types, but the Good factory method only takes a value of the “good” type, the Scala compiler will infer Nothing for the Bad type: scala> Good(3) res0: org.scalautils.Good[Int,Nothing] = Good(3) Often Nothing will work fine, as it will be widened as soon as the compiler encounters a more specific Bad type. Sometimes, however, you may need to specify it. In such situations you can use this orBad method, like this: scala> Good(3).orBad[String] res1: org.scalautils.Good[Int,String] = Good(3)
def orElse[H >: G, C >: B](alternative: ⇒ Or[H, C]): Or[G, B] Returns this Or if it is a Good, otherwise returns the result of evaluating the passed alternative. Returns this Or if it is a Good, otherwise returns the result of evaluating the passed alternative. alternative the alternative by-name to evaluate if this Or is a Bad returns this Or, if it is a Good, else the result of evaluating alternative Definition Classes Good → Or
def swap: Or[B, G] Returns an Or with the Good and Bad types swapped: Bad becomes Good and Good becomes Bad. Returns an Or with the Good and Bad types swapped: Bad becomes Good and Good becomes Bad. Here's an example: scala> val lyrics = Bad("Hey Jude, don't make it bad. Take a sad song and make it better.") lyrics: org.scalautils.Bad[Nothing,String] = Bad(Hey Jude, don't make it bad. Take a sad song and make it better.) scala> lyrics.swap res12: org.scalautils.Or[String,Nothing] = Good(Hey Jude, don't make it bad. Take a sad song and make it better.) Now that song will be rolling around in your head all afternoon. But at least it is a good song (thanks to swap). returns if this Or is a Good, its Good value wrapped in a Bad; if this Or is a Bad, its Bad value wrapped in a Good. Definition Classes Good → Or
final def synchronized[T0](arg0: ⇒ T0): T0 Definition Classes AnyRef
def toEither: Either[B, G] Returns an Either: a Right containing the Good value, if this is a Good; a Left containing the Bad value, if this is a Bad. Returns an Either: a Right containing the Good value, if this is a Good; a Left containing the Bad value, if this is a Bad. Note that values effectively “switch sides” when convering an Or to an Either. If the type of the Or on which you invoke toEither is Or[Int, ErrorMessage] for example, the result will be an Either[ErrorMessage, Int]. The reason is that the convention for Either is that Left is used for “bad” values and Right is used for “good” ones. returns this Good value, wrapped in a Right, or this Bad value, wrapped in a Left. Definition Classes Good → Or
def toOption: Some[G] Returns a Some containing the Good value, if this Or is a Good, else None. Returns a Some containing the Good value, if this Or is a Good, else None. returns the contained “good” value wrapped in a Some, if this Or is a Good; None if this Or is a Bad. Definition Classes Good → Or
def toSeq: IndexedSeq[G] Returns an immutable IndexedSeq containing the Good value, if this Or is a Good, else an empty immutable IndexedSeq. Returns an immutable IndexedSeq containing the Good value, if this Or is a Good, else an empty immutable IndexedSeq. returns the contained “good” value in a lone-element Seq if this Or is a Good; an empty Seq if this Or is a Bad. Definition Classes Good → Or
def toTry(implicit ev: <:<[B, Throwable]): Success[G] Returns a Try: a Success containing the Good value, if this is a Good; a Failure containing the Bad value, if this is a Bad. Returns a Try: a Success containing the Good value, if this is a Good; a Failure containing the Bad value, if this is a Bad. Note: This method can only be called if the Bad type of this Or is a subclass of Throwable (or Throwable itself). Note that values effectively “switch sides” when converting an Or to an Either. If the type of the Or on which you invoke toEither is Or[Int, ErrorMessage] for example, the result will be an Either[ErrorMessage, Int]. The reason is that the convention for Either is that Left is used for “bad” values and Right is used for “good” ones. returns this Good value, wrapped in a Right, or this Bad value, wrapped in a Left. Definition Classes Good → Or
def transform[H, C](gf: (G) ⇒ Or[H, C], bf: (B) ⇒ Or[H, C]): Or[H, C] Transforms this Or by applying the function gf to this Or's Good value if it is a Good, or by applying bf to this Or's Bad value if it is a Bad.
Transforms this Or by applying the function gf to this Or's Good value if it is a Good, or by applying bf to this Or's Bad value if it is a Bad.
gf the function to apply to this Or's Good value, if it is a Good bf the function to apply to this Or's Bad value, if it is a Bad returns
the result of applying the appropriate one of the two passed functions, gf or bf, to this Or's value

Definition Classes
Good → Or
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 withFilter[C >: B](f: (G) ⇒ Validation[C]): Or[G, C]

Currently just forwards to filter, and therefore, returns the same result.
Currently just forwards to filter, and therefore, returns the same result.

Definition Classes
Or

final case class Good[+G, +B](g: G) extends Or[G, B] with Product with Serializable

Instance Constructors

new Good(g: G)

Value Members

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

def accumulating: Or[G, One[B]]

final def asInstanceOf[T0]: T0

def asOr: Or[G, B]

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def exists(p: (G) ⇒ Boolean): Boolean

def filter[C >: B](f: (G) ⇒ Validation[C]): Or[G, C]

def finalize(): Unit

def flatMap[H, C >: B](f: (G) ⇒ Or[H, C]): Or[H, C]

def forall(p: (G) ⇒ Boolean): Boolean

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

val g: G

def get: G

final def getClass(): Class[_]

def getOrElse[H >: G](default: ⇒ H): G

val isBad: Boolean

val isGood: Boolean

final def isInstanceOf[T0]: Boolean

def map[H](f: (G) ⇒ H): Or[H, B]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def orBad[C](implicit ev: <:<[B, C]): Good[G, C]

def orElse[H >: G, C >: B](alternative: ⇒ Or[H, C]): Or[G, B]

def swap: Or[B, G]

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

def toEither: Either[B, G]

def toOption: Some[G]

def toSeq: IndexedSeq[G]

def toTry(implicit ev: <:<[B, Throwable]): Success[G]

def transform[H, C](gf: (G) ⇒ Or[H, C], bf: (B) ⇒ Or[H, C]): Or[H, C]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def withFilter[C >: B](f: (G) ⇒ Validation[C]): Or[G, C]

Inherited from Serializable

Inherited from Serializable

Inherited from Product

Inherited from Equals

Inherited from Or[G, B]

Inherited from AnyRef

Inherited from Any

Ungrouped