W3cubDocs

/Scala 3.2

Object LazyList.LazyList

object LazyList extends SeqFactory[LazyList]

This object provides a set of operations to create Iterable values.

Supertypes	trait SeqFactory[LazyList] trait IterableFactory[LazyList] trait Serializable class Object trait Matchable class Any
Self type	LazyList.type

Classlikes

Source
object #::

Source
final class Deferrer[A] extends AnyVal

Source
final class SerializationProxy[A](var coll: LazyList[A]) extends Serializable

This serialization proxy is used for LazyLists which start with a sequence of evaluated cons cells. The forced sequence is serialized in a compact, sequential format, followed by the unevaluated tail, which uses standard Java serialization to store the complete structure of unevaluated thunks. This allows the serialization of long evaluated lazy lists without exhausting the stack through recursive serialization of cons cells.

Source
object cons

An alternative way of building and matching lazy lists using LazyList.cons(hd, tl).

Concrete methods

Source
override def concat[A](xss: Iterable[A]*): LazyList[A]

Concatenates all argument collections into a single lazy list.

Value parameters	xss the collections that are to be concatenated.
Returns	the concatenation of all the collections.
Definition Classes	IterableFactory

Source
def continually[A](elem: => A): LazyList[A]

Create an infinite LazyList containing the given element expression (which is computed for each occurrence).

Value parameters	elem the element composing the resulting LazyList
Returns	the LazyList containing an infinite number of elem

Source
def empty[A]: LazyList[A]

An empty collection

Type parameters	A the type of the lazy list's elements

Source
override def fill[A](n: Int)(elem: => A): LazyList[A]

Produces a lazy list containing the results of some element computation a number of times.

Value parameters	elem the element computation n the number of elements contained in the lazy list.
Returns	A lazy list that contains the results of `n` evaluations of `elem`.
Definition Classes	IterableFactory

Source
def from[A](coll: IterableOnce[A]): LazyList[A]

Creates a target lazy list from an existing source collection

Type parameters	A the type of the collection’s elements
Value parameters	source Source collection
Returns	a new lazy list with the elements of `source`

Source
def from(start: Int, step: Int): LazyList[Int]

Create an infinite LazyList starting at start and incrementing by step step.

Value parameters	start the start value of the LazyList step the increment value of the LazyList
Returns	the LazyList starting at value `start`.

Source
def from(start: Int): LazyList[Int]

Create an infinite LazyList starting at start and incrementing by 1.

Value parameters	start the start value of the LazyList
Returns	the LazyList starting at value `start`.

Source
def iterate[A](start: => A)(f: A => A): LazyList[A]

An infinite LazyList that repeatedly applies a given function to a start value.

Value parameters	f the function that's repeatedly applied start the start value of the LazyList
Returns	the LazyList returning the infinite sequence of values `start, f(start), f(f(start)), ...`

Source
def newBuilder[A]: Builder[A, LazyList[A]]

The builder returned by this method only evaluates elements of collections added to it as needed.

Type parameters	A the type of the lazy list’s elements
Returns	A builder for `LazyList` objects.

Source
override def tabulate[A](n: Int)(f: Int => A): LazyList[A]

Produces a lazy list containing values of a given function over a range of integer values starting from 0.

Value parameters	f The function computing element values n The number of elements in the lazy list
Returns	A lazy list consisting of elements `f(0), ..., f(n -1)`
Definition Classes	IterableFactory

Source
override def unfold[A, S](init: S)(f: S => Option[(A, S)]): LazyList[A]

Produces a lazy list that uses a function f to produce elements of type A and update an internal state of type S.

Type parameters	A Type of the elements S Type of the internal state
Value parameters	f Computes the next element (or returns `None` to signal the end of the collection) init State initial value
Returns	a lazy list that produces elements using `f` until `f` returns `None`
Definition Classes	IterableFactory

Inherited methods

Source
def apply[A](elems: A*): CC[A]

Creates a collection with the specified elements.

Type parameters	A the type of the collection's elements
Value parameters	elems the elements of the created collection
Returns	a new collection with elements `elems`
Inherited from	IterableFactory

Source
def fill[A](n1: Int, n2: Int, n3: Int, n4: Int, n5: Int)(elem: => A): CC[CC[CC[CC[CC[A]]]]]

Produces a five-dimensional collection containing the results of some element computation a number of times.

Value parameters	elem the element computation n1 the number of elements in the 1st dimension n2 the number of elements in the 2nd dimension n3 the number of elements in the 3rd dimension n4 the number of elements in the 4th dimension n5 the number of elements in the 5th dimension
Returns	A collection that contains the results of `n1 x n2 x n3 x n4 x n5` evaluations of `elem`.
Inherited from	IterableFactory

Source
def fill[A](n1: Int, n2: Int, n3: Int, n4: Int)(elem: => A): CC[CC[CC[CC[A]]]]

Produces a four-dimensional collection containing the results of some element computation a number of times.

Value parameters	elem the element computation n1 the number of elements in the 1st dimension n2 the number of elements in the 2nd dimension n3 the number of elements in the 3rd dimension n4 the number of elements in the 4th dimension
Returns	A collection that contains the results of `n1 x n2 x n3 x n4` evaluations of `elem`.
Inherited from	IterableFactory

Source
def fill[A](n1: Int, n2: Int, n3: Int)(elem: => A): CC[CC[CC[A]]]

Produces a three-dimensional collection containing the results of some element computation a number of times.

Value parameters	elem the element computation n1 the number of elements in the 1st dimension n2 the number of elements in the 2nd dimension n3 the number of elements in the 3rd dimension
Returns	A collection that contains the results of `n1 x n2 x n3` evaluations of `elem`.
Inherited from	IterableFactory

Source
def fill[A](n1: Int, n2: Int)(elem: => A): CC[CC[A]]

Produces a two-dimensional collection containing the results of some element computation a number of times.

Value parameters	elem the element computation n1 the number of elements in the 1st dimension n2 the number of elements in the 2nd dimension
Returns	A collection that contains the results of `n1 x n2` evaluations of `elem`.
Inherited from	IterableFactory

Source
def iterate[A](start: A, len: Int)(f: A => A): CC[A]

Produces a collection containing repeated applications of a function to a start value.

Value parameters	f the function that's repeatedly applied len the number of elements contained in the collection start the start value of the collection
Returns	a collection with `len` values in the sequence `start, f(start), f(f(start)), ...`
Inherited from	IterableFactory

Source
def range[A : Integral](start: A, end: A, step: A): CC[A]

Produces a collection containing equally spaced values in some integer interval.

Value parameters	end the end value of the collection (the first value NOT contained) start the start value of the collection step the difference between successive elements of the collection (must be positive or negative)
Returns	a collection with values `start, start + step, ...` up to, but excluding `end`
Inherited from	IterableFactory

Source
def range[A : Integral](start: A, end: A): CC[A]

Produces a collection containing a sequence of increasing of integers.

Value parameters	end the end value of the collection (the first value NOT contained) start the first element of the collection
Returns	a collection with values `start, start + 1, ..., end - 1`
Inherited from	IterableFactory

Source
def tabulate[A](n1: Int, n2: Int, n3: Int, n4: Int, n5: Int)(f: (Int, Int, Int, Int, Int) => A): CC[CC[CC[CC[CC[A]]]]]

Produces a five-dimensional collection containing values of a given function over ranges of integer values starting from 0.

Value parameters	f The function computing element values n1 the number of elements in the 1st dimension n2 the number of elements in the 2nd dimension n3 the number of elements in the 3rd dimension n4 the number of elements in the 4th dimension n5 the number of elements in the 5th dimension
Returns	A collection consisting of elements `f(i1, i2, i3, i4, i5)` for `0 <= i1 < n1`, `0 <= i2 < n2`, `0 <= i3 < n3`, `0 <= i4 < n4`, and `0 <= i5 < n5`.
Inherited from	IterableFactory

Source
def tabulate[A](n1: Int, n2: Int, n3: Int, n4: Int)(f: (Int, Int, Int, Int) => A): CC[CC[CC[CC[A]]]]

Produces a four-dimensional collection containing values of a given function over ranges of integer values starting from 0.

Value parameters	f The function computing element values n1 the number of elements in the 1st dimension n2 the number of elements in the 2nd dimension n3 the number of elements in the 3rd dimension n4 the number of elements in the 4th dimension
Returns	A collection consisting of elements `f(i1, i2, i3, i4)` for `0 <= i1 < n1`, `0 <= i2 < n2`, `0 <= i3 < n3`, and `0 <= i4 < n4`.
Inherited from	IterableFactory

Source
def tabulate[A](n1: Int, n2: Int, n3: Int)(f: (Int, Int, Int) => A): CC[CC[CC[A]]]

Produces a three-dimensional collection containing values of a given function over ranges of integer values starting from 0.

Value parameters	f The function computing element values n1 the number of elements in the 1st dimension n2 the number of elements in the 2nd dimension n3 the number of elements in the 3rd dimension
Returns	A collection consisting of elements `f(i1, i2, i3)` for `0 <= i1 < n1`, `0 <= i2 < n2`, and `0 <= i3 < n3`.
Inherited from	IterableFactory

Source
def tabulate[A](n1: Int, n2: Int)(f: (Int, Int) => A): CC[CC[A]]

Produces a two-dimensional collection containing values of a given function over ranges of integer values starting from 0.

Value parameters	f The function computing element values n1 the number of elements in the 1st dimension n2 the number of elements in the 2nd dimension
Returns	A collection consisting of elements `f(i1, i2)` for `0 <= i1 < n1` and `0 <= i2 < n2`.
Inherited from	IterableFactory

Source
final def unapplySeq[A](x: LazyList[A]): UnapplySeqWrapper[A]

Inherited from	SeqFactory

Implicits

Source
implicit def toDeferrer[A](l: => LazyList[A]): Deferrer[A]

Inherited implicits

Source
implicit def iterableFactory[A]: Factory[A, CC[A]]

Inherited from	IterableFactory

© 2002-2022 EPFL, with contributions from Lightbend.
Licensed under the Apache License, Version 2.0.
https://scala-lang.org/api/3.2.0/scala/collection/immutable/LazyList$.html

Object LazyList.LazyList

object LazyList extends SeqFactory[LazyList]

Classlikes

Source object #::

Source final class Deferrer[A] extends AnyVal

Source final class SerializationProxy[A](var coll: LazyList[A]) extends Serializable

Source object cons

Concrete methods

Source override def concat[A](xss: Iterable[A]*): LazyList[A]

Source def continually[A](elem: => A): LazyList[A]

Source def empty[A]: LazyList[A]

Source override def fill[A](n: Int)(elem: => A): LazyList[A]

Source def from[A](coll: IterableOnce[A]): LazyList[A]

Source def from(start: Int, step: Int): LazyList[Int]

Source def from(start: Int): LazyList[Int]

Source def iterate[A](start: => A)(f: A => A): LazyList[A]

Source def newBuilder[A]: Builder[A, LazyList[A]]

Source override def tabulate[A](n: Int)(f: Int => A): LazyList[A]

Source override def unfold[A, S](init: S)(f: S => Option[(A, S)]): LazyList[A]

Inherited methods

Source def apply[A](elems: A*): CC[A]

Source def fill[A](n1: Int, n2: Int, n3: Int, n4: Int, n5: Int)(elem: => A): CC[CC[CC[CC[CC[A]]]]]

Source def fill[A](n1: Int, n2: Int, n3: Int, n4: Int)(elem: => A): CC[CC[CC[CC[A]]]]

Source def fill[A](n1: Int, n2: Int, n3: Int)(elem: => A): CC[CC[CC[A]]]

Source def fill[A](n1: Int, n2: Int)(elem: => A): CC[CC[A]]

Source def iterate[A](start: A, len: Int)(f: A => A): CC[A]

Source def range[A : Integral](start: A, end: A, step: A): CC[A]

Source def range[A : Integral](start: A, end: A): CC[A]

Source def tabulate[A](n1: Int, n2: Int, n3: Int, n4: Int, n5: Int)(f: (Int, Int, Int, Int, Int) => A): CC[CC[CC[CC[CC[A]]]]]

Source def tabulate[A](n1: Int, n2: Int, n3: Int, n4: Int)(f: (Int, Int, Int, Int) => A): CC[CC[CC[CC[A]]]]

Source def tabulate[A](n1: Int, n2: Int, n3: Int)(f: (Int, Int, Int) => A): CC[CC[CC[A]]]

Source def tabulate[A](n1: Int, n2: Int)(f: (Int, Int) => A): CC[CC[A]]

Source final def unapplySeq[A](x: LazyList[A]): UnapplySeqWrapper[A]