Failure

def != (arg0: AnyRef): Boolean

def != (arg0: Any): Boolean

def ## (): Int

def $ (f: (Box[Nothing]) ⇒ Unit): Box[Nothing]

Alias for pass

def == (arg0: AnyRef): Boolean

def == (arg0: Any): Boolean

def === [B >: Nothing] (to: B): Boolean

Returns true if the value contained in this box is equal to the specified value.

def ?~ (msg: String): Failure

Transform an Empty to a Failure with the specified message.

def ?~! (msg: String): Failure

Transform an EmptyBox to a Failure with the specified message and chain the new Failure to any previous Failure represented by this Box.

def asA [B] (implicit m: Manifest[B]): Box[B]

Return a Full[B] if the contents of this Box is of type B, otherwise return Empty

def asInstanceOf [T0] : T0

def canEqual (arg0: Any): Boolean

val chain : Box[Failure]

def choice [B] (f1: (Nothing) ⇒ Box[B])(alternative: ⇒ Box[B]): Box[B]

Apply the function f1 to the contents of this Box if available; if this is empty return the specified alternative.

def clone (): AnyRef

def collect [B] (pf: PartialFunction[Nothing, B]): Box[B]

If the partial function is defined at the current Box's value apply the partial function.

def compoundFailMsg (msg: String): Box[Nothing]

Alias for ?~!

def dmap [B] (dflt: ⇒ B)(f: (Nothing) ⇒ B): B

Equivalent to map(f).

def elements : Iterator[Nothing]

Returns an Iterator over the value contained in this Box

def eq (arg0: AnyRef): Boolean

def equals (other: Any): Boolean

Determines equality based upon the contents of this Box instead of the box itself.

val exception : Box[Throwable]

def exceptionChain : List[Throwable]

Get the exception chain along with the exception chain of any chained failures

def exists (func: (Nothing) ⇒ Boolean): Boolean

Determine whether this Box contains a value which satisfies the specified predicate

def failMsg (msg: String): Box[Nothing]

Alias for ?~

def failureChain : List[Failure]

Flatten the Failure chain to a List where this Failure is at the head

def filter (p: (Nothing) ⇒ Boolean): Box[Nothing]

Return this Box if it contains a value satisfying the specified predicate; Empty otherwise

def filterMsg (msg: String)(p: (Nothing) ⇒ Boolean): Box[Nothing]

Filter this box on the specified predicate, returning a Failure with the specified message if the predicate is not satisfied.

def filterNot (f: (Nothing) ⇒ Boolean): Box[Nothing]

Creates a Box if the current Box is Full and the value does not satisfy the predicate, f.

def finalize (): Unit

def flatMap [B] (f: (A) ⇒ Box[B]): Box[B]

Apply a function returning a Box to the value contained in this Box if it exists and return the result, or empty otherwise.

def foreach [U] (f: (Nothing) ⇒ U): Unit

Perform a side effect by calling the specified function with the value contained in this box.

def getClass (): java.lang.Class[_]

def hashCode (): Int

def isA [B] (cls: Class[B]): Box[B]

Return a Full[B] if the contents of this Box is an instance of the specified class, otherwise return Empty

def isDefined : Boolean

Returns true if the box contains a value.

def isEmpty : Boolean

Returns true if this Box contains no value (is Empty or Failure or ParamFailure)

def isInstanceOf [T0] : Boolean

def iterator : Iterator[Nothing]

Returns an Iterator over the value contained in this Box

def javaIterator [B >: Nothing] : Iterator[B]

Get a Java Iterator from the Box

def map [B] (f: (A) ⇒ B): Box[B]

Apply a function to the value contained in this Box if it exists and return a new Box containing the result, or empty otherwise.

def messageChain : String

val msg : String

def ne (arg0: AnyRef): Boolean

def notify (): Unit

def notifyAll (): Unit

def openOr [B] (default: ⇒ B): B

Return the value contained in this Box if it is full; otherwise return the specified default

def openTheBox : Nothing

Return the value contained in this Box if it is Full; throw an exception otherwise.

def open_! : Nothing

Return the value contained in this Box if it is Full; throw an exception otherwise.

def or [B] (alternative: ⇒ Box[B]): Box[B]

Return this Box if Full, or the specified alternative if this is empty

def pass (f: (Box[Nothing]) ⇒ Unit): Box[Nothing]

Perform a side effect by passing this Box to the specified function and return this Box unmodified.

def productArity : Int

def productElement (arg0: Int): Any

def productIterator : Iterator[Any]

def productPrefix : String

def rootExceptionCause : Box[Throwable]

Gets the deepest exception cause

def run [T] (in: T)(f: (T, Nothing) ⇒ T): T

This method calls the specified function with the value contained in this Box

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

def toLeft [B] (right: ⇒ B): Either[Nothing, B]

An Either that is a Right with the given argument right if this is empty, or a Left if this is Fill with the Box's value

def toList : List[Nothing]

Returns a List of one element if this is Full, or an empty list if empty.

def toOption : Option[Nothing]

Returns the contents of this box in an Option if this is Full, or None if this is a empty (Empty, Failure or ParamFailure)

def toRight [B] (left: ⇒ B): Either[B, Nothing]

An Either that is a Left with the given argument left if this is empty, or a Right if this Full with the Box's value.

def toString (): String

def wait (): Unit

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

def wait (arg0: Long): Unit

def withFilter (p: (Nothing) ⇒ Boolean): WithFilter

Makes Box play better with Scala 2.

def ~> [T] (errorCode: T): ParamFailure[T]

Transform an Empty to a ParamFailure with the specified typesafe parameter.

def productElements : Iterator[Any]