package util
- Alphabetic
- Public
- All
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.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 viawithValue
only stay valid while thewithValue
's second argument, a parameterless closure, executes. When the second argument finishes, the variable reverts to the previous value.someDynamicVariable.withValue(newValue) { // ... code called in here that calls value ... // ... will be given back the newValue ... }
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.- Since
2.6
-
sealed abstract
class
Either[+A, +B] extends Product with Serializable
Represents a value of one of two possible types (a disjoint union.) An instance of
Either
is an instance of either scala.util.Left or scala.util.Right.Represents a value of one of two possible types (a disjoint union.) An instance of
Either
is an instance of either scala.util.Left or scala.util.Right.A common use of
Either
is as an alternative to scala.Option for dealing with possibly 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 thatLeft
is used for failure andRight
is used for success.For example, you could use
Either[String, Int]
to indicate whether a received input is aString
or anInt
.import scala.io.StdIn._ val in = readLine("Type Either a string or an Int: ") val result: Either[String,Int] = try Right(in.toInt) catch { case e: NumberFormatException => Left(in) } result match { case Right(x) => s"You passed me the Int: $x, which I will increment. $x + 1 = ${x+1}" case Left(x) => s"You passed me the String: $x" }
Either
is right-biased, which means thatRight
is assumed to be the default case to operate on. If it isLeft
, operations likemap
andflatMap
return theLeft
value unchanged:def doubled(i: Int) = i * 2 Right(42).map(doubled) // Right(84) Left(42).map(doubled) // Left(42)
Since
Either
defines the methodsmap
andflatMap
, it can also be used in for comprehensions:val right1 = Right(1) : Right[Double, Int] val right2 = Right(2) val right3 = Right(3) val left23 = Left(23.0) : Left[Double, Int] val left42 = Left(42.0) for { x <- right1 y <- right2 z <- right3 } yield x + y + z // Right(6) for { x <- right1 y <- right2 z <- left23 } yield x + y + z // Left(23.0) for { x <- right1 y <- left23 z <- right2 } yield x + y + z // Left(23.0) // Guard expressions are not supported: for { i <- right1 if i > 0 } yield i // error: value withFilter is not a member of Right[Double,Int] // Similarly, refutable patterns are not supported: for (x: Int <- right1) yield x // error: value withFilter is not a member of Right[Double,Int]
Since
for
comprehensions usemap
andflatMap
, the types of function parameters used in the expression must be inferred. These types are constrained by theEither
values. In particular, because of right-biasing,Left
values may require an explicit type argument for type parameterB
, the right value. Otherwise, it might be inferred asNothing
.for { x <- left23 y <- right1 z <- left42 // type at this position: Either[Double, Nothing] } yield x + y + z // ^ // error: ambiguous reference to overloaded definition, // both method + in class Int of type (x: Char)Int // and method + in class Int of type (x: Byte)Int // match argument types (Nothing) for (x <- right2 ; y <- left23) yield x + y // Left(23.0) for (x <- right2 ; y <- left42) yield x + y // error for { x <- right1 y <- left42 // type at this position: Either[Double, Nothing] z <- left23 } yield x + y + z // Left(42.0), but unexpectedly a `Either[Double,String]`
- Since
2.7
- final case class Failure[+T](exception: Throwable) extends Try[T] with Product with Serializable
-
final
case class
Left[+A, +B](value: A) extends Either[A, B] with Product with Serializable
The left side of the disjoint union, as opposed to the scala.util.Right side.
- class Random extends Serializable
-
final
case class
Right[+A, +B](value: B) extends Either[A, B] with Product with Serializable
The right side of the disjoint union, as opposed to the scala.util.Left side.
- 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.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:
import scala.io.StdIn import scala.util.{Try, Success, Failure} def divide: Try[Int] = { val dividend = Try(StdIn.readLine("Enter an Int that you'd like to divide:\n").toInt) val divisor = Try(StdIn.readLine("Enter an Int that you'd like to divide by:\n").toInt) val problem = dividend.flatMap(x => divisor.map(y => x/y)) problem match { case Success(v) => println("Result of " + dividend.get + "/"+ divisor.get +" is: " + v) Success(v) case Failure(e) => println("You must've divided by zero or entered something that's not an Int. Try again!") println("Info from the exception: " + e.getMessage) divide } }
An important property of
Try
shown in the above example is its ability to pipeline, or chain, operations, catching exceptions along the way. TheflatMap
andmap
combinators in the above example each essentially pass off either their successfully completed value, wrapped in theSuccess
type for it to be further operated upon by the next combinator in the chain, or the exception wrapped in theFailure
type usually to be simply passed on down the chain. Combinators such asrecover
andrecoverWith
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.- Since
2.10
-
class
MurmurHash[T] extends (T) ⇒ Unit
A class designed to generate well-distributed non-cryptographic hashes.
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
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.The object
Random
offers a default implementation of scala.util.Random and random-related convenience methods.- Since
2.8
-
object
Sorting
The
Sorting
object provides convenience wrappers forjava.util.Arrays.sort
.The
Sorting
object provides convenience wrappers forjava.util.Arrays.sort
. Methods that defer tojava.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 wherejava.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 usejava.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.
- object Try extends Serializable
Deprecated Value Members
-
object
MurmurHash
An object designed to generate well-distributed non-cryptographic hashes.
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
This is the documentation for the Scala standard library.
Package structure
The scala package contains core types like
Int
,Float
,Array
orOption
which are accessible in all Scala compilation units without explicit qualification or imports.Notable packages include:
scala.collection
and its sub-packages contain Scala's collections frameworkscala.collection.immutable
- Immutable, sequential data-structures such asVector
,List
,Range
,HashMap
orHashSet
scala.collection.mutable
- Mutable, sequential data-structures such asArrayBuffer
,StringBuilder
,HashMap
orHashSet
scala.collection.concurrent
- Mutable, concurrent data-structures such asTrieMap
scala.collection.parallel.immutable
- Immutable, parallel data-structures such asParVector
,ParRange
,ParHashMap
orParHashSet
scala.collection.parallel.mutable
- Mutable, parallel data-structures such asParArray
,ParHashMap
,ParTrieMap
orParHashSet
scala.concurrent
- Primitives for concurrent programming such asFutures
andPromises
scala.io
- Input and output operationsscala.math
- Basic math functions and additional numeric types likeBigInt
andBigDecimal
scala.sys
- Interaction with other processes and the operating systemscala.util.matching
- Regular expressionsOther packages exist. See the complete list on the right.
Additional parts of the standard library are shipped as separate libraries. These include:
scala.reflect
- Scala's reflection API (scala-reflect.jar)scala.xml
- XML parsing, manipulation, and serialization (scala-xml.jar)scala.swing
- A convenient wrapper around Java's GUI framework called Swing (scala-swing.jar)scala.util.parsing
- Parser combinators (scala-parser-combinators.jar)Automatic imports
Identifiers in the scala package and the
scala.Predef
object are always in scope by default.Some of these identifiers are type aliases provided as shortcuts to commonly used classes. For example,
List
is an alias forscala.collection.immutable.List
.Other aliases refer to classes provided by the underlying platform. For example, on the JVM,
String
is an alias forjava.lang.String
.