Scala Library: scala.util.control
scala.util.control
Type Members
class Breaks extends AnyRef
A class that can be instantiated for the break control abstraction. Example usage:
Calls to break from one instantiation of Breaks
will never target breakable
objects of some other instantiation.
trait ControlThrowable extends Throwable with NoStackTrace
A marker trait indicating that the Throwable
it is mixed into is intended for
flow control.
Note that Throwable
subclasses which extend this trait may extend any other
Throwable
subclass (eg. RuntimeException
) and are not required to extend
Throwable
directly.
Instances of Throwable
subclasses marked in this way should not normally be
caught. Where catch-all behaviour is required ControlThrowable
should be
propagated, for example:
trait NoStackTrace extends Throwable
A trait for exceptions which, for efficiency reasons, do not fill in the stack trace. Stack trace suppression can be disabled on a global basis via a system property wrapper in scala.sys.SystemProperties.
- Source
- Since
- 2.8
Value Members
object Breaks extends Breaks
An object that can be used for the break control abstraction. Example usage:
object Exception
Classes representing the components of exception handling. Each class is independently composable. Some example usages:
This class differs from scala.util.Try
in that it focuses on composing
exception handlers rather than composing behavior. All behavior should be
composed first and fed to a Catch
object using one of the opt
or either
methods.
object NoStackTrace extends Serializable
object NonFatal
Extractor of non-fatal Throwables. Will not match fatal errors like
VirtualMachineError
(for example, OutOfMemoryError
and
StackOverflowError
, subclasses of VirtualMachineError
), ThreadDeath
,
LinkageError
, InterruptedException
, ControlThrowable
.
Note that scala.util.control.ControlThrowable, an internal Throwable, is not
matched by NonFatal
(and would therefore be thrown).
For example, all harmless Throwables can be caught by:
object TailCalls
Methods exported by this object implement tail calls via trampolining. Tail
calling methods have to return their result using done
or call the next method
using tailcall
. Both return a TailRec
object. The result of evaluating a
tailcalling function can be retrieved from a Tailrec
value using method
result
. Implemented as described in “Stackless Scala with Free Monads”
http://blog.higher-order.com/assets/trampolines.pdf
Here’s a usage example:
Full Source:
Interested in Scala?
I send out weekly, personalized emails with articles and conference talks.
Subscribe now.