Пакет scala.scala

пакет scala

Основные типы Scala. Они всегда доступны без явного импорта.

Классы

Исходный код

объект #::

Исходный код@showAsInfix

абстрактный запечатанный класс *:[+H, +T <: Tuple] extends NonEmptyTuple

Исходный код

объект *:

Исходный код@implicitNotFound(msg = "Cannot prove that ${From} <:>

абстрактный запечатанный класс <:<[-From, +To] extends From => To with Serializable

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

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

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

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

sealed trait Option[+A] {
  // def flatten[B, A <: Option[B]]: Option[B] = ...
  // won't work, since the A in flatten shadows the class-scoped A.
  def flatten[B](implicit ev: A <:< Option[B]): Option[B]
    = if(isEmpty) None else ev(get)
  // Because (A <:< Option[B]) <: (A => Option[B]), ev can be called to turn the
  // A from get into an Option[B], and because ev is implicit, that call can be
  // left out and inserted automatically.
}

Исходный код

объект <:<

Исходный код@implicitNotFound(msg = "Cannot prove that ${From} =:= ${To}.")

абстрактный запечатанный класс =:=[From, To] extends From <:< To with Serializable

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

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

implicit class BufOps[A](private val buf: ArrayBuffer[A]) extends AnyVal {
  def inPlaceTranspose[E]()(implicit ev: A =:= ArrayBuffer[E]) = ???
  // Because ArrayBuffer is invariant, we can't make do with just a A <:< ArrayBuffer[E]
  // Getting buffers *out* from buf would work, but adding them back *in* wouldn't.
}

абстрактный открытый класс Any

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

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

окончательный абстрактный класс AnyKind

Супертип всех типов.

См. https://dotty.epfl.ch/docs/reference/other-new-features/kind-polymorphism.html.

класс AnyRef

Класс AnyRef — это корневой класс всех ссылочных типов. Все типы, кроме типов значений, наследуются от этого класса.

абстрактный открытый класс AnyVal

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

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

Исходный код@nowarn("cat=deprecation&origin=scala\\.DelayedInit")

трейт App extends DelayedInit

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

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

Нет необходимости в явном методе main. Вместо этого всё тело класса становится «главным методом».

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

Ограничения

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

В будущих версиях этот трейт больше не будет расширять DelayedInit.

Исходный код

объект Array

Вспомогательные методы для работы с массивами. Например:

val a = Array(1, 2)
val b = Array.ofDim[Int](2)
val c = Array.concat(a, b)

где объекты массива a, b и c имеют соответственно значения Array(1, 2), Array(0, 0) и Array(1, 2, 0, 0).

Источник

final class Массив[T](_length: Int) extends Serializable with Cloneable

Массивы — это изменяемые, индексированные коллекции значений. 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.

Источник

final abstract class Булево extends AnyVal

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

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

Источник

объект Boolean

Источник

final abstract class Байт extends AnyVal

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

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

Источник

объект Байт

Источник@implicitNotFound("Значения типов ${L} и ${R} нельзя сравнивать с == или !=")

запечатанный тракт CanEqual[-L, -R]

Маркерный тракт, указывающий, что значения типа L могут быть сравнены со значениями типа R.

Источник

объект CanEqual

Объект-компаньон, содержащий несколько общеизвестных CanEqual экземпляров. Экземпляры CanEqual, связанные с примитивными типами или типом Null, обрабатываются непосредственно в компиляторе (см. Implicits.synthesizedCanEqual), поэтому они здесь не включены.

Источник@experimental @implicitNotFound("Отсутствует возможность выбрасывания исключения ${E}.\nВозможность может быть предоставлена одним из следующих способов:\n - Добавление предложения using `(using CanThrow[${E}])` в определение метода\n - Добавление предложения `throws ${E}` после типа результата метода\n - Обертка этого фрагмента кода в блок `try`, который перехватывает ${E}")

стираемый класс CanThrow[-E <: Исключение]

Класс возможностей, который позволяет выбрасывать исключение E. При использовании функции experimental.saferExceptions выражение throw Ex() потребует наличия класса CanThrow[Ex].

Источник

final abstract class Символ extends AnyVal

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

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

Источник

объект Символ

Источник

объект Консоль extends AnsiColor

Реализует функциональность вывода значений Scala на терминал. Для чтения значений используйте StdIn. Также определяет константы для разметки текста на терминалах с поддержкой ANSI.

Вывод консоли

Используйте методы print для вывода текста.

scala> Console.printf(
  "Today the outside temperature is a balmy %.1f°C. %<.1f°C beats the previous record of %.1f°C.\n",
  -137.0,
  -135.05)
Today the outside temperature is a balmy -137.0°C. -137.0°C beats the previous record of -135.1°C.

Коды ANSI

Используйте коды ANSI для раскрашивания вывода консоли в STDOUT или STDERR.

import Console.{GREEN, RED, RESET, YELLOW_B, UNDERLINED}

object PrimeTest {

  def isPrime(): Unit = {

    val candidate = io.StdIn.readInt().ensuring(_ > 1)

    val prime = (2 to candidate - 1).forall(candidate % _ != 0)

    if (prime)
      Console.println(s"${RESET}${GREEN}yes${RESET}")
    else
      Console.err.println(s"${RESET}${YELLOW_B}${RED}${UNDERLINED}NO!${RESET}")
  }

  def main(args: Array[String]): Unit = isPrime()

}

Переопределение ввода-вывода

Используйте переопределение ввода-вывода для временной замены набора потоков ввода и/или вывода. В данном примере метод, основанный на потоках, обернут в функцию.

import java.io.{ByteArrayOutputStream, StringReader}

object FunctionalPrimeTest {

  def isPrime(candidate: Int): Boolean = {

    val input = new StringReader(s"$candidate\n")
    val outCapture = new ByteArrayOutputStream
    val errCapture = new ByteArrayOutputStream

    Console.withIn(input) {
      Console.withOut(outCapture) {
        Console.withErr(errCapture) {
          PrimeTest.isPrime()
        }
      }
    }

    if (outCapture.toByteArray.nonEmpty) // "yes"
      true
    else if (errCapture.toByteArray.nonEmpty) // "NO!"
      false
    else throw new IllegalArgumentException(candidate.toString)
  }

  def main(args: Array[String]): Unit = {
    val primes = (2 to 50) filter (isPrime)
    println(s"First primes: $primes")
  }

}

Источник@FunctionalInterface

абстрактный класс Преобразование[-T, +U] extends T => U

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

def $implicitConversion[T, U](x: T)(c: Conversion[T, U]): U = c(x)

Однако, наличие этого определения замедлило бы поиск неявных значений, поскольку его внешний тип соответствует любой паре типов. Поэтому поиск неявных значений содержит специальный случай в Implicits#discardForView, который эмулирует преобразование более эффективным способом.

Обратите внимание, что это класс SAM — лямбда-выражения автоматически преобразуются в значения Conversion.

Также обратите внимание, что в загрузчике dotty Predef.<:< должен наследоваться от Conversion Это сократило бы количество специальных случаев в discardForView с двух до одного.

Класс Conversion также может использоваться для явного преобразования с помощью расширяющего метода convert.

Источник

final abstract class Double extends AnyVal

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

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

Источник

object Double

Источник

final class DummyImplicit

Тип, для которого всегда существует неявное значение.

Источник

object DummyImplicit

Источник

trait Dynamic

Маркерный интерфейс, который позволяет выполнять динамические вызовы. Экземпляры 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.

Источник

object EmptyTuple extends Tuple

Кортеж из 0 элементов.

Источник@SerialVersionUID(8476000850333817230L)

abstract class Enumeration(initial: Int) extends Serializable

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

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

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

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

// Define a new enumeration with a type alias and work with the full set of enumerated values
object WeekDay extends Enumeration {
 type WeekDay = Value
 val Mon, Tue, Wed, Thu, Fri, Sat, Sun = Value
}
import WeekDay._
def isWorkingDay(d: WeekDay) = ! (d == Sat || d == Sun)
WeekDay.values filter isWorkingDay foreach println
// output:
// Mon
// Tue
// Wed
// Thu
// Fri

// Example of adding attributes to an enumeration by extending the Enumeration.Val class
object Planet extends Enumeration {
 protected case class PlanetVal(mass: Double, radius: Double) extends super.Val {
   def surfaceGravity: Double = Planet.G * mass / (radius * radius)
   def surfaceWeight(otherMass: Double): Double = otherMass * surfaceGravity
 }
 import scala.language.implicitConversions
 implicit def valueToPlanetVal(x: Value): PlanetVal = x.asInstanceOf[PlanetVal]
 val G: Double = 6.67300E-11
 val Mercury = PlanetVal(3.303e+23, 2.4397e6)
 val Venus   = PlanetVal(4.869e+24, 6.0518e6)
 val Earth   = PlanetVal(5.976e+24, 6.37814e6)
 val Mars    = PlanetVal(6.421e+23, 3.3972e6)
 val Jupiter = PlanetVal(1.9e+27, 7.1492e7)
 val Saturn  = PlanetVal(5.688e+26, 6.0268e7)
 val Uranus  = PlanetVal(8.686e+25, 2.5559e7)
 val Neptune = PlanetVal(1.024e+26, 2.4746e7)
}
println(Planet.values.filter(_.radius > 7.0e6))
// output:
// Planet.ValueSet(Jupiter, Saturn, Uranus, Neptune)

Источник

trait Equals

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

Источник

final abstract class Float extends AnyVal

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

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

Источник

object Float

Источник

object Function

Модуль, определяющий вспомогательные методы для функционального программирования высшего порядка.

Источник

trait Function0[@specialized +R] extends AnyRef

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

В следующем примере, определение 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())
}

Источник

object Function1

Источник@implicitNotFound(msg = "No implicit view available from ${T1} => ${R}.")

trait Function1[@specialized -T1, @specialized +R] extends AnyRef

Функция с 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: последняя может указывать входы, для которых она не будет обрабатывать.

Источник

trait Function10[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, +R] extends AnyRef

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

Источник

trait Function11[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, +R] extends AnyRef

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

Источник

trait Function12[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, +R] extends AnyRef

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

Источник

trait Function13[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, +R] extends AnyRef

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

Источник

trait Function14[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, +R] extends AnyRef

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

Источник

trait Function15[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, -T15, +R] extends AnyRef

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

Источник

trait Function16[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, -T15, -T16, +R] extends AnyRef

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

Источник

trait Function17[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, -T15, -T16, -T17, +R] extends AnyRef

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

Источник

trait Function18[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, -T15, -T16, -T17, -T18, +R] extends AnyRef

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

Источник

trait Function19[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, -T15, -T16, -T17, -T18, -T19, +R] extends AnyRef

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

Источник

trait Function2[@specialized -T1, @specialized -T2, @specialized +R] extends AnyRef

Функция от 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))
}

Источник

trait Function20[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, -T15, -T16, -T17, -T18, -T19, -T20, +R] extends AnyRef

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

Источник

trait Function21[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, -T15, -T16, -T17, -T18, -T19, -T20, -T21, +R] extends AnyRef

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

Источник

trait Function22[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, -T15, -T16, -T17, -T18, -T19, -T20, -T21, -T22, +R] extends AnyRef

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

Источник

trait Function3[-T1, -T2, -T3, +R] extends AnyRef

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

Источник

trait Function4[-T1, -T2, -T3, -T4, +R] extends AnyRef

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

Источник

trait Function5[-T1, -T2, -T3, -T4, -T5, +R] extends AnyRef

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

Источник

trait Function6[-T1, -T2, -T3, -T4, -T5, -T6, +R] extends AnyRef

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

Источник

trait Function7[-T1, -T2, -T3, -T4, -T5, -T6, -T7, +R] extends AnyRef

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

Источник

trait Function8[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, +R] extends AnyRef

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

Источник

trait Function9[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, +R] extends AnyRef

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

Источник

object IArray

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

Источник

final abstract class Int extends AnyVal

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

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

Источник

object Int

Источник

final abstract class Long extends AnyVal

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

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

Источник

object Long

Источник

final class MatchError(obj: Any) extends RuntimeException

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

open trait Matchable

Базовый класс типов, которые могут быть безопасно сопоставлены с образцом.

См. https://dotty.epfl.ch/docs/reference/other-new-features/matchable.html.

Источник

sealed trait NonEmptyTuple extends Tuple

Кортеж произвольной ненулевой арности

Источник@SerialVersionUID(5066590221178148012L)

case object None extends Option[Nothing]

Этот объект-константа представляет отсутствующие значения.

Источник

final class NotImplementedError(msg: String) extends Error

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

final abstract open class Nothing

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, который всегда выбрасывает исключение.

final abstract open class Null

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

Null — это тип литерала null. Он является подтипом каждого типа, кроме типов-значений. Типы-значения являются подклассами AnyVal, который включает примитивные типы, такие как Int, Boolean, и пользовательские типы-значения.

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

Источник

object Option

Источник@SerialVersionUID(-114498752079829388L)

sealed abstract class Option[+A] extends IterableOnce[A] with Product with Serializable

Представляет значения по умолчанию. Экземпляры 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 comprehension, если None возвращается из request.getParameter, всё выражение результатом будет None

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

Вот полезные методы, которые существуют как для scala.Some, так и для None. - isDefined — Истина, если не пусто - isEmpty — Истина, если пусто - nonEmpty — Истина, если не пусто - orElse — Вычисляется и возвращается альтернативное необязательное значение, если пусто - getOrElse — Вычисляется и возвращается альтернативное значение, если пусто - get — Возвращает значение, выбросит исключение, если пусто - fold — Применяет функцию к необязательному значению, возвращает значение по умолчанию, если пусто - map — Применяет функцию к необязательному значению - flatMap — Аналогично map, но функция должна возвращать необязательное значение - foreach — Применяет процедуру к значению Option - collect — Применяет частичное соответствие шаблону к необязательному значению - filter — Необязательное значение удовлетворяет предикату - filterNot — Необязательное значение не удовлетворяет предикату - exists — Применяет предикат к необязательному значению, или ложь, если пусто - forall — Применяет предикат к необязательному значению, или истина, если пусто - contains — Проверяет, равно ли значение необязательному значению, или ложь, если пусто - zip — Объединяет два необязательных значения в парное необязательное значение - unzip — Разделяет парное необязательное значение на два необязательных значения - unzip3 — Разделяет тройное необязательное значение на три необязательных значения - 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")
}

Источник

trait PartialFunction[-A, +B] extends A => B

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

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

val f: PartialFunction[Int, Any] = { case x => x / 0 }   // ArithmeticException: / by zero

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

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

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

val sample = 1 to 10
def isEven(n: Int) = n % 2 == 0
val eveningNews: PartialFunction[Int, String] = {
  case x if isEven(x) => s"$x is even"
}

// The method collect is described as "filter + map"
// because it uses a PartialFunction to select elements
// to which the function is applied.
val evenNumbers = sample.collect(eveningNews)

val oddlyEnough: PartialFunction[Int, String] = {
  case x if !isEven(x) => s"$x is odd"
}

// The method orElse allows chaining another PartialFunction
// to handle input outside the declared domain.
val numbers = sample.map(eveningNews orElse oddlyEnough)

// same as
val numbers = sample.map(n => eveningNews.applyOrElse(n, oddlyEnough))

val half: PartialFunction[Int, Int] = {
  case x if isEven(x) => x / 2
}

// Calculating the domain of a composition can be expensive.
val oddByHalf = half.andThen(oddlyEnough)

// Invokes `half.apply` on even elements!
val oddBalls = sample.filter(oddByHalf.isDefinedAt)

// Better than filter(oddByHalf.isDefinedAt).map(oddByHalf)
val oddBalls = sample.collect(oddByHalf)

// Providing "default" values.
val oddsAndEnds = sample.map(n => oddByHalf.applyOrElse(n, (i: Int) => s"[$i]"))

Источник

объект PartialFunction

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

import PartialFunction._

def strangeConditional(other: Any): Boolean = cond(other) {
  case x: String if x == "abc" || x == "def"  => true
  case x: Int => true
}
def onlyInt(v: Any): Option[Int] = condOpt(v) { case x: Int => x }

Источник

trait PolyFunction

Маркерный интерфейс для полиморфных типов функций.

Это единственный интерфейс, который можно уточнить с помощью полиморфного метода, при условии, что этот метод называется apply, например: PolyFunction { def apply[T_1, ..., T_M](x_1: P_1, ..., x_N: P_N): R } Этот тип будет стёрт до FunctionN.

Источник

объект Predef

Объект Predef предоставляет определения, доступные во всех единицах компиляции Scala без явного указания.

Типы общего пользования

Predef предоставляет псевдонимы типов для типов, которые часто используются, такие как неизменяемые типы коллекций scala.collection.immutable.Map и scala.collection.immutable.Set.

Вывод в консоль

Для базового вывода в консоль Predef предоставляет удобные методы print и println, которые являются псевдонимами методов в объекте scala.Console.

Утверждения

Предоставляется набор assert функций для документирования и динамической проверки инвариантов в коде. Вызовы assert могут быть исключены во время компиляции путём предоставления параметра командной строки -Xdisable-assertions, что поднимает -Xelide-below над elidable.ASSERTION, до уровня scalac команды.

Также предоставляются варианты assert для использования с инструментами статического анализа: assume, require и ensuring. require и ensuring предназначены для использования в качестве средства спецификации стиля «design by contract» предопределенных и пост-условий функций, с целью того, что эти спецификации могли бы быть обработаны инструментом статического анализа. Например,

def addNaturals(nats: List[Int]): Int = {
  require(nats forall (_ >= 0), "List contains negative numbers")
  nats.foldLeft(0)(_ + _)
} ensuring(_ >= 0)

Объявление addNaturals указывает, что список целых чисел должен содержать только натуральные числа (т. е. неотрицательные), и что возвращаемый результат также будет натуральным. require отличается от assert тем, что в случае неудачи проверки виноват вызывающий функцию, а не логическая ошибка внутри addNaturals. ensuring — это разновидность assert, которая объявляет гарантию, которую функция предоставляет относительно своего возвращаемого значения.

Неявные преобразования

Здесь также определено несколько часто применяемых неявных преобразований, а также в родительском типе scala.LowPriorityImplicits. Предоставляются неявные преобразования для «расширения» числовых значений, например, преобразования значения Short в Long при необходимости, а также добавления дополнительных функций высшего порядка к массивам значений. Более подробное описание приведено в документации к scala.Array.

Источник

trait Product extends Equals

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

Источник

object Product1

Источник

trait Product1[@specialized(Int, Long, Double) +T1] extends Product

Product1 — это декартово произведение из 1 компоненты.

Источник

object Product10

Источник

trait Product10[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10] extends Product

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

Источник

object Product11

Источник

trait Product11[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11] extends Product

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

Источник

object Product12

Источник

trait Product12[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12] extends Product

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

Источник

object Product13

Источник

trait Product13[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13] extends Product

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

Источник

object Product14

Источник

trait Product14[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14] extends Product

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

Источник

object Product15

Источник

trait Product15[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15] extends Product

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

Источник

объект Product16

Источник

трайт Product16[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15, +T16] extends Product

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

Источник

объект Product17

Источник

трайт Product17[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15, +T16, +T17] extends Product

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

Источник

объект Product18

Источник

трайт Product18[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15, +T16, +T17, +T18] extends Product

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

Источник

объект Product19

Источник

трайт Product19[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15, +T16, +T17, +T18, +T19] extends Product

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

Источник

объект Product2

Источник

трайт Product2[@specialized(Int, Long, Double) +T1, @specialized(Int, Long, Double) +T2] extends Product

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

Источник

объект Product20

Источник

трайт Product20[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15, +T16, +T17, +T18, +T19, +T20] extends Product

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

Источник

объект Product21

Источник

trait Product21[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15, +T16, +T17, +T18, +T19, +T20, +T21] extends Product

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

Источник

object Product22

Источник

trait Product22[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15, +T16, +T17, +T18, +T19, +T20, +T21, +T22] extends Product

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

Источник

object Product3

Источник

trait Product3[+T1, +T2, +T3] extends Product

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

Источник

object Product4

Источник

trait Product4[+T1, +T2, +T3, +T4] extends Product

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

Источник

object Product5

Источник

trait Product5[+T1, +T2, +T3, +T4, +T5] extends Product

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

Источник

object Product6

Источник

trait Product6[+T1, +T2, +T3, +T4, +T5, +T6] extends Product

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

Источник

object Product7

Источник

trait Product7[+T1, +T2, +T3, +T4, +T5, +T6, +T7] extends Product

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

Источник

object Product8

Источник

trait Product8[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8] extends Product

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

Источник

object Product9

Источник

trait Product9[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9] extends Product

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

Источник

case class ScalaReflectionException(msg: String) extends Exception

Исключение, указывающее на ошибку во время рефлексии Scala

Источник

trait Selectable

Маркируемый класс для объектов, которые поддерживают структурный выбор с помощью selectDynamic и applyDynamic.

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

def selectDynamic(name: String): Any def applyDynamic(name: String)(args: Any*): Any =

selectDynamic вызывается для простых выборов v.m, а applyDynamic вызывается для выборов с аргументами v.m(...). Если существует только один тип выбора, метод, поддерживающий другой тип, может быть опущен. applyDynamic также может иметь второй список параметров java.lang.Class, т.е. он может иметь альтернативную сигнатуру

def applyDynamic(name: String, paramClasses: Class[_]*)(args: Any*): Any

В этом случае вызов будет синтезировать Class аргументы для стирания всех формальных типов параметров метода в структурном типе.

Источник

object Selectable

Источник@deprecatedInheritance("Scheduled for being final in the future", "2.13.0")

class SerialVersionUID(value: Long) extends ConstantAnnotation

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

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

Источник

final abstract class Short extends AnyVal

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

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

Источник

object Short

final open trait Singleton

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 о типах-синглтонах на основе литералов.

Исходный код@SerialVersionUID(1234815782226070388L)

final case class Some[+A](value: A) extends Option[A]

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

Исходный код

trait Specializable

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

Исходный код

object Specializable

Исходный код

case class StringContext(parts: String*)

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

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.

Исходный код

object StringContext

Исходный код

final class Symbol extends Serializable

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

Исходный код

объект Symbol

Исходный код

герметичный признак Tuple расширяет Product

Кортеж произвольной арности

Исходный код

объект Tuple

Исходный код

окончательный случайный класс Tuple1[@specialized(Int, Long, Double) +T1](_1: T1) расширяет Product1[T1]

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

Исходный код

окончательный случайный класс Tuple10[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10](_1: T1, _2: T2, _3: T3, _4: T4, _5: T5, _6: T6, _7: T7, _8: T8, _9: T9, _10: T10) расширяет Product10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]

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

Исходный код

окончательный случайный класс Tuple11[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11](_1: T1, _2: T2, _3: T3, _4: T4, _5: T5, _6: T6, _7: T7, _8: T8, _9: T9, _10: T10, _11: T11) расширяет Product11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]

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

Исходный код

окончательный случайный класс Tuple12[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12](_1: T1, _2: T2, _3: T3, _4: T4, _5: T5, _6: T6, _7: T7, _8: T8, _9: T9, _10: T10, _11: T11, _12: T12) расширяет Product12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]

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

Исходный код

окончательный случайный класс Tuple13[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13](_1: T1, _2: T2, _3: T3, _4: T4, _5: T5, _6: T6, _7: T7, _8: T8, _9: T9, _10: T10, _11: T11, _12: T12, _13: T13) расширяет Product13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]

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

Источник

final case class Tuple14[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14](_1: T1, _2: T2, _3: T3, _4: T4, _5: T5, _6: T6, _7: T7, _8: T8, _9: T9, _10: T10, _11: T11, _12: T12, _13: T13, _14: T14) extends Product14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]

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

Источник

final case class Tuple15[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15](_1: T1, _2: T2, _3: T3, _4: T4, _5: T5, _6: T6, _7: T7, _8: T8, _9: T9, _10: T10, _11: T11, _12: T12, _13: T13, _14: T14, _15: T15) extends Product15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]

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

Источник

final case class Tuple16[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15, +T16](_1: T1, _2: T2, _3: T3, _4: T4, _5: T5, _6: T6, _7: T7, _8: T8, _9: T9, _10: T10, _11: T11, _12: T12, _13: T13, _14: T14, _15: T15, _16: T16) extends Product16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16]

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

Источник

final case class Tuple17[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15, +T16, +T17](_1: T1, _2: T2, _3: T3, _4: T4, _5: T5, _6: T6, _7: T7, _8: T8, _9: T9, _10: T10, _11: T11, _12: T12, _13: T13, _14: T14, _15: T15, _16: T16, _17: T17) extends Product17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17]

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

Source

final case class Tuple18[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15, +T16, +T17, +T18](_1: T1, _2: T2, _3: T3, _4: T4, _5: T5, _6: T6, _7: T7, _8: T8, _9: T9, _10: T10, _11: T11, _12: T12, _13: T13, _14: T14, _15: T15, _16: T16, _17: T17, _18: T18) extends Product18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18]

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

Source

final case class Tuple19[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15, +T16, +T17, +T18, +T19](_1: T1, _2: T2, _3: T3, _4: T4, _5: T5, _6: T6, _7: T7, _8: T8, _9: T9, _10: T10, _11: T11, _12: T12, _13: T13, _14: T14, _15: T15, _16: T16, _17: T17, _18: T18, _19: T19) extends Product19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19]

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

Source

final case class Tuple2[@specialized(Int, Long, Double, Char, Boolean) +T1, @specialized(Int, Long, Double, Char, Boolean) +T2](_1: T1, _2: T2) extends Product2[T1, T2]

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

Source

final case class Tuple20[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15, +T16, +T17, +T18, +T19, +T20](_1: T1, _2: T2, _3: T3, _4: T4, _5: T5, _6: T6, _7: T7, _8: T8, _9: T9, _10: T10, _11: T11, _12: T12, _13: T13, _14: T14, _15: T15, _16: T16, _17: T17, _18: T18, _19: T19, _20: T20) extends Product20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20]

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

Source

final case class Tuple21[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15, +T16, +T17, +T18, +T19, +T20, +T21](_1: T1, _2: T2, _3: T3, _4: T4, _5: T5, _6: T6, _7: T7, _8: T8, _9: T9, _10: T10, _11: T11, _12: T12, _13: T13, _14: T14, _15: T15, _16: T16, _17: T17, _18: T18, _19: T19, _20: T20, _21: T21) extends Product21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21]

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

Source

final case class Tuple22[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15, +T16, +T17, +T18, +T19, +T20, +T21, +T22](_1: T1, _2: T2, _3: T3, _4: T4, _5: T5, _6: T6, _7: T7, _8: T8, _9: T9, _10: T10, _11: T11, _12: T12, _13: T13, _14: T14, _15: T15, _16: T16, _17: T17, _18: T18, _19: T19, _20: T20, _21: T21, _22: T22) extends Product22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22]

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

Source

final case class Tuple3[+T1, +T2, +T3](_1: T1, _2: T2, _3: T3) extends Product3[T1, T2, T3]

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

Source

final case class Tuple4[+T1, +T2, +T3, +T4](_1: T1, _2: T2, _3: T3, _4: T4) extends Product4[T1, T2, T3, T4]

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

Source

final case class Tuple5[+T1, +T2, +T3, +T4, +T5](_1: T1, _2: T2, _3: T3, _4: T4, _5: T5) extends Product5[T1, T2, T3, T4, T5]

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

Source

final case class Tuple6[+T1, +T2, +T3, +T4, +T5, +T6](_1: T1, _2: T2, _3: T3, _4: T4, _5: T5, _6: T6) extends Product6[T1, T2, T3, T4, T5, T6]

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

Source

final case class Tuple7[+T1, +T2, +T3, +T4, +T5, +T6, +T7](_1: T1, _2: T2, _3: T3, _4: T4, _5: T5, _6: T6, _7: T7) extends Product7[T1, T2, T3, T4, T5, T6, T7]

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

Исходный код

final case class Tuple8[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8](_1: T1, _2: T2, _3: T3, _4: T4, _5: T5, _6: T6, _7: T7, _8: T8) extends Product8[T1, T2, T3, T4, T5, T6, T7, T8]

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

Исходный код

final case class Tuple9[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9](_1: T1, _2: T2, _3: T3, _4: T4, _5: T5, _6: T6, _7: T7, _8: T8, _9: T9) extends Product9[T1, T2, T3, T4, T5, T6, T7, T8, T9]

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

Исходный код

final case class UninitializedFieldError(msg: String) extends RuntimeException

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

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

Исходный код

final abstract class Unit extends AnyVal

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

Исходный код@compileTimeOnly("`Unit` companion object is not allowed in source; instead, use `()` for the unit value")

object Unit

Исходный код@implicitNotFound(msg = "No singleton value available for ${T}.")

final class ValueOf[T](val value: T) extends AnyVal

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

Исходный код@getter @setter @beanGetter @beanSetter @field @deprecatedInheritance("Scheduled for being final in the future", "2.13.0")

class deprecated(message: String, since: String) extends ConstantAnnotation

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

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

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

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

Исходный код@getter @setter @beanGetter @beanSetter

final class deprecatedInheritance(message: String, since: String) extends ConstantAnnotation

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

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

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

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

Исходный код@param @deprecatedInheritance("Scheduled for being final in the future", "2.13.0")

class deprecatedName(name: String, since: String) extends StaticAnnotation

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

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

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

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

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)
         ^

Источник@getter @setter @beanGetter @beanSetter @deprecatedInheritance("Планируется сделать final в будущем", "2.13.0")

class deprecatedOverriding(message: String, since: String) extends ConstantAnnotation

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

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

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

Источник@deprecatedInheritance("Планируется сделать final в будущем", "2.13.0")

class inline extends StaticAnnotation

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

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

При включенном встраивании инлайнер всегда будет пытаться встроить методы или места вызова, помеченные @inline (при условии, что встраивание из определяющего класса разрешено, см. -opt-inline-from:help). Если встраивание невозможно, например, потому что метод не final, будет выведено предупреждение оптимизатора. См. -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

Источник

object language

Объект scala.language управляет доступными для программиста языковыми возможностями, как предложено в документе SIP-18.

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

import language.postfixOps // or language._
List(1, 2, 3) reverse

Языковые возможности:

• dynamics позволяет определять переписывание вызовов с использованием тракта Dynamic

• existentials позволяет писать экзистенциальные типы

• higherKinds позволяет писать типы высших порядков

• implicitConversions позволяет определять неявные методы и члены

• postfixOps позволяет использовать постфиксные операторы (не рекомендуется)

• reflectiveCalls позволяет использовать структурные типы

• experimental содержит более новые функции, которые еще не были протестированы в производстве

Источник

object languageFeature

Источник

class main extends Annotation

Аннотация, обозначающая главную функцию

Источник@deprecatedInheritance("Планируется сделать final в будущем", "2.13.0")

class native extends StaticAnnotation

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

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

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

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

Источник

final class noinline extends StaticAnnotation

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

Обратите внимание, что по умолчанию 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

Источник

final class specialized(group: SpecializedGroup) extends StaticAnnotation

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

class MyList[@specialized T] ...

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

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

Источник

final class throws[T <: Throwable](cause: String) extends StaticAnnotation

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

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

Источник@field

final class transient extends StaticAnnotation

Источник

final class unchecked extends Annotation

Аннотация, обозначающая, что аннотированный элемент не должен рассматриваться для дополнительных проверок компилятора. Конкретные применения включают аннотирование темы выражения match для подавления предупреждений об исчерпывающей и достижимости, и аннотирование аргумента типа в случае match для подавления предупреждений об 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 }
}

Источник@experimental

object unsafeExceptions

Источник@field

final class volatile extends StaticAnnotation

Типы

type & = [X0, X1] =>> X0 & X1

Пересечение двух типов.

См. https://dotty.epfl.ch/docs/reference/new-types/intersection-types.html.

Источник

type ::[+A] = ::[A]

Источник

type AbstractMethodError = AbstractMethodError

Source

type Исключение индекса массива = ArrayIndexOutOfBoundsException

Source

type BigDecimal = BigDecimal

Source

type BigInt = BigInt

Source

type ClassCastException = ClassCastException

Source

type Cloneable = Cloneable

Source

type Either[+A, +B] = Either[A, B]

Source

type Пустая кортеж = EmptyTuple.type

Кортеж из 0 элементов

Source

type Equiv[T] = Equiv[T]

Source

type Ошибка = Error

Source

type Исключение = Exception

Source

type Дробный[T] = Fractional[T]

Source

opaque type IArray[+T]

Source

type Исключение некорректного аргумента = IllegalArgumentException

Source

type Исключение индекса = IndexOutOfBoundsException

Source@migration("scala.IndexedSeq is now scala.collection.immutable.IndexedSeq instead of scala.collection.IndexedSeq", "2.13.0")

type Индексированный массив[+A] = IndexedSeq[A]

Source

type Целочисленный[T] = Integral[T]

Source

type Прерванное исключение = InterruptedException

Source

type Итерируемый[+A] = Iterable[A]

Source

type Итерируемый один раз[+A] = IterableOnce[A]

Source

type Итератор[+A] = Iterator[A]

Source

type Ленивый список[+A] = LazyList[A]

Source

type Левая[+A, +B] = Left[A, B]

Source

type Список[+A] = List[A]

Source

type Исключение отсутствия элемента = NoSuchElementException

Source

type Исключение нулевого указателя = NullPointerException

Source

type Исключение формата числа = NumberFormatException

Source

type Числовой[T] = Numeric[T]

Source

type Упорядоченный[T] = Ordered[T]

Source

type Порядок[T] = Ordering[T]

Source

type Частичный порядок[T] = PartialOrdering[T]

Source

type Частично упорядоченный[T] = PartiallyOrdered[T]

Source

type Диапазон = Range

Source

type Правая[+A, +B] = Right[A, B]

Source

type Исключение времени выполнения = RuntimeException

Source@migration("scala.Seq is now scala.collection.immutable.Seq instead of scala.collection.Seq", "2.13.0")

type Последовательность[+A] = Seq[A]

Source

type Сериализуемый = Serializable

Source

type Строка = StringBuilder

Source

type StringIndexOutOfBoundsException = StringIndexOutOfBoundsException

Source

type Throwable = Throwable

Source

type UnsupportedOperationException = UnsupportedOperationException

Source

type Vector[+A] = Vector[A]

type | = [X0, X1] =>> X0 | X1

Объединение двух типов.

См. https://dotty.epfl.ch/docs/reference/new-types/union-types.html.

Конкретные поля

Source

val +:: +:.type

Source

val :+: :+.type

Source

val ::: ::.type

Source

val AnyRef: Specializable

Source

val BigDecimal: BigDecimal.type

Source

val BigInt: BigInt.type

Source

val Either: Either.type

Source

val Equiv: Equiv.type

Source

val Fractional: Fractional.type

Source

val IndexedSeq: IndexedSeq.type

Source

val Integral: Integral.type

Source

val Iterable: Iterable.type

Source

val Iterator: Iterator.type

Source

val LazyList: LazyList.type

Source

val Left: Left.type

Source

val List: List.type

Source

val Nil: Nil.type

Source

val Numeric: Numeric.type

Source

val Ordered: Ordered.type

Source

val Ordering: Ordering.type

Source

val Range: Range.type

Source

val Right: Right.type

Source

val Seq: Seq.type

Source

val StringBuilder: StringBuilder.type

Source

val Vector: Vector.type