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

object Empty extends Stream[Nothing]

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

Исходный код

def force: Empty.type

Вынуждает оценку всего Stream и возвращает её.

Исходный код

override def head: Nothing

Исходный код

override def isEmpty: Boolean

Исходный код

override def knownSize: Int

Исходный код

override def tail: Stream[Nothing]

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

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

final def ++[B](suffix: IterableOnce[B]): Stream[B]

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

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

final override def ++:[B](prefix: IterableOnce[B]): Stream[B]

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

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

final def +:[B](elem: B): Stream[B]

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

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

final def :+[B](elem: B): Stream[B]

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

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

final def :++[B](suffix: IterableOnce[B]): Stream[B]

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

Исходный код

override def addString(sb: StringBuilder, start: String, sep: String, end: String): StringBuilder

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

Неопределённые элементы представляются как "_", неопределённый хвост представляется как "<not computed>", а циклы представляются как "<cycle>".

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 andThen[C](k: PartialFunction[Nothing, C]): PartialFunction[Int, C]

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

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

Source

override def andThen[C](k: Nothing => C): PartialFunction[Int, C]

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

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

Source

def appended[B](elem: B): Stream[B]

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

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

Пример:

scala> val a = List(1)
a: List[Int] = List(1)

scala> val b = a :+ 2
b: List[Int] = List(1, 2)

scala> println(a)
List(1)

Исходный код

def appendedAll[B](suffix: IterableOnce[B]): Stream[B]

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

Исходный код@throws(scala.throws.$lessinit$greater$default$1[scala.IndexOutOfBoundsException])

override def apply(n: Int): Nothing

Исходный код

def applyOrElse[A1 <: Int, 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: Any): Boolean

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

final override def collect[B](pf: PartialFunction[Nothing, B]): Stream[B]

Source@tailrec

final override def collectFirst[B](pf: PartialFunction[Nothing, B]): Option[B]

Source

def combinations(n: Int): Iterator[Stream[Nothing]]

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

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

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

Source

def compose[R](k: PartialFunction[R, Int]): PartialFunction[R, Nothing]

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

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

Source@unspecialized

def compose[A](g: A => Int): A => Nothing

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

Source@inline

final override def concat[B](suffix: IterableOnce[B]): Stream[B]

Source

override def contains[A1](elem: A1): Boolean

Source

def containsSlice[B](that: Seq[B]): Boolean

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

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

Source

def copyToArray[B](xs: Array[B], start: Int, len: Int): Int

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

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

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

Source@deprecatedOverriding("This should always forward to the 3-arg version of this method", since = "2.13.4")

def copyToArray[B](xs: Array[B], start: Int): Int

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

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

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

Source@deprecatedOverriding("This should always forward to the 3-arg version of this method", since = "2.13.4")

def copyToArray[B](xs: Array[B]): Int

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

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

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

Источник

def corresponds[B](that: IterableOnce[B])(p: (Nothing, B) => Boolean): Boolean

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

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

Источник

def corresponds[B](that: Seq[B])(p: (Nothing, B) => Boolean): Boolean

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

Источник

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

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

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

Источник

def diff[B](that: Seq[B]): Stream[Nothing]

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

Источник

def distinct: Stream[Nothing]

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

Источник

def distinctBy[B](f: Nothing => B): Stream[Nothing]

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

Исходный код

def drop(n: Int): Stream[Nothing]

Исходный код

def dropRight(n: Int): Stream[Nothing]

Выбирает все элементы, кроме последних n.

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

Исходный код

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

Исходный код

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
}

Исходный код

override def empty: Stream[Nothing]

Исходный код

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

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

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

Source

override def equals(o: Any): Boolean

Source

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

Source

override def filter(pred: Nothing => Boolean): Stream[Nothing]

Source

override def filterNot(pred: Nothing => Boolean): Stream[Nothing]

Source@tailrec

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]): Stream[B]

Source

def flatten[B](implicit asIterable: Nothing => IterableOnce[B]): Stream[B]

Source

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

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

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

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

Source@tailrec

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

Специализация потока foldLeft, которая позволяет сборщику мусора собирать по ходу.

Source

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

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

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

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

Source

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

Source@tailrec

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

Применяет данную функцию f к каждому элементу этой линейной последовательности (при сохранении порядка элементов).

Исходный код

protected def fromSpecific(coll: IterableOnce[Nothing]): Stream[Nothing]

Исходный код

def groupBy[K](f: Nothing => K): Map[K, Stream[Nothing]]

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

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

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

Исходный код

def groupMap[K, B](key: Nothing => K)(f: Nothing => B): Map[K, Stream[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[Stream[Nothing]]

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

Исходный код

override def hashCode(): Int

Исходный код

override def headOption: Option[Nothing]

Исходный код@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

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

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

Исходный код

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

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

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

Источник

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

Источник@deprecatedOverriding("Override indexWhere(p, from) instead - indexWhere(p) calls indexWhere(p, 0)", "2.13.0")

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

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

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

Источник

def indices: Range

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

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

Источник

def init: Stream[Nothing]

Начальная часть коллекции без её последнего элемента.

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

Источник

def inits: Iterator[Stream[Nothing]]

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

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

Источник

def intersect[B](that: Seq[B]): Stream[Nothing]

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

Источник

override def isDefinedAt(x: Int): Boolean

Источник

override def isTraversableAgain: Boolean

Источник

override def iterableFactory: SeqFactory[Stream]

Источник

def iterator: Iterator[Nothing]

Источник

override def last: Nothing

Источник

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

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

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

Источник@deprecatedOverriding("Override lastIndexOfSlice(that, end) instead - lastIndexOfSlice(that) calls lastIndexOfSlice(that, Int.MaxValue)", "2.13.0")

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

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

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

Источник

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

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

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

Источник

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

Источник@deprecatedOverriding("Override lastIndexWhere(p, end) instead - lastIndexWhere(p) calls lastIndexWhere(p, Int.MaxValue)", "2.13.0")

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

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

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

Источник

def lastOption: Option[Nothing]

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

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

Источник

def lazyAppendedAll[B](suffix: => IterableOnce[B]): Stream[B]

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

Источник

def lazyZip[B](that: Iterable[B]): LazyZip2[Nothing, B, Empty.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)

Источник

def length: Int

Источник

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

Источник

override def lengthCompare(len: Int): Int

Источник@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

Источник

def lift: Int => Option[Nothing]

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

Источник

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

Источник

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

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

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

Источник

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, Stream[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

def padTo[B](len: Int, elem: B): Stream[B]

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

Source

override def partition(p: Nothing => Boolean): (Stream[Nothing], Stream[Nothing])

Source

def partitionMap[A1, A2](f: Nothing => Either[A1, A2]): (Stream[A1], Stream[A2])

Применяет функцию f к каждому элементу итерационной коллекции и возвращает пару итерационных коллекций: первая из значений, возвращаемых f, которые были заключены в scala.util.Left, и вторая из значений, заключенных в scala.util.Right.

Пример:

val xs = Iterable(1, "one", 2, "two", 3, "three") partitionMap {
 case i: Int => Left(i)
 case s: String => Right(s)
}
// xs == (Iterable(1, 2, 3),
//        Iterable(one, two, three))

Source

def patch[B](from: Int, other: IterableOnce[B], replaced: Int): Stream[B]

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

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

Source

def permutations: Iterator[Stream[Nothing]]

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

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

Source

final override def prepended[B](elem: B): Stream[B]

Source

def prependedAll[B](prefix: IterableOnce[B]): Stream[B]

Как и :++, возвращает новую коллекцию, содержащую элементы левого операнда, за которыми следуют элементы правого операнда.

Отличается от :++ тем, что правый операнд определяет тип результирующей коллекции, а не левый. Мемоническое правило: двоеточие стоит с той стороны, где находится новый тип коллекции.

Source

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

Перемножает элементы этой коллекции.

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

Источник

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

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

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

Источник

final override def reduceLeft[B](f: (B, Nothing) => B): B

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

Источник

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]

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

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

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

Источник

def reverse: Stream[Nothing]

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

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

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

Источник

def reverseIterator: Iterator[Nothing]

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

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

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

Источник

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): Поток[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: Int, to: Int)(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: Int): Int

Исходный код

final def segmentLength(p: Nothing => Boolean): Int

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

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

Исходный код

final override def size: Int

Исходный код

final override def sizeCompare(that: Iterable[_]): Int

Исходный код

final override def sizeCompare(otherSize: Int): Int

Исходный код@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

Исходный код

def slice(from: Int, until: Int): Поток[Nothing]

Источник

def sliding(size: Int, step: Int): Iterator[Stream[Nothing]]

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

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

Источник

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

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

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

Источник

def sortBy[B](f: Nothing => B)(implicit ord: Ordering[B]): Stream[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): Stream[Nothing]

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

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

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

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

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

Источник

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

Сортирует эту последовательность в соответствии с Ordering.

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

Источник

def span(p: Nothing => Boolean): (Stream[Nothing], Stream[Nothing])

Источник

override def splitAt(n: Int): (Stream[Nothing], Stream[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. Для шагов, помеченных scala.collection.Stepper.EfficientSplit, преобразователи в scala.jdk.StreamConverters позволяют создавать параллельные потоки, тогда как обычные шаги могут быть преобразованы только в последовательные потоки.

Источник

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

Суммирует элементы этой коллекции.

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

Источник

override def tails: Iterator[Stream[Nothing]]

Источник

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

Источник

def takeRight(n: Int): Stream[Nothing]

Выбирает последние n элементов.

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

Источник

def takeWhile(p: Nothing => Boolean): Stream[Nothing]

Возвращает самую длинную префиксную последовательность элементов, удовлетворяющих предикату.

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

Источник

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

Источник

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

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

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

Источник

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

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

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

Источник@inline

final def toBuffer[B]: Buffer[B]

Источник

def toIndexedSeq: IndexedSeq[Nothing]

Источник

def toList: List[Nothing]

Источник

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

Источник

final override def toSeq: Empty.type

Источник

def toSet[B]: Set[B]

Источник

override def toString: String

Источник

def toVector: Vector[Nothing]

Источник

def transpose[B](implicit asIterable: Nothing => Iterable[B]): Stream[Stream[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 в выражении сопоставления с образцом.

Источник

def unzip[A1, A2](implicit asPair: Nothing => (A1, A2)): (Stream[A1], Stream[A2])

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

val xs = Iterable(
           (1, "one"),
           (2, "two"),
           (3, "three")).unzip
// xs == (Iterable(1, 2, 3),
//        Iterable(one, two, three))

Источник

def unzip3[A1, A2, A3](implicit asTriple: Nothing => (A1, A2, A3)): (Stream[A1], Stream[A2], Stream[A3])

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

val xs = Iterable(
           (1, "one", '1'),
           (2, "two", '2'),
           (3, "three", '3')).unzip3
// xs == (Iterable(1, 2, 3),
//        Iterable(one, two, three),
//        Iterable(1, 2, 3))

Источник

def updated[B](index: Int, elem: B): Stream[B]

Копия этого последовательности с заменой одного элемента.

Источник

override def view: SeqView[Nothing]

Источник

final override def withFilter(p: Nothing => Boolean): WithFilter[Nothing, Stream]

collection.WithFilter , позволяющий GC заголовка потока во время обработки

Источник

final override def zip[B](that: IterableOnce[B]): Stream[(Nothing, B)]

Источник

def zipAll[A1, B](that: Iterable[B], thisElem: A1, thatElem: B): Stream[(A1, B)]

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

Source

final override def zipWithIndex: Stream[(Nothing, Int)]