Класс scala.collection.immutable.Inclusive

@SerialVersionUID(3L)

class Inclusive[T](start: T, end: T, step: T)(implicit num: Integral[T]) extends NumericRange[T]

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

Исходный код

override def copy(start: T, end: T, step: T): Inclusive[T]

Исходный код

def exclusive: Exclusive[T]

Наследуемые методы

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

final def ++[B >: T](suffix: IterableOnce[B]): IndexedSeq[B]

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

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

final override def ++:[B >: T](prefix: IterableOnce[B]): IndexedSeq[B]

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

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

final def +:[B >: T](elem: B): IndexedSeq[B]

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

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

final def :+[B >: T](elem: B): IndexedSeq[B]

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

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

final def :++[B >: T](suffix: IterableOnce[B]): IndexedSeq[B]

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

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

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

Исходный код

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)

Исходный код

def andThen[C](k: PartialFunction[T, C]): PartialFunction[Int, C]

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

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

Исходный код

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

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

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

Исходный код

override def appended[B >: T](elem: B): IndexedSeq[B]

Исходный код

override def appendedAll[B >: T](suffix: IterableOnce[B]): IndexedSeq[B]

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

def apply(idx: Int): T

Исходный код

def applyOrElse[A1 <: Int, B1 >: T](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 by(newStep: T): NumericRange[T]

Создает новый диапазон со значениями начала и конца этого диапазона и новым step.

Исходный код

override def canEqual(that: Any): Boolean

Исходный код

override def collect[B](pf: PartialFunction[T, B]): IndexedSeq[B]

Исходный код

def collectFirst[B](pf: PartialFunction[T, B]): Option[B]

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

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

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

Исходный код

def combinations(n: Int): Iterator[IndexedSeq[T]]

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

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

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

Source

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

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

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

Source@unspecialized

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

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

Source@inline

final override def concat[B >: T](suffix: IterableOnce[B]): IndexedSeq[B]

Source

override def contains[A1 >: T](x: A1): Boolean

Source

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

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

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

Source

def containsTyped(x: T): Boolean

Source

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Исходный код

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

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

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

Source

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

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

Source

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

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

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

Source

override def diff[B >: T](that: Seq[B]): IndexedSeq[T]

Source

def distinct: IndexedSeq[T]

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

Source

override def distinctBy[B](f: T => B): IndexedSeq[T]

Source

override def drop(n: Int): NumericRange[T]

Source

override def dropRight(n: Int): IndexedSeq[T]

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

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

Source

def dropWhile(p: T => Boolean): IndexedSeq[T]

Source

def elementWise: ElementWiseExtractor[Int, T]

Возвращает объект-экстрактор с методом 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: IndexedSeq[T]

Source

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

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

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

Source

override def equals(other: Any): Boolean

Source

def exists(p: T => Boolean): Boolean

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

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

Source

override def filter(pred: T => Boolean): IndexedSeq[T]

Source

override def filterNot(pred: T => Boolean): IndexedSeq[T]

Source

def find(p: T => Boolean): Option[T]

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

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

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

Source

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

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

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

Source

override def flatMap[B](f: T => IterableOnce[B]): IndexedSeq[B]

Source

override def flatten[B](implicit toIterableOnce: T => IterableOnce[B]): IndexedSeq[B]

Source

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

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

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

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

Source

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

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

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

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

Исходный код

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

Исходный код

def forall(p: T => Boolean): Boolean

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

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

Исходный код

override def foreach[@specialized U](f: T => U): Unit

Исходный код

protected def fromSpecific(coll: IterableOnce[T]): IndexedSeq[T]

Исходный код

def groupBy[K](f: T => K): Map[K, IndexedSeq[T]]

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

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

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

Исходный код

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

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

Источник

override def head: T

Источник

override def headOption: Option[T]

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

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

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

Источник

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

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

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

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

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

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

Источник

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

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

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

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

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

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

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

Источник

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

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

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

Источник

def indices: Range

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

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

Источник

override def init: NumericRange[T]

Source

def inits: Iterator[IndexedSeq[T]]

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

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

Source

override def intersect[B >: T](that: Seq[B]): IndexedSeq[T]

Source

def isDefinedAt(idx: Int): Boolean

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

Реализации методов apply и isDefinedAt преобразуют Seq[A] в PartialFunction[Int, A].

Source

override def isTraversableAgain: Boolean

Source

override def iterableFactory: SeqFactory[IndexedSeq]

Source

override def iterator: Iterator[T]

Source

override def knownSize: Int

Source

override def last: T

Source

def lastIndexOf[B >: T](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 >: T](that: Seq[B]): Int

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

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

Source

def lastIndexOfSlice[B >: T](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: T => Boolean): Int

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

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

Source

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

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

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

Исходный код

def lastOption: Option[T]

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

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

Исходный код

def lazyZip[B](that: Iterable[B]): LazyZip2[T, B, Inclusive[T]]

Аналогично 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)

Исходный код

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

Исходный код

final 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[T]

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

Исходный код

override def map[B](f: T => B): IndexedSeq[B]

Исходный код

override def max[T1 >: T](implicit ord: Ordering[T1]): T

Исходный код

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

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

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

Исходный код

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

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

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

Исходный код

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

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

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

Исходный код

override def min[T1 >: T](implicit ord: Ordering[T1]): T

Исходный код

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник@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, который может быть переопределен.

Источник

protected def newSpecificBuilder: Builder[T, IndexedSeq[T]]

Источник@deprecatedOverriding("nonEmpty is defined as !isEmpty; override isEmpty instead", "2.13.0")

def nonEmpty: Boolean

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

Источник

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

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

Источник

override def padTo[B >: T](len: Int, elem: B): IndexedSeq[B]

Источник

override def partition(p: T => Boolean): (IndexedSeq[T], IndexedSeq[T])

Источник

override def partitionMap[A1, A2](f: T => Either[A1, A2]): (IndexedSeq[A1], IndexedSeq[A2])

Source

override def patch[B >: T](from: Int, other: IterableOnce[B], replaced: Int): IndexedSeq[B]

Source

def permutations: Iterator[IndexedSeq[T]]

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

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

Source

override def prepended[B >: T](elem: B): IndexedSeq[B]

Source

override def prependedAll[B >: T](prefix: IterableOnce[B]): IndexedSeq[B]

Source

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

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

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

Source

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

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

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

Source

def reduceLeft[B >: T](op: (B, T) => B): B

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

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

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

Source

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

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

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

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

Source

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

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

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

Source

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

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

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

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

Source

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

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

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

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

Источник

override def reverse: NumericRange[T]

Источник

override def reverseIterator: Iterator[T]

Источник

override protected def reversed: Iterable[T]

Источник

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

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

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

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

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

Источник

override def sameElements[B >: T](o: IterableOnce[B]): Boolean

Источник

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

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

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

Источник

override def scanLeft[B](z: B)(op: (B, T) => B): IndexedSeq[B]

Источник

def scanRight[B](z: B)(op: (T, B) => B): IndexedSeq[B]

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

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

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

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

Пример:

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

Источник

override def search[B >: T](elem: B, from: Int, to: Int)(implicit ord: Ordering[B]): SearchResult

Источник

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

Источник

def segmentLength(p: T => Boolean, from: Int): Int

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

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

Источник

final def segmentLength(p: T => 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

Источник

override def slice(from: Int, until: Int): IndexedSeq[T]

Источник

def sliding(size: Int, step: Int): Iterator[IndexedSeq[T]]

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

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

Источник

def sliding(size: Int): Iterator[IndexedSeq[T]]

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

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

Источник

def sortBy[B](f: T => B)(implicit ord: Ordering[B]): IndexedSeq[T]

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

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

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

Сортировка стабильна. То есть элементы, которые равны (как определяется 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: (T, T) => Boolean): IndexedSeq[T]

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

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

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

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

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

Источник

override def sorted[B >: T](implicit ord: Ordering[B]): IndexedSeq[T]

Источник

override def span(p: T => Boolean): (IndexedSeq[T], IndexedSeq[T])

Источник

override def splitAt(n: Int): (NumericRange[T], NumericRange[T])

Source

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

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

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

Source

override def stepper[S <: Stepper[_]](implicit shape: StepperShape[T, S]): S & EfficientSplit

Source

override def sum[B >: T](implicit num: Numeric[B]): B

Source

override def tail: NumericRange[T]

Source

def tails: Iterator[IndexedSeq[T]]

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

Source

override def take(n: Int): NumericRange[T]

Source

override def takeRight(n: Int): IndexedSeq[T]

Коллекция, содержащая последние n элементы этой коллекции.

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

Source

def takeWhile(p: T => Boolean): IndexedSeq[T]

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

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

Source

override def tapEach[U](f: T => U): IndexedSeq[T]

Source

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

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

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

Source

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

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

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

Source@inline

final def toBuffer[B >: T]: Buffer[B]

Source

final override def toIndexedSeq: IndexedSeq[T]

Source

def toList: List[T]

Source

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

Source

final override def toSeq: Inclusive[T]

Source

def toSet[B >: T]: Set[B]

Source

override def toString: String

Source

def toVector: Вектор[T]

Source

def transpose[B](implicit asIterable: T => Iterable[B]): ИндексированныйПоследовательность[ИндексированныйПоследовательность[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))

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

Source

def unapply(a: Целое): Вариант[T]

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

Source

override def unzip[A1, A2](implicit asPair: T => (A1, A2)): (ИндексированныйПоследовательность[A1], ИндексированныйПоследовательность[A2])

Source

override def unzip3[A1, A2, A3](implicit asTriple: T => (A1, A2, A3)): (ИндексированныйПоследовательность[A1], ИндексированныйПоследовательность[A2], ИндексированныйПоследовательность[A3])

Source

override def updated[B >: T](index: Целое, elem: B): ИндексированныйПоследовательность[B]

Source

override def view: IndexedSeqView[T]

Source

def withFilter(p: T => Булево): WithFilter[T, ИндексированныйПоследовательность]

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

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

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

Source

override def zip[B](that: IterableOnce[B]): ИндексированныйПоследовательность[(T, B)]

Source

def zipAll[A1 >: T, B](that: Iterable[B], thisElem: A1, thatElem: B): ИндексированныйПоследовательность[(A1, B)]

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

Source

override def zipWithIndex: ИндексированныйПоследовательность[(T, Целое)]

Inherited fields

Source

lazy override val hashCode: Целое

Source

lazy override val isEmpty: Булево

Источник

val isInclusive: Boolean

Источник

lazy override val length: Int