LazyList

Type Members

type Coll = LazyList[_]

Attributes
protected[this]
Definition Classes
GenericCompanion
final class Deferrer[A] extends AnyVal
class GenericCanBuildFrom[A] extends CanBuildFrom[CC[_], A, CC[A]]

Definition Classes
GenTraversableFactory
class LazyListCanBuildFrom[A] extends GenericCanBuildFrom[A]
final class SerializationProxy[A] extends Serializable

This serialization proxy is used for LazyLists which start with a sequence of evaluated cons cells.
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.

Annotations
@SerialVersionUID()

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
object #::
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def ReusableCBF: GenericCanBuildFrom[Nothing]

Definition Classes
GenTraversableFactory
def apply[A](elems: A*): LazyList[A]

Definition Classes
LazyList → GenericCompanion
final def asInstanceOf[T0]: T0

Definition Classes
Any
implicit def canBuildFrom[A]: CanBuildFrom[Coll, A, LazyList[A]]
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def concat[A](xss: Iterable[A]*): LazyList[A]
def concat[A](xss: Traversable[A]*): LazyList[A]

Definition Classes
GenTraversableFactory
object cons

An alternative way of building and matching lazy lists using LazyList.cons(hd, tl).
def continually[A](elem: ⇒ A): LazyList[A]

Create an infinite LazyList containing the given element expression (which is computed for each occurrence).
Create an infinite LazyList containing the given element expression (which is computed for each occurrence).
elem
the element composing the resulting LazyList
returns
the LazyList containing an infinite number of elem
def empty[A]: LazyList[A]

Definition Classes
LazyList → GenericCompanion
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def fill[A](n: Int)(elem: ⇒ A): LazyList[A]

Definition Classes
LazyList → GenTraversableFactory
def fill[A](n1: Int, n2: Int, n3: Int, n4: Int, n5: Int)(elem: ⇒ A): LazyList[LazyList[LazyList[LazyList[LazyList[A]]]]]

Definition Classes
GenTraversableFactory
def fill[A](n1: Int, n2: Int, n3: Int, n4: Int)(elem: ⇒ A): LazyList[LazyList[LazyList[LazyList[A]]]]

Definition Classes
GenTraversableFactory
def fill[A](n1: Int, n2: Int, n3: Int)(elem: ⇒ A): LazyList[LazyList[LazyList[A]]]

Definition Classes
GenTraversableFactory
def fill[A](n1: Int, n2: Int)(elem: ⇒ A): LazyList[LazyList[A]]

Definition Classes
GenTraversableFactory
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def from(start: Int): LazyList[Int]

Create an infinite LazyList starting at start and incrementing by 1.
Create an infinite LazyList starting at start and incrementing by 1.
start
the start value of the LazyList
returns
the LazyList starting at value start.
def from(start: Int, step: Int): LazyList[Int]

Create an infinite LazyList starting at start and incrementing by step step.
Create an infinite LazyList starting at start and incrementing by step step.
start
the start value of the LazyList
step
the increment value of the LazyList
returns
the LazyList starting at value start.
def from[A](coll: GenTraversableOnce[A]): LazyList[A]
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def iterate[A](start: A, len: Int)(f: (A) ⇒ A): LazyList[A]

Definition Classes
LazyList → GenTraversableFactory
def iterate[A](start: ⇒ A)(f: (A) ⇒ A): LazyList[A]

An infinite LazyList that repeatedly applies a given function to a start value.
An infinite LazyList that repeatedly applies a given function to a start value.
start
the start value of the LazyList
f
the function that's repeatedly applied
returns
the LazyList returning the infinite sequence of values start, f(start), f(f(start)), ...
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def newBuilder[A]: Builder[A, LazyList[A]]

The builder returned by this method only evaluates elements of collections added to it as needed.
The builder returned by this method only evaluates elements of collections added to it as needed.
A
the type of the lazy list’s elements
returns
A builder for LazyList objects.

Definition Classes
LazyList → GenericCompanion
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def range[A](start: A, end: A, step: A)(implicit arg0: Integral[A]): LazyList[A]

Definition Classes
LazyList → GenTraversableFactory
def range[A](start: A, end: A)(implicit arg0: Integral[A]): LazyList[A]

Definition Classes
LazyList → GenTraversableFactory
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def tabulate[A](n: Int)(f: (Int) ⇒ A): LazyList[A]

Definition Classes
LazyList → GenTraversableFactory
def tabulate[A](n1: Int, n2: Int, n3: Int, n4: Int, n5: Int)(f: (Int, Int, Int, Int, Int) ⇒ A): LazyList[LazyList[LazyList[LazyList[LazyList[A]]]]]

Definition Classes
GenTraversableFactory
def tabulate[A](n1: Int, n2: Int, n3: Int, n4: Int)(f: (Int, Int, Int, Int) ⇒ A): LazyList[LazyList[LazyList[LazyList[A]]]]

Definition Classes
GenTraversableFactory
def tabulate[A](n1: Int, n2: Int, n3: Int)(f: (Int, Int, Int) ⇒ A): LazyList[LazyList[LazyList[A]]]

Definition Classes
GenTraversableFactory
def tabulate[A](n1: Int, n2: Int)(f: (Int, Int) ⇒ A): LazyList[LazyList[A]]

Definition Classes
GenTraversableFactory
implicit def toDeferrer[A](l: ⇒ LazyList[A]): Deferrer[A]
def toString(): String

Definition Classes
AnyRef → Any
def unapplySeq[A](x: LazyList[A]): Some[LazyList[A]]

Definition Classes
SeqFactory
def unfold[A, S](init: S)(f: (S) ⇒ Option[(A, S)]): LazyList[A]
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )

Related Docs: class LazyList | package immutable

object LazyList extends SeqFactory[LazyList] with Serializable

Type Members

type Coll = LazyList[_]

final class Deferrer[A] extends AnyVal

class GenericCanBuildFrom[A] extends CanBuildFrom[CC[_], A, CC[A]]

class LazyListCanBuildFrom[A] extends GenericCanBuildFrom[A]

final class SerializationProxy[A] extends Serializable

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

object #::

final def ==(arg0: Any): Boolean

def ReusableCBF: GenericCanBuildFrom[Nothing]

def apply[A](elems: A*): LazyList[A]

final def asInstanceOf[T0]: T0

implicit def canBuildFrom[A]: CanBuildFrom[Coll, A, LazyList[A]]

def clone(): AnyRef

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

def concat[A](xss: Traversable[A]*): LazyList[A]

object cons

def continually[A](elem: ⇒ A): LazyList[A]

def empty[A]: LazyList[A]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def fill[A](n: Int)(elem: ⇒ A): LazyList[A]

def fill[A](n1: Int, n2: Int, n3: Int, n4: Int, n5: Int)(elem: ⇒ A): LazyList[LazyList[LazyList[LazyList[LazyList[A]]]]]

def fill[A](n1: Int, n2: Int, n3: Int, n4: Int)(elem: ⇒ A): LazyList[LazyList[LazyList[LazyList[A]]]]

def fill[A](n1: Int, n2: Int, n3: Int)(elem: ⇒ A): LazyList[LazyList[LazyList[A]]]

def fill[A](n1: Int, n2: Int)(elem: ⇒ A): LazyList[LazyList[A]]

def finalize(): Unit

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

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

def from[A](coll: GenTraversableOnce[A]): LazyList[A]

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def iterate[A](start: A, len: Int)(f: (A) ⇒ A): LazyList[A]

def iterate[A](start: ⇒ A)(f: (A) ⇒ A): LazyList[A]

final def ne(arg0: AnyRef): Boolean

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

final def notify(): Unit

final def notifyAll(): Unit

def range[A](start: A, end: A, step: A)(implicit arg0: Integral[A]): LazyList[A]

def range[A](start: A, end: A)(implicit arg0: Integral[A]): LazyList[A]

final def synchronized[T0](arg0: ⇒ T0): T0

def tabulate[A](n: Int)(f: (Int) ⇒ A): LazyList[A]

def tabulate[A](n1: Int, n2: Int, n3: Int, n4: Int, n5: Int)(f: (Int, Int, Int, Int, Int) ⇒ A): LazyList[LazyList[LazyList[LazyList[LazyList[A]]]]]

def tabulate[A](n1: Int, n2: Int, n3: Int, n4: Int)(f: (Int, Int, Int, Int) ⇒ A): LazyList[LazyList[LazyList[LazyList[A]]]]

def tabulate[A](n1: Int, n2: Int, n3: Int)(f: (Int, Int, Int) ⇒ A): LazyList[LazyList[LazyList[A]]]

def tabulate[A](n1: Int, n2: Int)(f: (Int, Int) ⇒ A): LazyList[LazyList[A]]

implicit def toDeferrer[A](l: ⇒ LazyList[A]): Deferrer[A]

def toString(): String

def unapplySeq[A](x: LazyList[A]): Some[LazyList[A]]

def unfold[A, S](init: S)(f: (S) ⇒ Option[(A, S)]): LazyList[A]

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

Inherited from Serializable

Inherited from java.io.Serializable

Inherited from SeqFactory[LazyList]

Inherited from TraversableFactory[LazyList]

Inherited from GenericSeqCompanion[LazyList]

Inherited from GenSeqFactory[LazyList]

Inherited from GenTraversableFactory[LazyList]

Inherited from GenericCompanion[LazyList]

Inherited from AnyRef

Inherited from Any

Ungrouped