Scala Library: scala.util
scala.util
Deprecated Value Members
object MurmurHash
An object designed to generate well-distributed non-cryptographic hashes. It is designed to hash a collection of integers; along with the integers to hash, it generates two magic streams of integers to increase the distribution of repetitive input sequences. Thus, three methods need to be called at each step (to start and to incorporate a new integer) to update the values. Only one method needs to be called to finalize the hash.
- Annotations
- @ deprecated
- Deprecated
- (Since version 2.10.0) Use the object MurmurHash3 instead.
- Source
Type Members
class DynamicVariable[T] extends AnyRef
DynamicVariables
provide a binding mechanism where the current value is found
through dynamic scope, but where access to the variable itself is resolved
through static scope.
The current value can be retrieved with the value method. New values should be
pushed using the withValue
method. Values pushed via withValue
only stay
valid while the withValue
‘s second argument, a parameterless closure,
executes. When the second argument finishes, the variable reverts to the
previous value.
Each thread gets its own stack of bindings. When a new thread is created, the
DynamicVariable
gets a copy of the stack of bindings from the parent thread,
and from then on the bindings for the new thread are independent of those for
the original thread.
- Source
- Version
- 1.1, 2007-5-21
sealed abstract class Either[+A, +B] extends Product with Serializable
Represents a value of one of two possible types (a disjoint union.) Instances of Either are either an instance of scala.util.Left or scala.util.Right.
A common use of Either is as an alternative to scala.Option for dealing with possible missing values. In this usage, scala.None is replaced with a scala.util.Left which can contain useful information. scala.util.Right takes the place of scala.Some. Convention dictates that Left is used for failure and Right is used for success.
For example, you could use Either[String, Int]
to detect whether a received
input is a String or an Int.
A projection can be used to selectively operate on a value of type Either,
depending on whether it is of type Left or Right. For example, to transform an
Either using a function, in the case where it’s a Left, one can first apply the
left
projection and invoke map
on that projected Either. If a right
projection is applied to that Left, the original Left is returned, unmodified.
Like with other types which define a map
method, the same can be achieved
using a for-comprehension:
To support multiple projections as generators in for-comprehensions, the Either
type also defines a flatMap
method.
- Source
- Version
- 1.0, 11/10/2008
- Since
- 2.7
final case class Failure[+T](exception: Throwable) extends Try[T] with Product with Serializable
final case class Left[+A, +B](a: A) extends Either[A, B] with Product with Serializable
The left side of the disjoint union, as opposed to the scala.util.Right side.
- Source
- Version
- 1.0, 11/10/2008
class MurmurHash[T] extends (T) ⇒ Unit
A class designed to generate well-distributed non-cryptographic hashes. It is designed to be passed to a collection’s foreach method, or can take individual hash values with append. Its own hash code is set equal to the hash code of whatever it is hashing.
- Annotations
- @ deprecated
- Deprecated
- (Since version 2.10.0) Use the object MurmurHash3 instead.
- Source
class Random extends Serializable
final case class Right[+A, +B](b: B) extends Either[A, B] with Product with Serializable
The right side of the disjoint union, as opposed to the scala.util.Left side.
- Source
- Version
- 1.0, 11/10/2008
final case class Success[+T](value: T) extends Try[T] with Product with Serializable
sealed abstract class Try[+T] extends Product with Serializable
The Try
type represents a computation that may either result in an exception,
or return a successfully computed value. It’s similar to, but semantically
different from the scala.util.Either type.
Instances of Try[T]
, are either an instance of scala.util.Success [T] or
scala.util.Failure [T].
For example, Try
can be used to perform division on a user-defined input,
without the need to do explicit exception-handling in all of the places that an
exception might occur.
Example:
An important property of Try
shown in the above example is its ability to _
pipeline_ , or chain, operations, catching exceptions along the way. The
flatMap
and map
combinators in the above example each essentially pass off
either their successfully completed value, wrapped in the Success
type for it
to be further operated upon by the next combinator in the chain, or the
exception wrapped in the Failure
type usually to be simply passed on down the
chain. Combinators such as recover
and recoverWith
are designed to provide
some type of default behavior in the case of failure.
Note : only non-fatal exceptions are caught by the combinators on Try
(see
scala.util.control.NonFatal). Serious system errors, on the other hand, will be
thrown.
Note: : all Try combinators will catch exceptions and return failure unless otherwise specified in the documentation.
Try
comes to the Scala standard library after years of use as an integral
part of Twitter’s stack.
- Source
- Since
- 2.10
Value Members
object Either extends Serializable
object Properties extends PropertiesTrait
Loads library.properties
from the jar.
object Random extends Random
The object Random
offers a default implementation of scala.util.Random and
random-related convenience methods.
- Source
- Since
- 2.8
object Sorting
The Sorting
object provides convenience wrappers for java.util.Arrays.sort
.
Methods that defer to java.util.Arrays.sort
say that they do or under what
conditions that they do.
Sorting
also implements a general-purpose quicksort and stable (merge) sort
for those cases where java.util.Arrays.sort
could only be used at the cost of
a large memory penalty. If performance rather than memory usage is the primary
concern, one may wish to find alternate strategies to use
java.util.Arrays.sort
directly e.g. by boxing primitives to use a custom
ordering on them.
Sorting
provides methods where you can provide a comparison function, or can
request a sort of items that are scala.math.Ordered or that otherwise have an
implicit or explicit scala.math.Ordering.
Note also that high-performance non-default sorts for numeric types are not provided. If this is required, it is advisable to investigate other libraries that cover this use case.
- Source
- Version
- 1.1
object Try extends Serializable
package control
package hashing
package matching
Full Source:
Interested in Scala?
I send out weekly, personalized emails with articles and conference talks.
Subscribe now.