Makes Box
play better with Scala for
comprehensions.
Makes Box
play better with Scala for
comprehensions.
Alias for pass
.
Returns true if the value contained in this box is equal to the specified value.
Returns true if the value contained in this box is equal to the specified
value. This is the same thing that ==
does when it's handed a value that
isn't a Box
, but using this is recommended because it's clearer that the
behavior will be different than the usual expectation.
Transform an Empty
to a Failure
with the specified message.
Chain the given msg
as a Failure
ahead of any failures this Box
may
represent.
Chain the given msg
as a Failure
ahead of any failures this Box
may
represent.
If this is an Empty
, this method behaves like ?~
. If it is a Failure
,
however, this method returns a new Failure
with the given msg
and with its
chain
set to this Failure
.
As with ?~
, if this is a Full
, we return it unchanged.
A Failure
with the message if this Box
is an Empty
box. Chain
this box to the new Failure
if this is a Failure
. The unchanged
box if it is a Full
.
Create a Full
box containing the specified value if this box's value is
of type B
and Empty
otherwise.
Equivalent to flatMap(f1).or(alternative)
.
Equivalent to flatMap(f1).or(alternative)
.
If the partial function is defined at the current Box's value, apply the partial function.
If the partial function is defined at the current Box's value, apply the partial function.
An alias for collect
.
An alias for collect
.
Although this function is different for true collections, because Box
is
really a collection of 1, the two functions are identical.
Alias for ?~!
.
Alias for ?~!
.
Equivalent to map(f).openOr(dflt)
.
Equivalent to map(f).openOr(dflt)
.
Returns an Iterator
over the value
contained in this Box
, if any.
For Full
and Empty
, this has the expected behavior.
For Full
and Empty
, this has the expected behavior. Equality in terms
of Failure checks for equivalence of failure causes:
Failure("boom") == Failure("boom") Failure("bam") != Failure("boom") Failure("boom", Full(someException), Empty) != Failure("boom")
For other values, determines equality based upon the contents of this Box
instead of the box itself. As a result, it is not symmetric. As an example:
val foo = "foo" val boxedFoo = Full(foo) foo == boxedFoo //is false boxedFoo == foo //is true
It is safest to use ===
explicitly when you're looking for this behavior,
and use ==
only for box-to-box comparisons:
Full("magic") == Full("magic") Full("magic") != Full("another") Full("magic") != Empty Full("magic") != Failure("something's gone wrong")
Return a list of the exceptions that led to this Failure
.
Return a list of the exceptions that led to this Failure
. First, unflattens
the list of causes of this Failure
's exception
. Then, if this Failure
has a chain
, walks down it and concatenates their exceptionChain
to the
end of this one's.
A single list of Throwable
s from the most direct cause to the
least direct cause of this Failure
.
If this Box
contains a value and it satisfies the specified func
,
return true
.
If this Box
contains a value and it satisfies the specified func
,
return true
. Otherwise, return false
.
true
if this Box does contain a value and it satisfies the
predicate.
Alias for ?~
.
Flatten the Failure
chain to a List where this Failure is at the head.
If this Box
contains a value and it satisfies the specified predicate
,
return the Box
unchanged.
If this Box
contains a value and it satisfies the specified predicate
,
return the Box
unchanged.
If this Box
contains a value and it satisfies the specified predicate
,
return the Box
unchanged. Otherwise, return a Failure
with the given
msg
.
A Failure
with the message if the box is empty or the predicate
is not satisfied by the value contained in this Box.
If this Box
contains a value and it does not satisfy the specified
f
, return the Box
unchanged.
If this Box
contains a value and it does not satisfy the specified
f
, return the Box
unchanged. Otherwise, return an Empty
.
Apply a function returning a Box
to the value contained in this Box
if
it exists and return the resulting Box
.
Returns a Full
box containing the results of applying flipFn
to this box if it is a Failure
,
ParamFailure
or Empty
.
Returns a Full
box containing the results of applying flipFn
to this box if it is a Failure
,
ParamFailure
or Empty
. Returns Empty
if this box is Full
. In other words, it "flips" the
full/empty status of this Box.
If this Box
contains a value and it does not satisfy the specified
func
, return false
.
If this Box
contains a value and it does not satisfy the specified
func
, return false
. Otherwise, return true
.
true If the Box
is empty, or if its value satisfies the
predicate.
Perform a side effect by calling the specified function with the value contained in this box.
Perform a side effect by calling the specified function with the value
contained in this box. The function does not run if this Box
is empty.
If the Box
is Full
, apply the transform function f
on the value v
;
otherwise, just return the value untransformed.
If the Box
is Full
, apply the transform function f
on the value v
;
otherwise, just return the value untransformed.
The transform function is expected to be a function that will take the
value v
and produce a function from the value in the box to a new value
of the same type as v
.
For example:
val myBox = Full(10) myBox.fullXForm("No teddy bears left.")({ message => { teddyBears: Int => s"$message Oh wait, there are $teddyBears left!" } })
The type of the initial value, default value, and transformed value.
If the Box
is Full
, the value once transformed by the function
returned by f
. Otherwise, the initial value v
.
Exists to avoid the implicit conversion from Box
to Option
.
Exists to avoid the implicit conversion from Box
to Option
. Opening a
Box
unsafely should be done using openOrThrowException
.
This method always throws an exception.
If this box is Full
and contains an object of type B
, returns a Full
of type Box[B]
.
If this box is Full
and contains an object of type B
, returns a Full
of type Box[B]
. Otherwise, returns Empty
.
This is basically a Java-friendly version of asA
, which you should
prefer when using Scala.
For example:
scala> Full("boom").isA(classOf[Int]) res0: olon.common.Box[Int] = Empty scala> Full(5).isA(classOf[Int]) res1: olon.common.Box[Int] = Full(5)
Returns true if the box contains a value.
Returns true if the box contains a value.
Returns true
if this Box
contains no value (i.e., it is Empty
or
Failure
or ParamFailure
).
Returns an Iterator
over the value
contained in this Box
, if any.
Get a java.util.Iterator
from the Box.
Get a java.util.Iterator
from the Box.
Apply a function to the value contained in this Box
if it exists and return
a Full
containing the result.
Reduce this Failure
's message and the messages of all chained failures a
to a single String
.
Reduce this Failure
's message and the messages of all chained failures a
to a single String
. The resulting string links each step in the failure
chain with <-, and this Failure
's message is last.
For example:
scala> Failure("It's all gone wrong.") ?~! "Something's gone wrong." ?~! "It's all sideways" res0: olon.common.Failure = Failure(It's all sideways,Empty, Full(Failure(Something's gone wrong.,Empty, Full(Failure(It's all gone wrong.,Empty,Empty))))) scala> res0.messageChain res1: String = It's all sideways <- Something's gone wrong. <- It's all gone wrong.
Return the value contained in this Box
if it is full; otherwise return
the specified default.
The only time when you should be using this method is if the value is guaranteed to be available based on a guard outside of the method.
The only time when you should be using this method is if the value is
guaranteed to be available based on a guard outside of the method. In these
cases, please provide that information in the justification String
.
For example, User.currentUser.openOrThrowException("This snippet is only
used on pages where the user is logged in")
. For tests, use ==
or
===
instead. See the class documentation for more information.
A valid justification for using this method should not be "I want my code to fail fast when I call it." Using exceptions in the core logic of your application should be strongly discouraged.
Justify why calling this method is okay and why it will not result in an exception being thrown. This serves both as mandatory documentation and as a very clear indication of what unexpected thing happened in the event you were wrong about the guard.
The contents of the Box
if it is Full
.
Return this Box if Full
, or the specified alternative if it is
empty.
Perform a side effect by passing this Box
to the specified function and
return this Box
unmodified.
Perform a side effect by passing this Box
to the specified function and
return this Box
unmodified. Similar to foreach
, except that foreach
returns Unit
, while this method allows chained use of the Box
.
This box.
Gets the deepest exception cause, if any, which is ostensibly the root
cause of this Failure
.
This method calls the specified function with the specified in
value and
the value contained in this Box
.
This method calls the specified function with the specified in
value and
the value contained in this Box
. If this box is empty, returns the in
value directly.
The result of the function or the in
value.
An Either
that is a Right
with the given argument
right
if this is empty, or a Left
with the boxed value if this is
Full
.
Returns a List
of one element if this
is Full, or an empty list if empty.
Returns the contents of this box wrapped in Some
if this is Full
, or
None
if this is empty (meaning an Empty
, Failure
or ParamFailure).
Returns the contents of this box wrapped in Some
if this is Full
, or
None
if this is empty (meaning an Empty
, Failure
or ParamFailure).
An Either
that is a Left
with the given argument
left
if this is empty, or a Right
with the boxed value if this is
Full
.
Transforms this box using the transformFn
.
Transforms this box using the transformFn
. If transformFn
is defined for this box,
returns the result of applying transformFn
to it. Otherwise, returns this box unchanged.
If you want to change the content of a Full
box, using map
or collect
might be better
suited to that purpose. If you want to convert an Empty
, Failure
or a ParamFailure
into a
Full
box, you should use flip
.
// Returns Full("alternative") because the partial function covers the case. Full("error") transform { case Full("error") => Full("alternative") } // Returns Full(1), this Full box unchanged, because the partial function doesn't cover the case. Full(1) transform { case Full(2) => Failure("error") } // Returns this Failure("another-error") unchanged because the partial function doesn't cover the case. Failure("another-error") transform { case Failure("error", Empty, Empty) => Full("alternative") } // Returns Full("alternative") for an Empty box since `partialFn` is defined for Empty Empty transform { case Empty => Full("alternative") } // Returns Empty because the partial function is not defined for Empty Empty transform { case Failure("error", Empty, Empty) => Full("alternative") }
Makes Box
play better with Scala for
comprehensions.
Makes Box
play better with Scala for
comprehensions.
Transform an Empty
or Failure
to a ParamFailure
with the specified
type-safe parameter.
Transform an Empty
or Failure
to a ParamFailure
with the specified
type-safe parameter.
A value indicating the error.
A ParamFailure
with the specified value, unless this is already a
ParamFailure
or a Full
. If this is a Failure
, the
ParamFailure
will preserve the message of the Failure
.
A
Failure
is anEmptyBox
with an additional failure message explaining the reason for its being empty. It can also optionally provide an exception and/or a chain of previousFailure
s that may have caused this one.