Пакет scala.util

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.

Текущее значение может быть получено с помощью метода value. Новые значения должны быть добавлены с помощью метода withValue. Значения, добавленные через withValue, остаются действительными только пока выполняется второй аргумент withValue, безаргаментное замыкание. По завершении второго аргумента переменная возвращается к предыдущему значению.

someDynamicVariable.withValue(newValue) {
  // ... code called in here that calls value ...
  // ... will be given back the newValue ...
}

Каждый поток получает свой собственный стек привязок. При создании нового потока DynamicVariable получает копию стека привязок от родительского потока, и с этого момента привязки для нового потока независимы от привязок для исходного потока.

Представляет значение одного из двух возможных типов (дизъюнктивное объединение). Экземпляр Either является экземпляром либо scala.util.Left, либо scala.util.Right.

Обычное использование Either - это альтернатива scala.Option для работы с потенциально отсутствующими значениями. В этом использовании scala.None заменяется на scala.util.Left, который может содержать полезную информацию. scala.util.Right заменяет scala.Some. Согласно соглашению, Left используется для обозначения неудачи, а Right - для успеха.

Например, вы можете использовать Either[String, Int] для указания, является ли полученный ввод String или Int.

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 является правосторонним (right-biased), что означает, что Right предполагается как значение по умолчанию для обработки. Если это Left, операции, такие как map и flatMap, возвращают значение Left без изменений:

def doubled(i: Int) = i * 2
Right(42).map(doubled) // Right(84)
Left(42).map(doubled)  // Left(42)

Поскольку Either определяет методы map и flatMap, его также можно использовать в for-выражениях:

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]

Поскольку for выражения используют map и flatMap, типы параметров функций, используемых в выражении, должны быть выведены. Эти типы ограничены значениями Either. В частности, из-за правосторонности (right-biasing), значения Left могут потребовать явного указания типа для параметра типа B, правого значения. В противном случае он может быть выведен как Nothing.

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]`

Тип Try представляет вычисление, которое может привести либо к исключению, либо к возвращению успешно вычисленного значения. Он похож на, но семантически отличается от типа scala.util.Either.

Экземпляры Try[T], являются либо экземпляром scala.util.Success[T], либо scala.util.Failure[T].

Например, Try можно использовать для выполнения деления на пользовательский ввод, без необходимости явного обработки исключений во всех местах, где может произойти исключение.

Пример:

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
  }
}

Важным свойством Try, показанным в приведенном выше примере, является его способность цеплять или объединять операции, обрабатывая исключения по пути. Комбинаторы flatMap и map в приведенном выше примере по существу передают либо успешно завершённое значение, заключенное в тип Success для его дальнейшей обработки следующим комбинатором в цепочке, либо исключение, заключенное в тип Failure обычно для его простого передачи вниз по цепочке. Комбинаторы, такие как recover и recoverWith, разработаны для предоставления некоторого типа поведения по умолчанию в случае ошибки.

Примечание: только некритические исключения перехватываются комбинаторами в Try (см. scala.util.control.NonFatal). Серьёзные системные ошибки, с другой стороны, будут выброшены.

Примечание: все комбинаторы Try перехватывают исключения и возвращают ошибку, если не указано иное в документации.

Try появился в стандартной библиотеке Scala после многолетнего использования как неотъемлемой части стека Twitter.