Full

def != (arg0: AnyRef): Boolean

def != (arg0: Any): Boolean

def ## (): Int

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

Alias for pass

def == (arg0: AnyRef): Boolean

def == (arg0: Any): Boolean

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

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

def ?~ (msg: String): Box[A]

Transform an Empty to a Failure with the specified message.

def ?~! (msg: String): Box[A]

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

def choice [B] (f1: (A) ⇒ 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[A, B]): Box[B]

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

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

Alias for ?~!

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

Equivalent to map(f).

def elements : Iterator[A]

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.

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

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

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

Alias for ?~

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

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

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

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

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

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: (A) ⇒ 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] (clsOrg: 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[A]

Returns an Iterator over the value contained in this Box

def javaIterator [B >: A] : 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 ne (arg0: AnyRef): Boolean

def notify (): Unit

def notifyAll (): Unit

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

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

def openTheBox : A

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

def open_! : A

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

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

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

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

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 run [T] (in: T)(f: (T, A) ⇒ 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[A, 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[A]

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

def toOption : Option[A]

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, A]

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

val value : A

def wait (): Unit

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

def wait (arg0: Long): Unit

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

Makes Box play better with Scala 2.

def ~> [T] (errorCode: T): Box[A]

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

def productElements : Iterator[Any]