Объект scala.collection.immutable.Nil

case object Nil extends Список[Ничего]

Унаследованные типы

Исходный код

type MirroredElemLabels = EmptyTuple

Исходный код

type MirroredElemTypes = EmptyTuple

Исходный код

type MirroredLabel <: Строка

Имя типа

Исходный код

type MirroredMonoType = Singleton

Исходный код

type MirroredType = Singleton

Конкретные методы

Исходный код

override def head: Ничего

Исходный код

override def headOption: None.type

Исходный код

override def init: Ничего

Исходный код

override def iterator: Итератор[Ничего]

Исходный код

override def knownSize: Целое

Исходный код

override def last: Ничего

Исходный код

override def tail: Ничего

Исходный код

override def unzip[A1, A2](implicit asPair: Ничего => (A1, A2)): (Список[A1], Список[A2])

Унаследованные методы

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

final def ++[B](suffix: IterableOnce[B]): Список[B]

Псевдоним для concat

Source@inline

final override def ++:[B](prefix: IterableOnce[B]): Список[B]

Псевдоним для prependedAll

Source@inline

final def +:[B](elem: B): Список[B]

Псевдоним для prepended.

Обратите внимание, что операторы с окончанием :- являются правоассоциативными (см. пример). Мnemonic для +: по сравнению с :+: двоеточие ставится со стороны коллекции.

Source@inline

final def :+[B](elem: B): Список[B]

Псевдоним для appended

Обратите внимание, что операторы с окончанием :- являются правоассоциативными (см. пример). Мnemonic для +: по сравнению с :+: двоеточие ставится со стороны коллекции.

Source@inline

final def :++[B](suffix: IterableOnce[B]): Список[B]

Псевдоним для appendedAll

Source

def ::[B](elem: B): Список[B]

Добавляет элемент в начало этого списка.

1 :: List(2, 3) = List(2, 3).::(1) = List(1, 2, 3)

Source

def :::[B](prefix: Список[B]): Список[B]

Добавляет элементы заданного списка перед этим списком.

Пример:

List(1, 2) ::: List(3, 4) = List(3, 4).:::(List(1, 2)) = List(1, 2, 3, 4)

Source@inline

final def addString(b: StringBuilder): StringBuilder

Добавляет все элементы этой коллекции в строковый буфер. Записываемый текст состоит из строковых представлений (относительно метода toString) всех элементов этой коллекции без разделительной строки.

Пример:

scala> val a = List(1,2,3,4)
a: List[Int] = List(1, 2, 3, 4)

scala> val b = new StringBuilder()
b: StringBuilder =

scala> val h = a.addString(b)
h: StringBuilder = 1234

Source@inline

final def addString(b: StringBuilder, sep: String): StringBuilder

Добавляет все элементы этой коллекции в строковый буфер, используя разделительную строку. Записываемый текст состоит из строковых представлений (относительно метода toString) всех элементов этой коллекции, разделенных строкой sep.

Пример:

scala> val a = List(1,2,3,4)
a: List[Int] = List(1, 2, 3, 4)

scala> val b = new StringBuilder()
b: StringBuilder =

scala> a.addString(b, ", ")
res0: StringBuilder = 1, 2, 3, 4

Source

def addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder

Добавляет все элементы этой коллекции в строковый буфер, используя начальную, конечную и разделительные строки. Записываемый текст начинается со строки start и заканчивается строкой end. Внутри, строковые представления (относительно метода toString) всех элементов этой коллекции разделяются строкой sep.

Пример:

scala> val a = List(1,2,3,4)
a: List[Int] = List(1, 2, 3, 4)

scala> val b = new StringBuilder()
b: StringBuilder =

scala> a.addString(b , "List(" , ", " , ")")
res5: StringBuilder = List(1, 2, 3, 4)

Source

def andThen[C](k: PartialFunction[Nothing, C]): PartialFunction[ЦелоеЧисло, C]

Компонует эту частичную функцию с другой частичной функцией, которая применяется к результатам этой частичной функции.

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

Source

override def andThen[C](k: Nothing => C): PartialFunction[ЦелоеЧисло, C]

Компонует эту частичную функцию с функцией преобразования, которая применяется к результатам этой частичной функции.

Если тип функции в runtime является PartialFunction, то используется другой метод andThen.(обратите внимание на предостережения).

Source

override def appended[B](elem: B): Список[B]

Источник

override def appendedAll[B](suffix: IterableOnce[B]): Список[B]

Источник@throws(scala.throws.$lessinit$greater$default$1[scala.IndexOutOfBoundsException])

override def apply(n: Целое): Nothing

Источник

def applyOrElse[A1 <: Целое, B1](x: A1, default: A1 => B1): B1

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

Обратите внимание, что выражение pf.applyOrElse(x, default) эквивалентно

if(pf isDefinedAt x) pf(x) else default(x)

за исключением того, что метод applyOrElse может быть реализован более эффективно. Для всех литералов частичных функций компилятор генерирует реализацию applyOrElse, которая избегает двойной оценки соответствий с шаблонами и условий. Это делает applyOrElse основой для эффективной реализации многих операций и сценариев, таких как:

- объединение частичных функций в цепочки orElse/andThen не приводит к чрезмерной оценке apply/isDefinedAt - lift и unlift не оценивают исходные функции дважды при каждом вызове - runWith позволяет эффективно объединять частичные функции в императивном стиле с условными действиями

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

Источник

def canEqual(that: Любой): Булево

Источник

final override def collect[B](pf: PartialFunction[Nothing, B]): Список[B]

Источник

def collectFirst[B](pf: PartialFunction[Nothing, B]): Некоторые[B]

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

Примечание: может не завершиться для коллекций бесконечного размера.

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

Источник

def combinations(n: Целое): Итератор[Список[Nothing]]

Итерация по сочетаниям. _Сочетание_ длиной n — это подпоследовательность исходной последовательности, с элементами, взятыми в порядке. Таким образом, "xy" и "yy" — оба сочетания длины 2 для "xyy", но "yx" таковым не является. Если существует более одного способа генерации одной и той же подпоследовательности, будет возвращён только один.

Например, у "xyyy" есть три различных способа генерации "xy" в зависимости от того, какой элемент — первый, второй или третий "y" выбирается. Однако, поскольку все они идентичны, будет выбран только один. Какой из трёх будет выбран, является деталью реализации и не определён.

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

Источник

def compose[R](k: PartialFunction[R, Целое]): PartialFunction[R, Nothing]

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

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

Источник@unspecialized

def compose[A](g: A => Целое): A => Nothing

Компонует две функции Function1 в новую Function1, применяя эту функцию последней.

Источник@inline

final override def concat[B](suffix: IterableOnce[B]): Список[B]

Источник

final override def contains[A1](elem: A1): Булево

Источник

def containsSlice[B](that: Seq[B]): Булево

Проверяет, содержит ли эта последовательность заданную последовательность как срез.

Примечание: может не завершиться для коллекций бесконечного размера.

Источник

def copyToArray[B](xs: Массив[B], start: Целое число, len: Целое число): Целое число

Копирует элементы в массив, возвращая количество скопированных элементов.

Заполняет заданный массив xs начиная с индекса start не более чем len элементами этой коллекции.

Копирование завершится, когда будут скопированы все элементы этой коллекции, или будет достигнут конец массива, или len элементов будут скопированы.

Источник@deprecatedOverriding("Это должно всегда перенаправлять на 3-аргументную версию этого метода", since = "2.13.4")

def copyToArray[B](xs: Массив[B], start: Целое число): Целое число

Копирует элементы в массив, возвращая количество скопированных элементов.

Заполняет заданный массив xs начиная с индекса start значениями этой коллекции.

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

Источник@deprecatedOverriding("Это должно всегда перенаправлять на 3-аргументную версию этого метода", since = "2.13.4")

def copyToArray[B](xs: Массив[B]): Целое число

Копирует элементы в массив, возвращая количество скопированных элементов.

Заполняет заданный массив xs начиная с индекса start значениями этой коллекции.

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

Источник

override def corresponds[B](that: Последовательность[B])(p: (Nothing, B) => Булево): Булево

Источник

def corresponds[B](that: IterableOnce[B])(p: (Nothing, B) => Булево): Булево

Проверяет, связаны ли все элементы итератора этой коллекции с соответствующим элементом другой коллекции, удовлетворяя условиям предиката.

Примечание: не завершится для коллекций бесконечного размера.

Источник

def count(p: Nothing => Булево): Целое число

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

Примечание: не завершится для коллекций бесконечного размера.

Источник

override def diff[B](that: Последовательность[B]): Список[Nothing]

Источник

def distinct: Список[Nothing]

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

Источник

override def distinctBy[B](f: Nothing => B): Список[Nothing]

Источник

override def drop(n: Целое число): Список[Nothing]

Источник

override def dropRight(n: Целое число): Список[Nothing]

Остальная часть коллекции без её n последних элементов. Для линейных, неизменяемых коллекций это должно избегать создания копии.

Примечание: Даже при применении к представлению или ленивой коллекции элементы всегда будут принудительно вычисляться.

Source

override def dropWhile(p: Nothing => Boolean): List[Nothing]

Source

def elementWise: ElementWiseExtractor[Int, Nothing]

Возвращает объект-экстрактор с методом unapplySeq, который извлекает каждый элемент данных последовательности.

val firstChar: String => Option[Char] = _.headOption
Seq("foo", "bar", "baz") match {
  case firstChar.unlift.elementWise(c0, c1, c2) =>
    println(s"$c0, $c1, $c2") // Output: f, b, b
}

Source

override def empty: List[Nothing]

Source

def endsWith[B](that: Iterable[B]): Boolean

Проверяет, заканчивается ли эта последовательность заданной последовательностью.

Примечание: не будет завершаться для коллекций бесконечного размера.

Source

override def equals(o: Any): Boolean

Source

final override def exists(p: Nothing => Boolean): Boolean

Source

override def filter(p: Nothing => Boolean): List[Nothing]

Source

override def filterNot(p: Nothing => Boolean): List[Nothing]

Source

final override def find(p: Nothing => Boolean): Option[Nothing]

Source

override def findLast(p: Nothing => Boolean): Option[Nothing]

Source

final override def flatMap[B](f: Nothing => IterableOnce[B]): List[B]

Source

override def flatten[B](implicit toIterableOnce: Nothing => IterableOnce[B]): List[B]

Source

def fold[A1](z: A1)(op: (A1, A1) => A1): A1

Складывает элементы этой коллекции, используя заданный ассоциативный бинарный оператор. Реализация по умолчанию в IterableOnce эквивалентна foldLeft, но может быть переопределена для более эффективных порядков обхода.

Порядок выполнения операций над элементами не определён и может быть не детерминированным.

Примечание: не будет завершаться для коллекций бесконечного размера.

Source

override def foldLeft[B](z: B)(op: (B, Nothing) => B): B

Source

final override def foldRight[B](z: B)(op: (Nothing, B) => B): B

Исходный код

final override def forall(p: Nothing => Boolean): Boolean

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

final override def foreach[U](f: Nothing => U): Unit

Исходный код

def fromProduct(p: Product): MirroredMonoType

Исходный код

protected def fromSpecific(coll: IterableOnce[Nothing]): Список[Nothing]

Исходный код

def groupBy[K](f: Nothing => K): Map[K, Список[Nothing]]

Разделяет эту итерируемую коллекцию на карту итерируемых коллекций в соответствии с некоторой функцией-дискриминатором.

Примечание: даже при применении к представлению или ленивой коллекции она всегда заставляет элементы.

(xs groupBy f)(k) = xs filter (x => f(x) == k)

Исходный код

def groupMap[K, B](key: Nothing => K)(f: Nothing => B): Map[K, Список[B]]

Разделяет эту итерируемую коллекцию на карту итерируемых коллекций в соответствии с функцией-дискриминатором key. Каждый элемент в группе преобразуется в значение типа B с помощью функции value.

Это эквивалентно groupBy(key).mapValues(_.map(f)), но более эффективно.

case class User(name: String, age: Int)

def namesByAge(users: Seq[User]): Map[Int, Seq[String]] =
  users.groupMap(_.age)(_.name)

Примечание: даже при применении к представлению или ленивой коллекции она всегда заставляет элементы.

Исходный код

def groupMapReduce[K, B](key: Nothing => K)(f: Nothing => B)(reduce: (B, B) => B): Map[K, B]

Разделяет эту итерируемую коллекцию на карту в соответствии с функцией-дискриминатором key. Все значения, имеющие одинаковый дискриминатор, затем преобразуются с помощью функции f и затем сводятся к одному значению с помощью функции reduce.

Это эквивалентно groupBy(key).mapValues(_.map(f).reduce(reduce)), но более эффективно.

def occurrences[A](as: Seq[A]): Map[A, Int] =
  as.groupMapReduce(identity)(_ => 1)(_ + _)

Примечание: даже при применении к представлению или ленивой коллекции она всегда заставляет элементы.

Исходный код

def grouped(size: Int): Iterator[Список[Nothing]]

Разделяет элементы на итерируемые коллекции фиксированного размера.

Исходный код

override def hashCode(): Int

Исходный код@deprecatedOverriding("Override indexOf(elem, from) instead - indexOf(elem) calls indexOf(elem, 0)", "2.13.0")

def indexOf[B](elem: B): Int

Находит индекс первого вхождения некоторого значения в эту последовательность.

Исходный код

def indexOf[B](elem: B, from: Int): Int

Находит индекс первого вхождения некоторого значения в эту последовательность после или на определенном стартовом индексе.

Исходный код@deprecatedOverriding("Override indexOfSlice(that, from) instead - indexOfSlice(that) calls indexOfSlice(that, 0)", "2.13.0")

def indexOfSlice[B](that: Seq[B]): Int

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

Примечание: может не завершиться для бесконечных коллекций.

Source

def indexOfSlice[B](that: Seq[B], from: Int): Int

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

Примечание: может не завершаться для коллекций бесконечного размера.

Source@deprecatedOverriding("Override indexWhere(p, from) instead - indexWhere(p) calls indexWhere(p, 0)", "2.13.0")

def indexWhere(p: Nothing => Boolean): Int

Находит индекс первого элемента, удовлетворяющего некоторому предикату.

Примечание: может не завершаться для коллекций бесконечного размера.

Source

override def indexWhere(p: Nothing => Boolean, from: Int): Int

Source

def indices: Range

Создает диапазон всех индексов этой последовательности.

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

Source

def inits: Iterator[List[Nothing]]

Итерируется по начальным подпоследовательностям этой итерируемой коллекции. Первое значение будет этой итерируемой коллекцией, а последнее — пустой итерируемой коллекцией, а промежуточные значения — результатами последовательных применений init.

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

Source

override def intersect[B](that: Seq[B]): List[Nothing]

Source

override def isDefinedAt(x: Int): Boolean

Source

final override def isEmpty: Boolean

Source

override def isTraversableAgain: Boolean

Source

override def iterableFactory: SeqFactory[List]

Source

def lastIndexOf[B](elem: B, end: Int): Int

Находит индекс последнего вхождения некоторого значения в эту последовательность перед или на заданном индексе конца.

Примечание: не будет завершаться для коллекций бесконечного размера.

Source@deprecatedOverriding("Override lastIndexOfSlice(that, end) instead - lastIndexOfSlice(that) calls lastIndexOfSlice(that, Int.MaxValue)", "2.13.0")

def lastIndexOfSlice[B](that: Seq[B]): Int

Находит последний индекс, где эта последовательность содержит заданную последовательность как срез.

Примечание: не будет завершаться для коллекций бесконечного размера.

Source

def lastIndexOfSlice[B](that: Seq[B], end: Int): Int

Находит последний индекс перед или на заданном индексе конца, где эта последовательность содержит заданную последовательность как срез.

Примечание: не будет завершаться для коллекций бесконечного размера.

Source@deprecatedOverriding("Override lastIndexWhere(p, end) instead - lastIndexWhere(p) calls lastIndexWhere(p, Int.MaxValue)", "2.13.0")

def lastIndexWhere(p: Nothing => Boolean): Int

Находит индекс последнего элемента, удовлетворяющего некоторому предикату.

Примечание: не завершится для коллекций бесконечного размера.

Source

override def lastIndexWhere(p: Nothing => Boolean, end: Int): Int

Source

def lastOption: Option[Nothing]

Возвращает необязательный последний элемент.

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

Source

def lazyZip[B](that: Iterable[B]): LazyZip2[Nothing, B, Nil.type]

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

Вызовы lazyZip могут быть объединены для поддержки более высоких арностей (до 4) без затрат на создание и деструктуризацию промежуточных кортежей.

val xs = List(1, 2, 3)
val res = (xs lazyZip xs lazyZip xs lazyZip xs).map((a, b, c, d) => a + b + c + d)
// res == List(4, 8, 12)

Source

final override def length: Int

Source

final override def lengthCompare(len: Int): Int

Source

override def lengthCompare(that: Iterable[_]): Int

Source@inline

final def lengthIs: SizeCompareOps

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

Эти операции реализуются с помощью lengthCompare(Int) и позволяют использовать следующие более удобочитаемые конструкции:

this.lengthIs < len     // this.lengthCompare(len) < 0
this.lengthIs <= len    // this.lengthCompare(len) <= 0
this.lengthIs == len    // this.lengthCompare(len) == 0
this.lengthIs != len    // this.lengthCompare(len) != 0
this.lengthIs >= len    // this.lengthCompare(len) >= 0
this.lengthIs > len     // this.lengthCompare(len) > 0

Source

def lift: Int => Option[Nothing]

Преобразует эту частичную функцию в обычную функцию, возвращающую результат Option.

Source

final override def map[B](f: Nothing => B): List[B]

Source@inline

final def mapConserve[B <: AnyRef](f: Nothing => B): List[B]

Создает новый список, применяя функцию ко всем элементам этого списка. Подобно xs map f, но возвращает xs неизменным, если функция f отображает все элементы на себя (как определяется eq).

Source

def max[B](implicit ord: Ordering[B]): Nothing

Находит наибольший элемент.

Примечание: не завершится для коллекций бесконечного размера.

Source

def maxBy[B](f: Nothing => B)(implicit cmp: Ordering[B]): Nothing

Находит первый элемент, который дает наибольшее значение, измеренное функцией f.

Примечание: не завершится для коллекций бесконечного размера.

Источник

def maxByOption[B](f: Nothing => B)(implicit cmp: Ordering[B]): Option[Nothing]

Находит первый элемент, который возвращает наибольшее значение, измеренное функцией f.

Примечание: не будет завершаться для наборов бесконечного размера.

Источник

def maxOption[B](implicit ord: Ordering[B]): Option[Nothing]

Находит наибольший элемент.

Примечание: не будет завершаться для наборов бесконечного размера.

Источник

def min[B](implicit ord: Ordering[B]): Nothing

Находит наименьший элемент.

Примечание: не будет завершаться для наборов бесконечного размера.

Источник

def minBy[B](f: Nothing => B)(implicit cmp: Ordering[B]): Nothing

Находит первый элемент, который возвращает наименьшее значение, измеренное функцией f.

Примечание: не будет завершаться для наборов бесконечного размера.

Источник

def minByOption[B](f: Nothing => B)(implicit cmp: Ordering[B]): Option[Nothing]

Находит первый элемент, который возвращает наименьшее значение, измеренное функцией f.

Примечание: не будет завершаться для наборов бесконечного размера.

Источник

def minOption[B](implicit ord: Ordering[B]): Option[Nothing]

Находит наименьший элемент.

Примечание: не будет завершаться для наборов бесконечного размера.

Источник@inline

final def mkString: String

Отображает все элементы этого набора в строке.

Делегирует addString, который может быть переопределен.

Источник@inline

final def mkString(sep: String): String

Отображает все элементы этого набора в строке с использованием разделительной строки.

Делегирует addString, который может быть переопределен.

Источник

final def mkString(start: String, sep: String, end: String): String

Отображает все элементы этого набора в строке с использованием начальной, конечной и разделительной строк.

Делегирует addString, который может быть переопределен.

Source

protected def newSpecificBuilder: Builder[Nothing, Список[Nothing]]

Source@deprecatedOverriding("nonEmpty is defined as !isEmpty; override isEmpty instead", "2.13.0")

def nonEmpty: Boolean

Проверяет, не пуст ли набор.

Source

def orElse[A1 <: Int, B1](that: PartialFunction[A1, B1]): PartialFunction[A1, B1]

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

Source

override def padTo[B](len: Int, elem: B): Список[B]

Source

override def partition(p: Nothing => Boolean): (Список[Nothing], Список[Nothing])

Source

override def partitionMap[A1, A2](f: Nothing => Either[A1, A2]): (Список[A1], Список[A2])

Source

override def patch[B](from: Int, other: IterableOnce[B], replaced: Int): Список[B]

Source

def permutations: Итератор[Список[Nothing]]

Итерирует по различным перестановкам.

Примечание: Даже при применении к представлению или ленивой коллекции элементы всегда будут принудительно вычисляться.

Source

override def prepended[B](elem: B): Список[B]

Source

override def prependedAll[B](prefix: IterableOnce[B]): List[B]

Source

def product[B](implicit num: Numeric[B]): B

Перемножает элементы этого набора.

Примечание: не завершит работу для наборов бесконечной размерности.

Source

def productElementNames: Итератор[Строка]

Итератор по именам всех элементов этого произведения.

Source

def productIterator: Итератор[Любой]

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

Source

def reduce[B](op: (B, B) => B): B

Сводит элементы этого набора с помощью указанного ассоциативного бинарного оператора.

Порядок выполнения операций над элементами не определен и может быть не детерминированным.

Source

def reduceLeft[B](op: (B, Ничто) => B): B

Применяет бинарный оператор ко всем элементам этого набора слева направо.

Примечание: не завершит работу для наборов бесконечной размерности.

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

Источник

def reduceLeftOption[B](op: (B, Nothing) => B): Option[B]

Применяет бинарный оператор ко всем элементам этой коллекции слева направо (по возможности).

Примечание: не будет завершаться для коллекций бесконечного размера.

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

Источник

def reduceOption[B](op: (B, B) => B): Option[B]

Сводит элементы этой коллекции, если таковые имеются, с помощью заданного ассоциативного бинарного оператора.

Порядок выполнения операций над элементами не определен и может быть не детерминированным.

Источник

def reduceRight[B](op: (Nothing, B) => B): B

Применяет бинарный оператор ко всем элементам этой коллекции справа налево.

Примечание: не будет завершаться для коллекций бесконечного размера.

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

Источник

def reduceRightOption[B](op: (Nothing, B) => B): Option[B]

Возвращает значение Option, содержащее результат применения бинарного оператора к элементам этой коллекции справа налево (если коллекция не пуста).

Примечание: не будет завершаться для коллекций бесконечного размера.

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

Источник

final override def reverse: List[Nothing]

Источник

def reverseIterator: Iterator[Nothing]

Итератор, возвращающий элементы в обратном порядке.

Примечание: не будет завершаться для коллекций бесконечного размера.

Примечание: xs.reverseIterator эквивалентно xs.reverse.iterator, но может быть более эффективным.

Источник

def reverse_:::[B](prefix: List[B]): List[B]

Добавляет элементы заданного списка в обратном порядке в начало этого списка. xs reverse_::: ys эквивалентно xs.reverse ::: ys, но более эффективно.

Источник

protected def reversed: Iterable[Nothing]

Источник

def runWith[U](action: Nothing => U): Int => Boolean

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

Обратите внимание, что выражение pf.runWith(action)(x) эквивалентно

if(pf isDefinedAt x) { action(pf(x)); true } else false

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

Источник

override def sameElements[B](that: IterableOnce[B]): Boolean

Источник

def scan[B](z: B)(op: (B, B) => B): List[B]

Вычисляет сканирование префикса элементов коллекции.

Примечание: нейтральный элемент z может применяться более одного раза.

Источник

override def scanLeft[B](z: B)(op: (B, Nothing) => B): Список[B]

Источник

def scanRight[B](z: B)(op: (Nothing, B) => B): Список[B]

Создаёт набор, содержащий кумулятивные результаты применения оператора справа налево. Головка набора — это последний кумулятивный результат.

Примечание: не завершается для наборов бесконечного размера.

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

Примечание: даже при применении к представлению или ленивому набору он всегда принуждает элементы.

Пример:

List(1, 2, 3, 4).scanRight(0)(_ + _) == List(10, 9, 7, 4, 0)

Источник

def search[B](elem: B, from: Целое, to: Целое)(implicit ord: Ordering[B]): SearchResult

Поиск в интервале в этом отсортированном наборе определенного элемента. Если этот набор является IndexedSeq, используется двоичный поиск. В противном случае используется линейный поиск.

Набор должен быть отсортирован с использованием того же Ordering перед вызовом; в противном случае результаты не определены.

Источник

def search[B](elem: B)(implicit ord: Ordering[B]): SearchResult

Поиск в этом отсортированном наборе определенного элемента. Если набор является IndexedSeq, используется двоичный поиск. В противном случае используется линейный поиск.

Набор должен быть отсортирован с использованием того же Ordering перед вызовом; в противном случае результаты не определены.

Источник

override def segmentLength(p: Nothing => Boolean, from: Целое): Целое

Источник

final def segmentLength(p: Nothing => Boolean): Целое

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

Примечание: может не завершаться для наборов бесконечного размера.

Источник

final override def size: Целое

Источник

final override def sizeCompare(that: Iterable[_]): Целое

Источник

final override def sizeCompare(otherSize: Целое): Целое

Источник@inline

final def sizeIs: SizeCompareOps

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

Эти операции реализованы в терминах sizeCompare(Int) и позволяют использовать следующие более удобочитаемые варианты:

this.sizeIs < size     // this.sizeCompare(size) < 0
this.sizeIs <= size    // this.sizeCompare(size) <= 0
this.sizeIs == size    // this.sizeCompare(size) == 0
this.sizeIs != size    // this.sizeCompare(size) != 0
this.sizeIs >= size    // this.sizeCompare(size) >= 0
this.sizeIs > size     // this.sizeCompare(size) > 0

Источник

override def slice(from: Целое, until: Целое): Список[Nothing]

// Given a list
val letters = List('a','b','c','d','e')
// `slice` returns all elements beginning at index `from` and afterwards,
// up until index `until` (excluding index `until`.)
letters.slice(1,3) // Returns List('b','c')

Источник

def sliding(size: Целое, step: Целое): Итератор[Список[Nothing]]

Группирует элементы в блоки фиксированного размера, пропуская «скользящее окно» над ними (в отличие от разбиения на части, как в grouped.)

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

Источник

def sliding(size: Int): Iterator[List[Nothing]]

Группирует элементы в блоки фиксированного размера, пропуская "скользящее окно" по ним (в отличие от их разбиения, как это делается в grouped).

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

Источник

def sortBy[B](f: Nothing => B)(implicit ord: Ordering[B]): List[Nothing]

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

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

Примечание: даже при применении к представлению или ленивому набору данных всегда принудительно принуждает элементы.

Сортировка стабильна. То есть, элементы, которые равны (как определяется ord.compare), появляются в одном и том же порядке в отсортированном наборе данных, что и в исходном.

val words = "The quick brown fox jumped over the lazy dog".split(' ')
// this works because scala.Ordering will implicitly provide an Ordering[Tuple2[Int, Char]]
words.sortBy(x => (x.length, x.head))
res0: Array[String] = Array(The, dog, fox, the, lazy, over, brown, quick, jumped)

Источник

def sortWith(lt: (Nothing, Nothing) => Boolean): List[Nothing]

Сортирует этот набор данных в соответствии с функцией сравнения.

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

Примечание: даже при применении к представлению или ленивому набору данных всегда принудительно принуждает элементы.

Сортировка стабильна. То есть, элементы, которые равны (как определяется lt), появляются в одном и том же порядке в отсортированном наборе данных, что и в исходном.

List("Steve", "Tom", "John", "Bob").sortWith(_.compareTo(_) < 0) =
List("Bob", "John", "Steve", "Tom")

Источник

override def sorted[B](implicit ord: Ordering[B]): List[Nothing]

Источник@inline

final override def span(p: Nothing => Boolean): (List[Nothing], List[Nothing])

Источник

override def splitAt(n: Int): (List[Nothing], List[Nothing])

Источник

def startsWith[B](that: IterableOnce[B], offset: Int): Boolean

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

Примечание: если как получаемый объект this, так и аргумент that являются бесконечными последовательностями, этот метод может не завершиться.

Источник

def stepper[S <: Stepper[_]](implicit shape: StepperShape[Nothing, S]): S

Возвращает scala.collection.Stepper для элементов этого набора данных.

Stepper позволяет создавать поток Java для работы с набором данных, см. scala.jdk.StreamConverters. Для наборов данных, содержащих примитивные значения, Stepper может использоваться как итератор, который не упаковывает элементы.

Неявный параметр scala.collection.StepperShape определяет тип возвращаемого Stepper в соответствии с типом элемента этого набора данных.

• Для наборов данных типа Int, Short, Byte или Char, возвращается scala.collection.IntStepper

• Для наборов данных типа Double или Float, возвращается scala.collection.DoubleStepper

• Для наборов данных типа Long возвращается scala.collection.LongStepper

• Для любого другого типа элементов возвращается scala.collection.AnyStepper

Обратите внимание, что этот метод переопределен в дочерних классах, и тип возвращаемого значения уточняется до S with EfficientSplit, например, scala.collection.IndexedSeqOps.stepper. Для Stepper, помеченных scala.collection.Stepper.EfficientSplit, преобразователи в scala.jdk.StreamConverters позволяют создавать параллельные потоки, тогда как обычные Stepper могут быть преобразованы только в последовательные потоки.

Source

def sum[B](implicit num: Numeric[B]): B

Суммирует элементы этого набора.

Примечание: не завершит работу для коллекций бесконечного размера.

Source

override def tails: Iterator[List[Nothing]]

Source

override def take(n: Int): List[Nothing]

Source

override def takeRight(n: Int): List[Nothing]

Source@inline

final override def takeWhile(p: Nothing => Boolean): List[Nothing]

Source

override def tapEach[U](f: Nothing => U): List[Nothing]

Source

def to[C1](factory: Factory[Nothing, C1]): C1

Принимая во внимание фабрику коллекций factory, преобразуйте эту коллекцию в соответствующее представление для текущего типа элемента A. Примеры использования:

xs.to(List) xs.to(ArrayBuffer) xs.to(BitSet) // для xs: Iterable[Int]

Source

def toArray[B : ClassTag]: Array[B]

Преобразовать коллекцию в массив.

Примечание к реализации: НЕ вызывайте Array.from из этого метода.

Source@inline

final def toBuffer[B]: Buffer[B]

Source

def toIndexedSeq: IndexedSeq[Nothing]

Source

final override def toList: List[Nothing]

Source

def toMap[K, V](implicit ev: Nothing <:< (K, V)): Map[K, V]

Source

final override def toSeq: Nil.type

Source

def toSet[B]: Set[B]

Source

override def toString(): String

Source

def toVector: Vector[Nothing]

Source

def transpose[B](implicit asIterable: Nothing => Iterable[B]): List[List[B]]

Транспонирует эту итерируемую коллекцию итерируемых коллекций в итерируемую коллекцию итерируемых коллекций.

Тип результирующей коллекции будет определяться статическим типом итерируемой коллекции. Например:

val xs = List(
           Set(1, 2, 3),
           Set(4, 5, 6)).transpose
// xs == List(
//         List(1, 4),
//         List(2, 5),
//         List(3, 6))

val ys = Vector(
           List(1, 2, 3),
           List(4, 5, 6)).transpose
// ys == Vector(
//         Vector(1, 4),
//         Vector(2, 5),
//         Vector(3, 6))

Примечание: Даже при применении к представлению или ленивой коллекции она всегда будет принудительно использовать элементы.

Исходный код

def unapply(a: Int): Option[Nothing]

Попытка извлечь B из A в выражении сопоставления с образцом.

Исходный код

override def unzip3[A1, A2, A3](implicit asTriple: Nothing => (A1, A2, A3)): (Список[A1], Список[A2], Список[A3])

Исходный код

override def updated[B](index: Int, elem: B): Список[B]

Исходный код

override def view: SeqView[Nothing]

Исходный код

def withFilter(p: Nothing => Boolean): WithFilter[Nothing, Список]

Создает нестрогий фильтр этого итерируемого набора.

Примечание: разница между c filter p и c withFilter p заключается в том, что первый создает новый набор, а второй только ограничивает область действия последующих map, flatMap, foreach и withFilter операций.

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

Исходный код

override def zip[B](that: IterableOnce[B]): Список[(Nothing, B)]

Исходный код

def zipAll[A1, B](that: Iterable[B], thisElem: A1, thatElem: B): Список[(A1, B)]

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

Исходный код

override def zipWithIndex: Список[(Nothing, Int)]