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

Проверка двух объектов на неравенство.

Эквивалентно x.hashCode за исключением упакованных числовых типов и null. Для чисел возвращается значение хэша, согласованное с равенством значений: если два экземпляра типа значения сравниваются как true, то ## вернёт одинаковое значение хэша для каждого из них. Для null возвращает хэш-код, где null.hashCode вызывает NullPointerException.

Создаёт LazyList, содержащую заданный первый элемент, за которым следуют элементы из другого LazyList.

Создаёт LazyList, представляющую собой конкатенацию заданного LazyList и другого LazyList.

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

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

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

Обратите внимание, что операторы с окончанием :- ассоциативны справа (см. пример). Мnemonic for +: vs. :+ is: the COLon goes on the COLlection side.

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

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

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

Выражение x == that эквивалентно if (x eq null) that eq null else x.equals(that).

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

Неопределенное состояние представлено как "<not computed>", а циклы — как "<cycle>".

Этот метод оценивает все элементы коллекции.

Добавляет все элементы этой коллекции в строковый буфер. Записываемый текст состоит из строковых представлений (относительно метода 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

Добавляет все элементы этого набора в строку-построитель с использованием разделительной строки. Текст состоит из строковых представлений (относительно метода 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

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

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

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

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

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

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

Пример:

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)

Этот метод сохраняет ленивость; элементы оцениваются индивидуально по мере необходимости.

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

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

Этот метод сохраняет ленивость; элементы оцениваются индивидуально по мере необходимости.

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

Получение элемента по указанному индексу. Эта операция предоставляется для удобства в Seq. Не следует предполагать, что она эффективна, если у вас нет IndexedSeq.

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

Обратите внимание, что выражение 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 . Это может привести к лучшей производительности и более предсказуемому поведению в отношении побочных эффектов.

Преобразует объект-получатель к типу T0.

Обратите внимание, что успех преобразования во время выполнения зависит от семантики стирания Scala. Поэтому выражение 1.asInstanceOf[String] выбросит исключение ClassCastException во время выполнения, в то время как выражение List(1).asInstanceOf[List[String]] этого не сделает. В последнем примере, поскольку тип аргумента стирается во время компиляции, невозможно проверить, соответствуют ли содержимое списка требуемому типу.

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

Определяет префикс представления этого объекта в toString.

Рекомендуется возвращать имя конкретного типа коллекции, но не подклассы реализации. Например, для ListMap этот метод должен возвращать "ListMap", а не "Map" (супертип) или "Node" (подкласс реализации).

По умолчанию возвращается "Iterable". Он переопределён для основных типов коллекций "Seq", "IndexedSeq", "LinearSeq", "Buffer", "Set", "Map", "SortedSet", "SortedMap" и "View".

Создаёт копию объекта-приёмника.

По умолчанию реализация метода clone зависит от платформы.

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

Этот метод сохраняет ленивость; элементы оцениваются индивидуально по мере необходимости.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Этот метод сохраняет леность; элементы оцениваются индивидуально только по мере необходимости.

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

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

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

Этот метод ничего не вычисляет, пока над результатом не выполняется операция (например, вызов head или tail, или проверка на пустоту). Кроме того, он сохраняет ленивость для всех, кроме первых n элементов.

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

Этот метод ничего не вычисляет, пока над результатом не выполняется операция (например, вызов head или tail, или проверка на пустоту).

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

Этот метод ничего не вычисляет до тех пор, пока над результатом не выполняется операция (например, вызов head или tail, или проверка на пустоту). Кроме того, он сохраняет ленивость для всех элементов после того, как предикат возвращает false.

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

Пустой итерируемый объект того же типа, что и этот итерируемый объект

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

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

Проверяет, является ли аргумент (that) ссылкой на объект-получатель (this).

Метод eq реализует отношение эквивалентности на непустых экземплярах AnyRef, и обладает тремя дополнительными свойствами:

Он согласован: для любых непустых экземпляров x и y типа AnyRef, многократные вызовы x.eq(y) последовательно возвращают true или последовательно возвращают false. Для любого непустого экземпляра x типа AnyRef, вызовы x.eq(null) и null.eq(x) возвращают false. null.eq(null) возвращает true.

При переопределении методов equals или hashCode важно обеспечить согласованность их поведения с равенством по ссылке. Поэтому, если два объекта ссылаются друг на друга (o1 eq o2), они должны быть равны друг другу (o1 == o2) и должны иметь одинаковый хэш-код (o1.hashCode == o2.hashCode).

Универсальный метод равенства, определённый в AnyRef.

Этот метод оценивает все элементы коллекции.

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

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

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

Этот метод сохраняет ленивость; элементы оцениваются индивидуально только по мере необходимости.

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

Этот метод сохраняет ленивость; элементы оцениваются индивидуально только по мере необходимости.

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

Детали того, когда и если метод finalize вызывается, а также взаимодействие между finalize и нелокальными возвратами и исключениями зависят от платформы.

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

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

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

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

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

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

Например:

def getWords(lines: Seq[String]): Seq[String] = lines flatMap (line => line split "\\W+")

Тип результирующей коллекции определяется статическим типом ленивого списка. Это может иногда приводить к неожиданным результатам. Например:

// lettersOf will return a Seq[Char] of likely repeated letters, instead of a Set
def lettersOf(words: Seq[String]) = words flatMap (word => word.toSet)

// lettersOf will return a Set[Char], not a Seq
def lettersOf(words: Seq[String]) = words.toSet flatMap ((word: String) => word.toSeq)

// xs will be an Iterable[Int]
val xs = Map("a" -> List(11,111), "b" -> List(22,222)).flatMap(_._2)

// ys will be a Map[Int, Int]
val ys = Map("a" -> List(1 -> 11,1 -> 111), "b" -> List(2 -> 22,2 -> 222)).flatMap(_._2)

Этот метод сохраняет ленивость; элементы вычисляются только по мере необходимости.

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

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

val xs = List(
           Set(1, 2, 3),
           Set(1, 2, 3)
         ).flatten
// xs == List(1, 2, 3, 1, 2, 3)

val ys = Set(
           List(1, 2, 3),
           List(3, 2, 1)
         ).flatten
// ys == Set(1, 2, 3)

Этот метод сохраняет ленивость; элементы оцениваются индивидуально только по мере необходимости.

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

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

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

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

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

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

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

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

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

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

Этот метод обнаруживает циклы в ленивых списках и завершается после вычисления всех элементов цикла. Например:

val ring: LazyList[Int] = 1 #:: 2 #:: 3 #:: ring
ring.force
ring.toString

// prints
//
// LazyList(1, 2, 3, ...)

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

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

Возвращает строку, отформатированную в соответствии с заданной строкой format. Строки формата такие же, как у String.format (@see java.lang.String.format).

Определяет, как преобразовать заданный Iterable[A] в коллекцию типа C.

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

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

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

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

Разделяет эту итерируемую коллекцию на карту итерируемых коллекций в соответствии с функцией-дискриминатором 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)

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

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

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

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

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

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

Итератор, возвращаемый этим методом, в основном сохраняет леность; один элемент перед итератором оценивается.

Метод hashCode для ссылочных типов. См. hashCode в scala.Any.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Этот метод сохраняет ленивость; элементы оцениваются индивидуально только по мере необходимости.

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

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

Проверяет, является ли ленивый список пустым.

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

Проверяет, является ли динамический тип объекта-получателя T0.

Обратите внимание, что результат проверки учитывается в соответствии с семантикой стирания Scala. Поэтому выражение 1.isInstanceOf[String] вернет false, а выражение List(1).isInstanceOf[List[String]] вернет true. В последнем примере, поскольку тип аргумента стирается во время компиляции, проверить, содержат ли содержимое списка указанный тип, невозможно.

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

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

Итератор может быть использован только один раз

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

Этот метод сохраняет ленивость; элементы оцениваются только индивидуально по мере необходимости.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Этот метод сохраняет ленивость; элементы оцениваются индивидуально по мере необходимости.

Примечание: Повторное цепочное вызов методов append (appended, appendedAll, lazyAppendedAll) без принудительного вычисления промежуточных ленивых списков может привести к переполнению стека при вычислении конечного результата.

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

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

collection.LazyZip2 возвращаемое этим методом сохраняет ленивость; элементы оцениваются индивидуально по мере необходимости.

Длина (количество элементов) последовательности. size является псевдонимом для length в Seq коллекциях.

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

Сравнивает длину этой последовательности со значением теста.

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

Эти операции реализованы в терминах 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

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

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

Этот метод сохраняет ленивость; элементы оцениваются индивидуально только по мере необходимости.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Эквивалентно !(this eq that).

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

Разбуждает единственную нить, ожидающую монитор объекта-приёмника.

Разбуждает все нити, ожидающие монитор объекта-приёмника.

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

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

Этот метод сохраняет ленивость; элементы оцениваются индивидуально по мере необходимости.

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

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

Этот метод сохраняет ленивость; элементы вычисляются индивидуально только по мере необходимости.

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

Пример:

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

Этот метод сохраняет ленивость; элементы вычисляются индивидуально только по мере необходимости.

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

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

Этот метод сохраняет ленивость; элементы оцениваются индивидуально только по мере необходимости.

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

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

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

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

Пример:

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

scala> val y = 2 +: x
y: List[Int] = List(2, 1)

scala> println(x)
List(1)

Этот метод сохраняет ленивость; элементы оцениваются индивидуально только по мере необходимости.

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

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

Этот метод сохраняет ленивость; элементы оцениваются индивидуально только по мере необходимости.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Этот метод оценивает все элементы набора.

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

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

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

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

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

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

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

Являются ли элементы этого набора одинаковыми (и в том же порядке) что и элементы that?

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

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

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

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

Этот метод сохраняет ленивость; элементы оцениваются индивидуально только по мере необходимости.

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

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

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

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

Пример:

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

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

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

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

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

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

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

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

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

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

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

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

Сравнивает размер этой последовательности со значением теста.

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

Эти операции реализованы с помощью 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

Выбирает интервал элементов. Возвращаемый ленивый список состоит из всех элементов x, которые удовлетворяют инварианту:

from <= indexOf(x) < until

Этот метод не вычисляет ничего до тех пор, пока операция не будет выполнена над результатом (например, вызов head или tail, или проверка, пуст ли он). Кроме того, он сохраняет ленивость для всех, кроме первых from элементов.

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

Итератор, возвращаемый этим методом, в основном сохраняет ленивость; size - step max 1 элементы перед итератором вычисляются.

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

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

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

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

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

Сортирует эту последовательность согласно функции сравнения.

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

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

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

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

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

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

Примечание: c span p эквивалентно (но, возможно, более эффективно, чем) (c takeWhile p, c dropWhile p), при условии, что вычисление предиката p не вызывает побочных эффектов.

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

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

Примечание: c splitAt n эквивалентно (но, возможно, более эффективно, чем) (c take n, c drop n).

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

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

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

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

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

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

Для наборов с типами Int, Short, Byte или Char, возвращается IntStepper.Для наборов с типами Double или Float, возвращается DoubleStepper.Для наборов с типом Long, возвращается LongStepper.Для любого другого типа элементов возвращается AnyStepper.

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

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

Остальная часть коллекции без первого элемента.

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

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

Этот метод сохраняет леность; элементы оцениваются индивидуально по мере необходимости.

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

Этот метод ничего не вычисляет, пока над результатом не выполняется операция (например, вызов head или tail, или проверка на пустоту).

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

Этот метод сохраняет ленивость; элементы оцениваются индивидуально по мере необходимости.

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

Этот метод сохраняет ленивость; элементы оцениваются индивидуально по мере необходимости.

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

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

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

Этот метод сохраняет ленивость; элементы вычисляются только по мере необходимости.

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

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

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

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

Этот метод оценивает все элементы коллекции.

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

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

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

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

Этот метод сохраняет ленивость; элементы оцениваются индивидуально только по мере необходимости.

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

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

Этот метод сохраняет ленивость; элементы оцениваются индивидуально только по мере необходимости.

Копия этого ленивого списка с одним заменённым элементом.

Этот метод сохраняет ленивость; элементы оцениваются индивидуально только по мере необходимости.

Вид на элементы этого набора.

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

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

Возвращаемый collection.WithFilter этим методом сохраняет ленивость; элементы оцениваются индивидуально только по мере необходимости.

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

Этот метод сохраняет ленивость; элементы оцениваются индивидуально только по мере необходимости.

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

Этот метод сохраняет ленивость; элементы оцениваются индивидуально только по мере необходимости.

Объединяет этот ленивый список со своими индексами.

Этот метод сохраняет ленивость; элементы оцениваются индивидуально только по мере необходимости.