Пакет scala

Класс 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)
}

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

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

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

Здесь объект Main наследует метод main от App.

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

Примечания

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

Также следует отметить, что метод main не должен переопределяться: всё тело класса становится «методом main».

В будущих версиях этот трейт не будет больше расширять 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.mutable.ArrayOps (показано на строке 4 примера выше) и преобразование в scala.collection.mutable.WrappedArray (подтип scala.collection.Seq). Оба типа предоставляют множество стандартных операций, присутствующих в API коллекций Scala. Преобразование в ArrayOps временное, так как все операции, определённые на ArrayOps, возвращают Array, в то время как преобразование в WrappedArray постоянное, так как все операции возвращают WrappedArray.

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

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

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

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

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

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

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

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

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

Double, 64-битовое число с плавающей точкой IEEE-754 (эквивалентно примитивному типу Java double) является подтипом scala.AnyVal. Экземпляры Double не представлены объектом в базовой системе выполнения.

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

Маркерный трайт, который позволяет динамические вызовы. Экземпляры x этого трайта позволяют вызовы методов x.meth(args) для произвольных имён методов meth и списков аргументов args, а также доступ к полям x.field для произвольных имён полей field.

Если вызов не поддерживается напрямую x (т.е. если проверка типа не проходит), он переписывается в соответствии со следующими правилами:

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)

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

Определяет конечный набор значений, специфичный для перечисления. Обычно эти значения перечисляют все возможные формы чего-либо и предоставляют легкую альтернативу классам case.

Каждый вызов метода Value добавляет новое уникальное значение в перечисление. Для доступа эти значения обычно определяются как val члены вычисления.

Все значения в перечислении имеют общий, уникальный тип, определенный как Value тип-член перечисления (Value выбранный по стабильному идентификатору пути экземпляра перечисления).

Значения НЕ ДОЛЖНЫ добавляться в перечисление после его создания; это делает перечисление небезопасным для потоков. Если значения добавляются в перечисление из нескольких потоков (несинхронизированным образом) после создания, поведение перечисления не определено.

Интерфейс, содержащий операции для равенства. Единственный метод, отсутствующий в классе AnyRef, это canEqual.

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

Float, 32-битовое число с плавающей точкой IEEE-754 (эквивалентно примитивному типу Java float) является подтипом scala.AnyVal. Экземпляры Float не представлены объектом в базовой системе выполнения.

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

Функция без параметров.

В следующем примере, определение javaVersion является сокращением для определения анонимного класса 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())
}

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

В следующем примере, определение succ является сокращением для определения анонимного класса 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))
}

Обратите внимание на разницу между Function1 и scala.PartialFunction, последняя может указывать входные данные, с которыми она не будет работать.

Функция с 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's 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. Это подтип каждого типа, кроме типов значений.

Типы значений являются подклассами AnyVal, которые включают примитивные типы, такие как Int, Boolean и определенные пользователем типы значений.

Поскольку 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 — True, если не пусто isEmpty — True, если пусто nonEmpty — True, если не пусто orElse — Оценивает и возвращает альтернативное необязательное значение, если пусто getOrElse — Оценивает и возвращает альтернативное значение, если пусто get — Возвращает значение, выбрасывает исключение, если пусто fold — Применяет функцию к необязательному значению, возвращает значение по умолчанию, если пусто map — Применяет функцию к необязательному значению flatMap — То же, что и map, но функция должна возвращать необязательное значение foreach — Применяет процедуру к значению опциона collect — Применяет частичное сопоставление шаблонов к необязательному значению filter — Необязательное значение удовлетворяет предикату filterNot — Необязательное значение не удовлетворяет предикату exists — Применяет предикат к необязательному значению или возвращает false, если пусто forall — Применяет предикат к необязательному значению или возвращает true, если пусто contains — Проверяет, равно ли значение необязательному значению, или возвращает false, если пусто 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 — это декартово произведение из 1 компонента.

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

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

Product12 представляет собой декартово произведение 12 компонентов.

Product13 представляет собой декартово произведение 13 компонентов.

Product14 представляет собой декартово произведение 14 компонентов.

Product15 представляет собой декартово произведение 15 компонентов.

Product16 представляет собой декартово произведение 16 компонентов.

Product17 представляет собой декартово произведение 17 компонентов.

Product18 представляет собой декартово произведение 18 компонентов.

Product19 представляет собой декартово произведение 19 компонентов.

Product2 представляет собой декартово произведение 2 компонентов.

Product20 представляет собой декартово произведение 20 компонентов.

Product21 представляет собой декартово произведение 21 компонента.

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

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

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

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

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

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

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

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

Этот класс реализует простой прокси, который перенаправляет все вызовы к открытым, не финальным методам, определенным в классе Any, другому объекту self.

def hashCode(): Int
def equals(other: Any): Boolean
def toString(): String

Примечание: перенаправление методов таким способом, скорее всего, создаст асимметричный метод equals, что, как правило, не рекомендуется.

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

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

Класс 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.

Кортеж из 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.

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

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

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

@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.12.x, будет сохранен во всех версиях 2.12.x, но может быть удален в 2.13. (Устаревший элемент может храниться дольше для облегчения миграции. Разработчики не должны полагаться на это.)

Специальная политика устарелости для Scala 2.12
Команда Scala приняла специальную политику устарелости для Scala 2.12:

Поскольку обновление с 2.11 до 2.12 также требует обновления с Java 6 до Java 8, устаревшие элементы обычно не будут удалены в этом выпуске, чтобы облегчить миграцию и кросс-компиляцию.

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

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

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

Авторы библиотек должны указать политику устаревания своей библиотеки в своей документации, чтобы дать разработчикам руководство по тому, когда тип, аннотированный с @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
//              ^

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

@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 (heuristics)
 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).

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

@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 (heuristics)
 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()
}

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

Такое подавление должно использоваться с осторожностью, в противном случае могут возникнуть 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 }
}

Классы и объекты (но не тракты), наследующие DelayedInit маркерный тракт, будут иметь свой код инициализации переписанный следующим образом: code становится delayedInit(code).

Код инициализации включает все операторы и все определения значений, которые выполняются во время инициализации.

Пример:

trait Helper extends DelayedInit {
  def delayedInit(body: => Unit) = {
    println("dummy text, printed before initialization of C")
    body // evaluates the initialization code of C
  }
}

class C extends Helper {
  println("this is the initialization code of C")
}

object Test extends App {
  val c = new C
}

Должно привести к следующему выводу:

dummy text, printed before initialization of C
this is the initialization code of C

Маркерный тракт для элементов, которые не могут быть null

Экземпляры responder — это строительные блоки небольших программ, написанных в стиле передачи продолжения. Используя классы responder в for-циклах, можно встраивать языки предметной области в Scala, при этом программы в этих DSL кажутся написанными в прямом стиле.

Этот класс представляет ошибки неинициализированных переменных/значений.

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

Например, код Scala

@remote trait Hello {
  def sayHello(): String
}

эквивалентен следующему коду Java:

public interface Hello extends java.rmi.Remote {
    String sayHello() throws java.rmi.RemoteException;
}