Пакет scala

Пример A <:< B свидетельствует о том, что A является подтипом B. Требование неявного аргумента типа A <:< B кодирует обобщённое ограничение A <: B.

Чтобы ограничить любой абстрактный тип T, который находится в области видимости в списке аргументов метода (не только собственные параметры типа метода), просто добавьте неявный аргумент типа T <:< U, где U является требуемым верхним ограничением; или для нижних ограничений используйте: L <:< T, где L является требуемым нижним ограничением.

В случае возникновения каких-либо неясностей относительно того, какой метод идёт в каком направлении, все методы "Co" (включая apply) идут слева направо в типе ("с" типом), а все методы "Contra" идут справа налево ("против" типа). Например, apply преобразует From в To, а substituteContra заменяет To в типе на From.

Частично подготовлено Джейсоном Заугом.

Пример A =:= B свидетельствует о том, что типы A и B равны. Он также выступает как A <:< B, но не как B <:< A (непосредственно) из-за ограничений на наследование.

В случае возникновения каких-либо неясностей относительно того, какой метод идёт в каком направлении, все методы "Co" (включая apply) идут слева направо в типе ("с" типом), а все методы "Contra" идут справа налево ("против" типа). Например, apply преобразует From в To, а substituteContra заменяет To в типе на From.

Класс Any является корнем иерархии классов Scala. Каждый класс в среде выполнения Scala наследует непосредственно или косвенно от этого класса.

Начиная с Scala 2.10, возможно прямое расширение Any с помощью универсальных трейтов. Универсальный трейт — это трейт, который расширяет Any, содержит только def и не производит инициализацию.

Основной случай использования универсальных трейтов — это разрешить базовое наследование методов для классов значений. Например,

trait Printable extends Any {
  def print(): Unit = println(this)
}
class Wrapper(val underlying: Int) extends AnyVal with Printable

val w = new Wrapper(3)
w.print()

См. Классы значений и универсальные трейты для получения дополнительной информации о взаимодействии универсальных трейтов и классов значений.

AnyVal — это базовый класс всех типов значений, которые описывают значения, не реализованные как объекты в базовой системе хоста. Классы значений определены в спецификации языка Scala, раздел 12.2.

Стандартная реализация включает девять AnyVal подтипов:

scala.Double, scala.Float, scala.Long, scala.Int, scala.Char, scala.Short и scala.Byte — это числовые типы значений.

scala.Unit и scala.Boolean — это нечисловые типы значений.

Другие группы:

Типы поддиапазона — это scala.Byte, scala.Short и scala.Char. Типы целых чисел включают типы поддиапазона, а также scala.Int и scala.Long. Типы с плавающей запятой — scala.Float и scala.Double.

До Scala 2.10, AnyVal был запечатанным траитом. Однако начиная с Scala 2.10, можно определить подкласс AnyVal, называемый пользовательским классом значений, который обрабатывается компилятором особым образом. Правильно определённые пользовательские классы значений обеспечивают возможность повышения производительности для пользовательских типов, избегая выделения памяти для объекта во время выполнения и заменяя вызовы виртуальных методов вызовами статических методов.

Пользовательские классы значений, которые избегают выделения памяти…

должны иметь единственный val параметр, который является базовым представлением во время выполнения.могут определять def, но не val, var или вложенные traits, class или object.обычно наследуют только от траита AnyVal.не могут использоваться в тестах типов или сопоставления с образцом.не могут переопределять методы equals или hashCode.

Минимальный пример:

class Wrapper(val underlying: Int) extends AnyVal {
  def foo: Wrapper = new Wrapper(underlying * 19)
}

Важно отметить, что пользовательские классы значений ограничены, и в некоторых случаях всё ещё должны выделять память для экземпляра класса значений во время выполнения. Эти ограничения и обстоятельства подробно описаны в Value Classes and Universal Traits.

Траит App может быть использован для быстрого преобразования объектов в исполняемые программы. Вот пример:

object Main extends App {
  Console.println("Hello World: " + (args mkString ", "))
}

Явный метод main не требуется. Вместо этого весь тело класса становится «главным методом».

args возвращает текущие аргументы командной строки в виде массива.

Ограничения

Следует отметить, что этот траит реализован с использованием функциональности DelayedInit, что означает, что поля объекта не будут инициализированы до выполнения главного метода.

Будущие версии этого траита больше не будут наследовать от DelayedInit.

Массивы — это изменяемые, индексированные коллекции значений. Array[T] — представление Scala для T[] Java.

val numbers = Array(1, 2, 3, 4)
val first = numbers(0) // read the first element
numbers(3) = 100 // replace the 4th array element with 100
val biggerNumbers = numbers.map(_ * 2) // multiply all numbers by two

Массивы используют два распространённых элемента синтаксического сахара Scala, показанные в строках 2 и 3 приведённого выше примера кода. Строка 2 преобразуется в вызов apply(Int), а строка 3 преобразуется в вызов update(Int, T).

В scala.Predef существуют два неявных преобразования, которые часто применяются к массивам: преобразование в scala.collection.ArrayOps (показано в строке 4 примера выше) и преобразование в scala.collection.mutable.ArraySeq (подтип scala.collection.Seq). Оба типа предоставляют многие стандартные операции, используемые в API коллекций Scala. Преобразование в ArrayOps временное, поскольку все операции, определённые на ArrayOps возвращают Array, в то время как преобразование в ArraySeq постоянное, поскольку все операции возвращают ArraySeq.

Преобразование в ArrayOps имеет приоритет над преобразованием в ArraySeq. Например, рассмотрите следующий код:

val arr = Array(1, 2, 3)
val arrReversed = arr.reverse
val seqReversed : collection.Seq[Int] = arr.reverse

Значение arrReversed будет типа Array[Int], с неявным преобразованием в ArrayOps для выполнения операции reverse. Значение seqReversed, с другой стороны, будет вычислено путём преобразования в ArraySeq сначала и вызова варианта reverse, который возвращает другой ArraySeq.

Boolean (эквивалент примитивному типу boolean Java) — подтип scala.AnyVal. Экземпляры Boolean не представлены объектом в базовой системе выполнения.

Существует неявное преобразование из scala.Boolean => scala.runtime.RichBoolean, которое предоставляет полезные операции, отличные от примитивных.

Byte, 8-битовое знаковое целое число (эквивалент примитивному типу byte Java) — подтип scala.AnyVal. Экземпляры Byte не представлены объектом в базовой системе выполнения.

Существует неявное преобразование из scala.Byte => scala.runtime.RichByte, которое предоставляет полезные операции, отличные от примитивных.

Char, a 16-bit unsigned integer (equivalent to Java's char primitive type) is a subtype of scala.AnyVal. Instances of Char are not represented by an object in the underlying runtime system.

There is an implicit conversion from scala.Char => scala.runtime.RichChar which provides useful non-primitive operations.

Double, a 64-bit IEEE-754 floating point number (equivalent to Java's double primitive type) is a subtype of scala.AnyVal. Instances of Double are not represented by an object in the underlying runtime system.

There is an implicit conversion from scala.Double => scala.runtime.RichDouble which provides useful non-primitive operations.

A marker trait that enables dynamic invocations. Instances x of this trait allow method invocations x.meth(args) for arbitrary method names meth and argument lists args as well as field accesses x.field for arbitrary field names field.

If a call is not natively supported by x (i.e. if type checking fails), it is rewritten according to the following rules:

foo.method("blah")      ~~> foo.applyDynamic("method")("blah")
foo.method(x = "blah")  ~~> foo.applyDynamicNamed("method")(("x", "blah"))
foo.method(x = 1, 2)    ~~> foo.applyDynamicNamed("method")(("x", 1), ("", 2))
foo.field           ~~> foo.selectDynamic("field")
foo.varia = 10      ~~> foo.updateDynamic("varia")(10)
foo.arr(10) = 13    ~~> foo.selectDynamic("arr").update(10, 13)
foo.arr(10)         ~~> foo.applyDynamic("arr")(10)

As of Scala 2.10, defining direct or indirect subclasses of this trait is only possible if the language feature dynamics is enabled.

Defines a finite set of values specific to the enumeration. Typically these values enumerate all possible forms something can take and provide a lightweight alternative to case classes.

Each call to a Value method adds a new unique value to the enumeration. To be accessible, these values are usually defined as val members of the enumeration.

All values in an enumeration share a common, unique type defined as the Value type member of the enumeration (Value selected on the stable identifier path of the enumeration instance).

Values SHOULD NOT be added to an enumeration after its construction; doing so makes the enumeration thread-unsafe. If values are added to an enumeration from multiple threads (in a non-synchronized fashion) after construction, the behavior of the enumeration is undefined.

An interface containing operations for equality. The only method not already present in class AnyRef is canEqual.

Float, a 32-bit IEEE-754 floating point number (equivalent to Java's float primitive type) is a subtype of scala.AnyVal. Instances of Float are not represented by an object in the underlying runtime system.

There is an implicit conversion from scala.Float => scala.runtime.RichFloat which provides useful non-primitive operations.

A function of 0 parameters.

In the following example, the definition of javaVersion is a shorthand for the anonymous class definition anonfun0:

 object Main extends App {
   val javaVersion = () => sys.props("java.version")

   val anonfun0 = new Function0[String] {
     def apply(): String = sys.props("java.version")
   }
   assert(javaVersion() == anonfun0())
}

A function of 1 parameter.

In the following example, the definition of succ is a shorthand for the anonymous class definition anonfun1:

 object Main extends App {
   val succ = (x: Int) => x + 1
   val anonfun1 = new Function1[Int, Int] {
     def apply(x: Int): Int = x + 1
   }
   assert(succ(0) == anonfun1(0))
}

Note that the difference between Function1 and scala.PartialFunction is that the latter can specify inputs which it will not handle.

Функция с 2 параметрами.

В следующем примере определение max - это сокращенная запись для анонимного определения класса anonfun2:

 object Main extends App {
   val max = (x: Int, y: Int) => if (x < y) y else x

   val anonfun2 = new Function2[Int, Int, Int] {
     def apply(x: Int, y: Int): Int = if (x < y) y else x
   }
   assert(max(0, 1) == anonfun2(0, 1))
}

Целое число Int, 32-битное со знаком (эквивалентно примитивному типу Java int), является подтипом scala.AnyVal. Экземпляры Int не представлены объектом в подлежащей среде выполнения.

Существует неявное преобразование из scala.Int => scala.runtime.RichInt, которое предоставляет полезные операции, отличные от примитивных.

Long, 64-битное знаковое целое число (эквивалентно примитивному типу Java long) — подтип scala.AnyVal.

Экземпляры Long не представлены объектом в подлежащей среде выполнения.

Существует неявное преобразование из scala.Long => scala.runtime.RichLong, предоставляющее полезные операции, не связанные с примитивами.

Этот класс реализует ошибки, которые выбрасываются всякий раз, когда объект не соответствует ни одному шаблону в выражении сопоставления с образцом.

Выбрасывание этого исключения может служить временной заменой тела метода, которое ещё не реализовано. Например, это исключение выбрасывает Predef.???.

Nothing — вместе с scala.Null — находится в основании иерархии типов Scala.

Nothing является подтипом любого другого типа (включая scala.Null); экземпляров этого типа не существует. Хотя тип Nothing необитаем, он тем не менее полезен в нескольких случаях. Например, в библиотеке Scala определена константа scala.collection.immutable.Nil типа List[Nothing]. Поскольку списки в Scala ковариантны, это делает scala.collection.immutable.Nil экземпляром List[T], для любого элемента типа T.

Ещё одно применение типа Nothing — это тип возвращаемого значения для методов, которые никогда не возвращают значения обычным образом. Примером является метод error в scala.sys, который всегда выбрасывает исключение.

Null — вместе с scala.Nothing — находится в основании иерархии типов Scala.

Null является подтипом всех ссылочных типов; его единственным экземпляром является ссылка null. Поскольку Null не является подтипом типов значений, null не является членом ни одного такого типа. Например, нельзя присвоить null переменной типа scala.Int.

Представляет необязательные значения. Экземпляры Option являются либо экземпляром scala.Some, либо объектом None.

Наиболее распространенный способ использования экземпляра scala.Option — это рассматривать его как коллекцию или монаду и использовать map, flatMap, filter, или foreach:

val name: Option[String] = request getParameter "name"
val upper = name map { _.trim } filter { _.length != 0 } map { _.toUpperCase }
println(upper getOrElse "")

Обратите внимание, что это эквивалентно

val upper = for {
  name <- request getParameter "name"
  trimmed <- Some(name.trim)
  upper <- Some(trimmed.toUpperCase) if trimmed.length != 0
} yield upper
println(upper getOrElse "")

Из-за того, как работает понимание for, если None возвращается из request.getParameter, все выражение приведёт к None

Это позволяет создавать сложные цепочки значений scala.Option без необходимости проверки существования значения.

Эти полезные методы существуют как для scala.Some, так и для None.

isDefined — Истина, если не пусто isEmpty — Истина, если пусто nonEmpty — Истина, если не пусто orElse — Оценить и вернуть альтернативное необязательное значение, если пусто getOrElse — Оценить и вернуть альтернативное значение, если пусто get — Возвратить значение, выбросить исключение, если пусто fold — Применить функцию к необязательному значению, вернуть значение по умолчанию, если пусто map — Применить функцию к необязательному значению flatMap — То же, что и map, но функция должна возвращать необязательное значение foreach — Применить процедуру к значению Option collect — Применить частичное сопоставление шаблонов к необязательному значению filter — Значение Option удовлетворяет предикату filterNot — Значение Option не удовлетворяет предикату exists — Применить предикат к значению Option, иначе возвращает false, если пусто forall — Применить предикат к значению Option, иначе возвращает true, если пусто contains — Проверяет, равно ли значение значению Option, иначе возвращает false, если пусто zip — Объединить два необязательных значения для создания парного необязательного значения unzip — Разделить пару Option на два необязательных значения unzip3 — Разделить тройку Option на три необязательных значения toList — Одноэлементный список необязательного значения, в противном случае пустой список

Менее распространенный способ использования значений scala.Option — через сопоставление шаблонов:

val nameMaybe = request getParameter "name"
nameMaybe match {
  case Some(name) =>
    println(name.trim.toUppercase)
  case None =>
    println("No name value")
}

Взаимодействие с кодом, который иногда может возвращать null, безопасно оборачивается в scala.Option, чтобы стать None, а иначе scala.Some.

val abc = new java.util.HashMap[Int, String]
abc.put(1, "A")
bMaybe = Option(abc.get(2))
bMaybe match {
  case Some(b) =>
    println(s"Found $b")
  case None =>
    println("Not found")
}

Частичная функция типа PartialFunction[A, B] — это унарная функция, где область значений не обязательно включает все значения типа A. Функция isDefinedAt позволяет динамически проверить, находится ли значение в области значений функции.

Даже если isDefinedAt возвращает true для a: A, вызов apply(a) всё ещё может выбросить исключение, поэтому следующий код допустим:

val f: PartialFunction[Int, Any] = { case _ => 1/0 }

Ответственность за вызов isDefinedAt перед вызовом apply лежит на вызывающей стороне, потому что если isDefinedAt ложно, то не гарантируется, что apply выбросит исключение для указания состояния ошибки. Если исключение не выброшено, оценка может привести к произвольному значению.

Основное отличие между PartialFunction и scala.Function1 заключается в том, что пользователь PartialFunction может выбрать выполнение других действий с вводом, который объявлен вне его области определения. Например:

val sample = 1 to 10
val isEven: PartialFunction[Int, String] = {
  case x if x % 2 == 0 => x+" is even"
}

// the method collect can use isDefinedAt to select which members to collect
val evenNumbers = sample collect isEven

val isOdd: PartialFunction[Int, String] = {
  case x if x % 2 == 1 => x+" is odd"
}

// the method orElse allows chaining another partial function to handle
// input outside the declared domain
val numbers = sample map (isEven orElse isOdd)

Базовый трейт для всех продуктов, которые в стандартной библиотеке включают по крайней мере scala.Product1 до scala.Product22 и, следовательно, также их подклассы scala.Tuple1 до scala.Tuple22. Кроме того, все case-классы реализуют Product с синтетически генерируемыми методами.

Product1 is a Cartesian product of 1 component.

Product10 is a Cartesian product of 10 components.

Product11 is a Cartesian product of 11 components.

Product12 is a Cartesian product of 12 components.

Product13 is a Cartesian product of 13 components.

Product14 is a Cartesian product of 14 components.

Product15 is a Cartesian product of 15 components.

Product16 is a Cartesian product of 16 components.

Product17 is a Cartesian product of 17 components.

Product18 is a Cartesian product of 18 components.

Product19 is a Cartesian product of 19 components.

Product2 — это декартово произведение 2 компонентов.

Product20 — это декартово произведение 20 компонентов.

Product21 — это декартово произведение 21 компонента.

Product22 — это декартово произведение 22 компонентов.

Product3 — это декартово произведение 3 компонентов.

Product4 — это декартово произведение 4 компонентов.

Product5 — это декартово произведение 5 компонентов.

Product6 — это декартово произведение 6 компонентов.

Product7 — это декартово произведение 7 компонентов.

Product8 — это декартово произведение 8 компонентов.

Product9 — это декартово произведение 9 компонентов.

Аннотация для указания поля serialVersionUID (сериализуемого) класса.

В JVM, класс с этой аннотацией получит поле serialVersionUID, private, и static, названное serialVersionUID, со значением, указанным в value, которое механизм сериализации JVM использует для определения совместимости сериализации между различными версиями класса.

Short, 16-битное знаковое целое число (эквивалентный примитивному типу short Java) является подтипом scala.AnyVal. Экземпляры Short не представлены объектом в базовой системе времени выполнения.

Существует неявное преобразование из scala.Short => scala.runtime.RichShort, которое предоставляет полезные не-примитивные операции.

Singleton используется компилятором в качестве супертипа для одиночных типов. Это включает в себя литеральные типы, так как они также являются одиночными типами.

scala> object A { val x = 42 }
defined object A

scala> implicitly[A.type <:< Singleton]
res12: A.type <:< Singleton = generalized constraint

scala> implicitly[A.x.type <:< Singleton]
res13: A.x.type <:< Singleton = generalized constraint

scala> implicitly[42 <:< Singleton]
res14: 42 <:< Singleton = generalized constraint

scala> implicitly[Int <:< Singleton]
^
error: Cannot prove that Int <:< Singleton.

Singleton имеет специальное значение, когда появляется в качестве верхнего ограничения формального параметра типа. Обычно, вывод типов в Scala расширяет одиночные типы до базового не-одиночного типа. Когда параметр типа имеет явное верхнее ограничение Singleton, компилятор выводит одиночный тип.

scala> def check42[T](x: T)(implicit ev: T =:= 42): T = x
check42: [T](x: T)(implicit ev: T =:= 42)T

scala> val x1 = check42(42)
^
error: Cannot prove that Int =:= 42.

scala> def singleCheck42[T <: Singleton](x: T)(implicit ev: T =:= 42): T = x
singleCheck42: [T <: Singleton](x: T)(implicit ev: T =:= 42)T

scala> val x2 = singleCheck42(42)
x2: Int = 42

См. также SIP-23 о литеральных одиночных типах.

Класс Some[A] представляет существующие значения типа A.

Общий супертип для компаньонов специализируемых типов. Не следует расширять в пользовательском коде.

Этот класс предоставляет базовый механизм для интерполяции строк. Интерполяция строк позволяет пользователям встраивать ссылки на переменные непосредственно в *обработанные* строковые литералы. Вот пример:

val name = "James"
println(s"Hello, $name")  // Hello, James

Любой обработанный строковый литерал переписывается как создание экземпляра и вызов метода этого класса. Например:

s"Hello, $name"

переписывается как:

StringContext("Hello, ", "").s(name)

По умолчанию, этот класс предоставляет методы raw, s и f в качестве доступных интерполяторов.

Чтобы предоставить свой собственный интерполятор строк, создайте неявный класс, который добавляет метод к StringContext. Вот пример:

implicit class JsonHelper(private val sc: StringContext) extends AnyVal {
  def json(args: Any*): JSONObject = ...
}
val x: JSONObject = json"{ a: $a }"

Здесь класс расширения JsonHelper неявно добавляет метод json к StringContext, который может использоваться для json строковых литералов.

Этот класс предоставляет простой способ получения уникальных объектов для равных строк. Поскольку символы интернированы, их можно сравнивать с помощью равенства ссылок. Экземпляры Symbol могут быть легко созданы с помощью встроенного механизма цитирования Scala.

Например, терм Scala 'mysym вызовет конструктор класса Symbol следующим образом: Symbol("mysym").

Кортеж из 1 элемента; каноническое представление scala.Product1.

Кортеж из 10 элементов; каноническое представление scala.Product10.

Кортеж из 11 элементов; каноническое представление scala.Product11.

Кортеж из 12 элементов; каноническое представление scala.Product12.

Кортеж из 13 элементов; каноническое представление scala.Product13.

Кортеж из 14 элементов; каноническое представление scala.Product14.

Кортеж из 15 элементов; каноническое представление scala.Product15.

Кортеж из 16 элементов; каноническое представление scala.Product16.

Кортеж из 17 элементов; каноническое представление scala.Product17.

Кортеж из 18 элементов; каноническое представление scala.Product18.

Кортеж из 19 элементов; каноническое представление scala.Product19.

Кортеж из 2 элементов; каноническое представление scala.Product2.

Кортеж из 20 элементов; каноническое представление scala.Product20.

Кортеж из 21 элемента; каноническое представление scala.Product21.

Кортеж из 22 элементов; каноническое представление scala.Product22.

Кортеж из 3 элементов; каноническое представление scala.Product3.

Кортеж из 4 элементов; каноническое представление scala.Product4.

Кортеж из 5 элементов; каноническое представление scala.Product5.

Кортеж из 6 элементов; каноническое представление scala.Product6.

Кортеж из 7 элементов; каноническое представление scala.Product7.

Кортеж из 8 элементов; каноническое представление scala.Product8.

Кортеж из 9 элементов; каноническое представление scala.Product9.

Этот класс реализует ошибки, которые выбрасываются всякий раз, когда поле используется до его инициализации.

Такие проверки во время выполнения не включаются по умолчанию. Их можно включить с помощью опции компилятора -Xcheckinit.

Unit является подтипом scala.AnyVal. Существует только одно значение типа Unit, (), и оно не представлено каким-либо объектом в базовой среде выполнения. Метод с типом возвращаемого значения Unit аналогичен методу Java, который объявлен void.

ValueOf[T] предоставляет единственное значение типа T, где T — тип, имеющий единственного представителя. Квалифицируемые типы — это одиночные типы вида stablePath.type, Unit и одиночные типы, соответствующие литералам значений.

Экземпляры ValueOf[T] предоставляются неявно для всех допустимых типов. Обычно экземпляр требуется, когда необходимо значение времени выполнения, соответствующее вычислению на уровне типов.

Например, мы можем определить тип Residue[M <: Int], соответствующий группе целых чисел по модулю M. Мы можем затем потребовать, чтобы остатки могли суммироваться только тогда, когда они параметризованы одним и тем же модулем,

case class Residue[M <: Int](n: Int) extends AnyVal {
  def +(rhs: Residue[M])(implicit m: ValueOf[M]): Residue[M] =
    Residue((this.n + rhs.n) % valueOf[M])
}

val fiveModTen = Residue[10](5)
val nineModTen = Residue[10](9)

fiveModTen + nineModTen    // OK == Residue[10](4)

val fourModEleven = Residue[11](4)

fiveModTen + fourModEleven // compiler error: type mismatch;
                           //   found   : Residue[11]
                           //   required: Residue[10]

Обратите внимание, что здесь модуль закодирован в типе значений, поэтому не требует дополнительных затрат на хранение для каждого значения. Когда в реализации + требуется значение времени выполнения модуля, оно предоставляется в месте вызова с помощью неявного аргумента m типа ValueOf[M].

Аннотация, которая указывает, что определение устарело. При использовании аннотированного определения выводится предупреждение об устаревании.

Авторы библиотек должны указать политику устаревания своей библиотеки в документации, чтобы дать разработчикам руководство по тому, как долго будет сохраняться устаревшее определение.

Авторы библиотек должны преобразовывать имя своей библиотеки с номером версии, чтобы помочь разработчикам различать устаревшие определения, поступающие из разных библиотек:

@deprecated("this method will be removed", "FooLib 12.0")
def oldMethod(x: Int) = ...

Компилятор будет выводить предупреждения об устаревании, сгруппированные по библиотеке и версии:

oldMethod(1)
oldMethod(2)
aDeprecatedMethodFromLibraryBar(3, 4)

// warning: there was one deprecation warning (since BarLib 3.2)
// warning: there were two deprecation warnings (since FooLib 12.0)
// warning: there were three deprecation warnings in total; re-run with -deprecation for details

@deprecated в языке Scala и его стандартной библиотеке

Устаревшее элемент языка Scala или определение в стандартной библиотеке Scala будет сохраняться по крайней мере на протяжении текущей основной версии.

Это означает, что элемент, устаревший в каком-то релизе 2.13.x, будет сохраняться во всех релизах 2.13.x, но может быть удален в 2.14. (Устаревший элемент может сохраняться дольше для упрощения миграции, но разработчики не должны полагаться на это.)

Аннотация, которая указывает, что наследование от класса устарело.

Это обычно делается для предупреждения о том, что нефинальный класс будет сделать финальным в будущей версии. Наследование от такого класса генерирует предупреждение.

Предупреждения не генерируются, если подкласс находится в одном файле компиляции.

Авторы библиотек должны указать политику устаревания своей библиотеки в документации, чтобы дать разработчикам руководство по тому, когда тип, помеченный аннотацией @deprecatedInheritance, будет final.

Авторы библиотек должны преобразовывать имя своей библиотеки с номером версии, чтобы помочь разработчикам различать устаревшие определения, поступающие из разных библиотек:

@deprecatedInheritance("this class will be made final", "FooLib 12.0")
class Foo

val foo = new Foo     // no deprecation warning
class Bar extends Foo
// warning: inheritance from class Foo is deprecated (since FooLib 12.0): this class will be made final
// class Bar extends Foo
//                   ^

Аннотация, обозначающая, что имя параметра устарело.

Использование этого имени в именованном аргументе генерирует предупреждение об устаревании.

Авторы библиотек должны указывать политику устаревания библиотеки в своей документации, чтобы дать разработчикам рекомендации о том, как долго будет сохраняться устаревшее имя.

Авторы библиотек должны добавлять имя своей библиотеки к номеру версии, чтобы помочь разработчикам отличать устаревания, поступающие из разных библиотек:

def inc(x: Int, @deprecatedName("y", "FooLib 12.0") n: Int): Int = x + n
inc(1, y = 2)

выдаст следующее предупреждение:

warning: the parameter name y is deprecated (since FooLib 12.0): use n instead
inc(1, y = 2)
         ^

Аннотация, обозначающая, что переопределение члена устарело.

Переопределение такого члена в подклассе затем генерирует предупреждение.

Авторы библиотек должны указывать политику устаревания библиотеки в своей документации, чтобы дать разработчикам рекомендации о том, когда метод, помеченный @deprecatedOverriding, будет final.

Авторы библиотек должны добавлять имя своей библиотеки к номеру версии, чтобы помочь разработчикам отличать устаревания, поступающие из разных библиотек:

class Foo {
  @deprecatedOverriding("this method will be made final", "FooLib 12.0")
  def add(x: Int, y: Int) = x + y
}

class Bar extends Foo // no deprecation warning
class Baz extends Foo {
  override def add(x: Int, y: Int) = x - y
}
// warning: overriding method add in class Foo is deprecated (since FooLib 12.0): this method will be made final
// override def add(x: Int, y: Int) = x - y
//              ^

Аннотация для методов, которые оптимизатор должен встраивать.

Обратите внимание, что по умолчанию оптимизатор Scala отключен и никакие вызовы не встраиваются. См. -opt:help для информации о том, как включить оптимизатор и встраиватель.

Когда встраивание включено, встраиватель всегда будет пытаться встраивать методы или вызовы, помеченные @inline (при условии, что встраивание из определяющего класса разрешено, см. -opt-inline-from:help). Если встраивание невозможно, например, потому что метод не является окончательным, будет выдано предупреждение оптимизатора. См. -opt-warnings:help для подробностей.

Примеры:

@inline   final def f1(x: Int) = x
@noinline final def f2(x: Int) = x
          final def f3(x: Int) = x

 def t1 = f1(1)              // inlined if possible
 def t2 = f2(1)              // not inlined
 def t3 = f3(1)              // may be inlined (the inliner heuristics can select the callsite)
 def t4 = f1(1): @noinline   // not inlined (override at callsite)
 def t5 = f2(1): @inline     // inlined if possible (override at callsite)
 def t6 = f3(1): @inline     // inlined if possible
 def t7 = f3(1): @noinline   // not inlined
}

Примечание: скобки необходимы при аннотировании вызова в более сложном выражении.

def t1 = f1(1) + f1(1): @noinline   // equivalent to (f1(1) + f1(1)): @noinline
def t2 = f1(1) + (f1(1): @noinline) // the second call to f1 is not inlined

Маркер для нативных методов.

@native def f(x: Int, y: List[Long]): String = ...

Метод @native компилируется в нативный метод платформы, при этом отбрасывается тело метода (если оно есть). Тело будет проверено на соответствие типу, если оно присутствует.

Метод, помеченный @native, должен быть членом класса, а не трейта (начиная с 2.12).

Аннотация для методов, которые оптимизатор не должен встраивать.

Обратите внимание, что по умолчанию оптимизатор Scala отключен и никакие вызовы не встраиваются. См. -opt:help для информации о том, как включить оптимизатор и встраиватель.

Когда встраивание включено, встраиватель никогда не будет встраивать методы или вызовы, помеченные @noinline.

Примеры:

@inline   final def f1(x: Int) = x
@noinline final def f2(x: Int) = x
          final def f3(x: Int) = x

 def t1 = f1(1)              // inlined if possible
 def t2 = f2(1)              // not inlined
 def t3 = f3(1)              // may be inlined (the inliner heuristics can select the callsite)
 def t4 = f1(1): @noinline   // not inlined (override at callsite)
 def t5 = f2(1): @inline     // inlined if possible (override at callsite)
 def t6 = f3(1): @inline     // inlined if possible
 def t7 = f3(1): @noinline   // not inlined
}

Примечание: скобки необходимы при аннотировании вызова в более сложном выражении.

def t1 = f1(1) + f1(1): @noinline   // equivalent to (f1(1) + f1(1)): @noinline
def t2 = f1(1) + (f1(1): @noinline) // the second call to f1 is not inlined

Аннотировать параметры типа, на которых код должен быть автоматически специализирован. Например:

class MyList[@specialized T] ...

Тип T может быть специализирован на подмножестве примитивных типов, указав список примитивных типов для специализации:

class MyList[@specialized(Int, Double, Boolean) T] ..

Аннотация для указания исключений, выбрасываемых методом. Например:

class Reader(fname: String) {
  private val in = new BufferedReader(new FileReader(fname))
  @throws[IOException]("if the file doesn't exist")
  def read() = in.read()
}

Аннотация, обозначающая, что анотированный элемент не должен рассматриваться для дополнительных проверок компилятором. Конкретные применения включают аннотирование объекта выражения сопоставления для подавления предупреждений об исчерпываемости и аннотирование аргумента типа в случае сопоставления для подавления предупреждений об unchecked ошибках.

Такое подавление следует использовать с осторожностью, без него могут возникнуть scala.MatchError или java.lang.ClassCastException во время выполнения. В большинстве случаев можно и следует устранить предупреждение вместо его подавления.

object Test extends App {
  // This would normally warn "match is not exhaustive"
  // because `None` is not covered.
  def f(x: Option[String]) = (x: @unchecked) match { case Some(y) => y }
  // This would normally warn "type pattern is unchecked"
  // but here will blindly cast the head element to String.
  def g(xs: Any) = xs match { case x: List[String @unchecked] => x.head }
}