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

@SerialVersionUID(3L)

final class LazyList[+A] extends AbstractSeq[A] with LinearSeq[A] with LinearSeqOps[A, LazyList, LazyList[A]] with IterableFactoryDefaults[A, LazyList] with Serializable

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

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

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

Насколько ленивым является LazyList? Когда у вас есть значение типа LazyList, вы ещё не знаете, пустой ли список или нет. Если вы узнаете, что он не пустой, то вы также знаете, что голова была вычислена. Но хвост сам по себе является LazyList, чья пустота или не пустота может остаться неопределенной.

LazyList может быть бесконечным. Например, LazyList.from(0) содержит все натуральные числа 0, 1, 2 и так далее. Для бесконечных последовательностей некоторые методы (такие как count, sum, max или min) не завершатся.

Вот пример:

import scala.math.BigInt
object Main extends App {
  val fibs: LazyList[BigInt] =
    BigInt(0) #:: BigInt(1) #:: fibs.zip(fibs.tail).map{ n => n._1 + n._2 }
  fibs.take(5).foreach(println)
}

// prints
//
// 0
// 1
// 1
// 2
// 3

Чтобы проиллюстрировать, добавим немного вывода к определению fibs, чтобы увидеть, что происходит.

import scala.math.BigInt
object Main extends App {
  val fibs: LazyList[BigInt] =
    BigInt(0) #:: BigInt(1) #::
      fibs.zip(fibs.tail).map{ n =>
        println(s"Adding ${n._1} and ${n._2}")
        n._1 + n._2
      }
  fibs.take(5).foreach(println)
  fibs.take(6).foreach(println)
}

// prints
//
// 0
// 1
// Adding 0 and 1
// 1
// Adding 1 and 1
// 2
// Adding 1 and 2
// 3

// And then prints
//
// 0
// 1
// 1
// 2
// 3
// Adding 2 and 3
// 5

Обратите внимание, что определение fibs использует val , а не def. Кэширование LazyList требует наличия места для хранения информации, и val позволяет это сделать.

Дополнительные замечания о семантике LazyList:

- Хотя LazyList изменяется при обращении к нему, это не противоречит его неизменяемости. После того, как значения кэшированы, они не изменяются. Значения, которые ещё предстоит кэшировать, всё ещё «существуют», просто они ещё не вычислены.

- Следует проявлять осторожность при использовании кэширования; оно может потреблять много памяти, если вы не будете внимательны. Это потому, что кэширование LazyList создаёт структуру, очень похожую на scala.collection.immutable.List. Пока что-то держит за голову, голова держит за хвост, и так далее рекурсивно. Если, с другой стороны, ничего не держит за голову (например, если мы использовали def для определения LazyList), то как только она больше не используется напрямую, она исчезает.

- Обратите внимание, что некоторые операции, включая drop, dropWhile, flatMap или collect могут обработать большое количество промежуточных элементов, прежде чем вернуть результат.

Вот ещё один пример. Начнём с натуральных чисел и перейдём по ним.

// We'll start with a silly iteration
def loop(s: String, i: Int, iter: Iterator[Int]): Unit = {
  // Stop after 200,000
  if (i < 200001) {
    if (i % 50000 == 0) println(s + i)
    loop(s, iter.next(), iter)
  }
}

// Our first LazyList definition will be a val definition
val lazylist1: LazyList[Int] = {
  def loop(v: Int): LazyList[Int] = v #:: loop(v + 1)
  loop(0)
}

// Because lazylist1 is a val, everything that the iterator produces is held
// by virtue of the fact that the head of the LazyList is held in lazylist1
val it1 = lazylist1.iterator
loop("Iterator1: ", it1.next(), it1)

// We can redefine this LazyList such that all we have is the Iterator left
// and allow the LazyList to be garbage collected as required.  Using a def
// to provide the LazyList ensures that no val is holding onto the head as
// is the case with lazylist1
def lazylist2: LazyList[Int] = {
  def loop(v: Int): LazyList[Int] = v #:: loop(v + 1)
  loop(0)
}
val it2 = lazylist2.iterator
loop("Iterator2: ", it2.next(), it2)

// And, of course, we don't actually need a LazyList at all for such a simple
// problem.  There's no reason to use a LazyList if you don't actually need
// one.
val it3 = new Iterator[Int] {
  var i = -1
  def hasNext = true
  def next(): Int = { i += 1; i }
}
loop("Iterator3: ", it3.next(), it3)

- В примере fibs ранее, тот факт, что tail вообще работает, представляет интерес. fibs имеет начальное (0, 1, LazyList(...)), поэтому tail является детерминированным. Если бы мы определили fibs таким образом, чтобы только 0 были конкретно известны, то акт определения tail потребовал бы вычисления tail, поэтому вычисление не смогло бы продвинуться, как в этом коде:

// The first time we try to access the tail we're going to need more
// information which will require us to recurse, which will require us to
// recurse, which...
lazy val sov: LazyList[Vector[Int]] = Vector(0) #:: sov.zip(sov.tail).map { n => n._1 ++ n._2 }

Определение fibs выше создаёт больше объектов, чем необходимо, в зависимости от того, как вы можете его реализовать. Следующая реализация предоставляет более «эффективную» реализацию из-за того, что имеет более прямой путь к самим числам:

lazy val fib: LazyList[Int] = {
  def loop(h: Int, n: Int): LazyList[Int] = h #:: loop(n, h + n)
  loop(1, 1)
}

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

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

Только когда он дальше оценивается (что может и не произойти!), любые элементы заставляются.

например:

def tailWithSideEffect: LazyList[Nothing] = {
  println("getting empty LazyList")
  LazyList.empty
}

val emptyTail = tailWithSideEffect // prints "getting empty LazyList"

val suspended = 1 #:: tailWithSideEffect // doesn't print anything
val tail = suspended.tail // although the tail is evaluated, *still* nothing is yet printed
val filtered = tail.filter(_ => false) // still nothing is printed
filtered.isEmpty // prints "getting empty LazyList"

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

Исходный код

def #::[B >: A](elem: => B): LazyList[B]

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

Исходный код

def #:::[B >: A](prefix: LazyList[B]): LazyList[B]

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

Исходный код

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

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

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

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

Исходный код

override def appended[B >: A](elem: B): LazyList[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)

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

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

Source

override def appendedAll[B >: A](suffix: IterableOnce[B]): LazyList[B]

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

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

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

Source

override def collect[B](pf: PartialFunction[A, B]): LazyList[B]

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

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

Source@tailrec

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

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

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

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

Source

override def diff[B >: A](that: Seq[B]): LazyList[A]

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

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

Source

override def drop(n: Int): LazyList[A]

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

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

Source

override def dropRight(n: Int): LazyList[A]

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

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

Source

override def dropWhile(p: A => Boolean): LazyList[A]

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

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

Source

override def filter(pred: A => Boolean): LazyList[A]

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

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

Source

override def filterNot(pred: A => Boolean): LazyList[A]

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

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

Source@tailrec

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

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

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

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

Source

override def flatMap[B](f: A => IterableOnce[B]): LazyList[B]

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

Например:

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)

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

Source

override def flatten[B](implicit asIterable: A => IterableOnce[B]): LazyList[B]

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

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

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)

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

Source@tailrec

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

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

Source

def force: LazyList[A]

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

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

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

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

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

Source@tailrec

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

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

Source

override def grouped(size: Int): Iterator[LazyList[A]]

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

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

Source

override def head: A

Source

override def intersect[B >: A](that: Seq[B]): LazyList[A]

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

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

Source

override def isEmpty: Boolean

Source

override def iterableFactory: SeqFactory[LazyList]

Source

override def iterator: Iterator[A]

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

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

Source

override def knownSize: Int

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

Source

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

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

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

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

Source

override def lazyZip[B](that: Iterable[B]): LazyZip2[A, B, LazyList[A]]

Аналогично 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 сохраняет ленивость; элементы оцениваются индивидуально по мере необходимости.

Source

override def map[B](f: A => B): LazyList[B]

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

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

Source

override def padTo[B >: A](len: Int, elem: B): LazyList[B]

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

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

Source

override def partition(p: A => Boolean): (LazyList[A], LazyList[A])

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

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

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

Source

override def partitionMap[A1, A2](f: A => Either[A1, A2]): (LazyList[A1], LazyList[A2])

Применяет функцию 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))

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

Source

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

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

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

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

Исходный код

override def prepended[B >: A](elem: B): LazyList[B]

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

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

Пример:

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)

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

Исходный код

override def prependedAll[B >: A](prefix: IterableOnce[B]): LazyList[B]

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

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

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

Исходный код

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

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

Исходный код

override def reverse: LazyList[A]

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

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

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

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

Исходный код

override def scanLeft[B](z: B)(op: (B, A) => B): LazyList[B]

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

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

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

Исходный код

override def slice(from: Int, until: Int): LazyList[A]

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

from <= indexOf(x) < until

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

Исходный код

override def sliding(size: Int, step: Int): Iterator[LazyList[A]]

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

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

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

Исходный код

override def tail: LazyList[A]

Исходный код

override def take(n: Int): LazyList[A]

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

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

Исходный код

override def takeRight(n: Int): LazyList[A]

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

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

Исходный код

override def takeWhile(p: A => Boolean): LazyList[A]

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

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

Исходный код

override def tapEach[U](f: A => U): LazyList[A]

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

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

Исходный код

override def toString(): String

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

Исходный код

override def transpose[B](implicit asIterable: A => Iterable[B]): LazyList[LazyList[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))

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

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

Исходный код

override def unzip[A1, A2](implicit asPair: A => (A1, A2)): (LazyList[A1], LazyList[A2])

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

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

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

Исходный код

override def unzip3[A1, A2, A3](implicit asTriple: A => (A1, A2, A3)): (LazyList[A1], LazyList[A2], LazyList[A3])

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

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

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

Исходный код

override def updated[B >: A](index: Int, elem: B): LazyList[B]

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

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

Исходный код

override def withFilter(p: A => Boolean): WithFilter[A, LazyList]

Фильтр, который позволяет GC головы ленивого списка во время обработки.

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

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

Исходный код

override def zip[B](that: IterableOnce[B]): LazyList[(A, B)]

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

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

Исходный код

override def zipAll[A1 >: A, B](that: Iterable[B], thisElem: A1, thatElem: B): LazyList[(A1, B)]

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

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

Исходный код

override def zipWithIndex: LazyList[(A, Int)]

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

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

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

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

final def ++[B >: A](suffix: IterableOnce[B]): LazyList[B]

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

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

final override def ++:[B >: A](prefix: IterableOnce[B]): LazyList[B]

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

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

final def +:[B >: A](elem: B): LazyList[B]

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

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

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

final def :+[B >: A](elem: B): LazyList[B]

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

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

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

final def :++[B >: A](suffix: IterableOnce[B]): LazyList[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 andThen[C](k: PartialFunction[A, C]): PartialFunction[Int, C]

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

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

Источник

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

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

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

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

override def apply(n: Int): A

Источник

def applyOrElse[A1 <: Int, B1 >: A](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

Источник

def combinations(n: Int): Iterator[LazyList[A]]

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

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

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

Источник

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

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

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

Источник@unspecialized

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

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

Источник@inline

final override def concat[B >: A](suffix: IterableOnce[B]): LazyList[B]

Источник

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

Источник

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

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

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

Источник

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Источник

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

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

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

Источник

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

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

Исходный код

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

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

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

Исходный код

def distinct: LazyList[A]

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

Исходный код

def distinctBy[B](f: A => B): LazyList[A]

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

Исходный код

def elementWise: ElementWiseExtractor[Int, A]

Возвращает объект извлекателя с методом 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: LazyList[A]

Исходный код

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

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

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

Исходный код

override def equals(o: Any): Boolean

Исходный код

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

Исходный код

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

Исходный код

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

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

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

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

Исходный код

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

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

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

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

Исходный код

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

Исходный код

protected def fromSpecific(coll: IterableOnce[A]): LazyList[A]

Исходный код

def groupBy[K](f: A => K): Map[K, LazyList[A]]

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

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

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

Исходный код

def groupMap[K, B](key: A => K)(f: A => B): Map[K, LazyList[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: A => K)(f: A => 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)(_ + _)

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

Исходный код

override def hashCode(): Int

Исходный код

override def headOption: Option[A]

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

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

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

Source

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

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

Source@deprecatedOverriding("Override indexOfSlice(that, from) instead - indexOfSlice(that) calls indexOfSlice(that, 0)", "2.13.0")

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

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

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

Source

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

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

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

Source

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

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

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

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

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

Source

def indices: Range

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

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

Source

def init: LazyList[A]

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

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

Source

def inits: Iterator[LazyList[A]]

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

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

Source

override def isDefinedAt(x: Int): Boolean

Source

override def isTraversableAgain: Boolean

Source

override def last: A

Source

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

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

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

Источник

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

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

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

Источник

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

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

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

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

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

Источник

def lastOption: Option[A]

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

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

Источник

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[A]

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

Источник

def max[B >: A](implicit ord: Ordering[B]): A

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник

def min[B >: A](implicit ord: Ordering[B]): A

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник@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[A, LazyList[A]]

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

def nonEmpty: Boolean

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

Источник

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

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

Источник

def permutations: Iterator[LazyList[A]]

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

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

Источник

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

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

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

Источник

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

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

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

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

Источник

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

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

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

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

Источник

def reverseIterator: Iterator[A]

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

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

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

Источник

protected def reversed: Iterable[A]

Источник

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

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

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

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

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

Источник

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

Источник

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

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

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

Источник

def scanRight[B](z: B)(op: (A, B) => B): LazyList[B]

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

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

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

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

Пример:

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

Источник

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

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

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

Источник

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

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

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

Источник

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

Источник

final def segmentLength(p: A => 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 sliding(size: Int): Iterator[LazyList[A]]

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

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

Источник

def sortBy[B](f: A => B)(implicit ord: Ordering[B]): LazyList[A]

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

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

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

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

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

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

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

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

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

Источник

def sorted[B >: A](implicit ord: Ordering[B]): LazyList[A]

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

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

Источник

def span(p: A => Boolean): (LazyList[A], LazyList[A])

Источник

override def splitAt(n: Int): (LazyList[A], LazyList[A])

Источник

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

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

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

Источник

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

Возвращает scala.collection.Stepper для элементов этой коллекции.

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

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

• Для коллекций Int, Short, Byte или Char, возвращается scala.collection.IntStepper

• Для коллекций Double или Float, возвращается scala.collection.DoubleStepper

• Для коллекций Long, возвращается scala.collection.LongStepper

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

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

Источник

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

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

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

Источник

override def tails: Iterator[LazyList[A]]

Источник

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

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

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

Источник

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

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

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

Источник@inline

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

Source

def toIndexedSeq: IndexedSeq[A]

Source

def toList: List[A]

Source

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

Source

final override def toSeq: LazyList[A]

Source

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

Source

def toVector: Vector[A]

Source

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

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

Source

override def view: SeqView[A]