Streaming

Type Members

final case class Cons[A](a: A, tail: Eval[Streaming[A]]) extends Streaming[A] with Product with Serializable
final case class Empty[A]() extends Streaming[A] with Product with Serializable

Concrete Streaming[A] types:
Concrete Streaming[A] types:
- Empty(): an empty stream.
- Cons(a, tail): a non-empty stream containing (at least) a.
- Wait(tail): a deferred stream.
Cons represents a lazy, possibly infinite stream of values. Eval[_] is used to represent possible laziness (via Now, Later, and Always). The head of Cons is eager -- a lazy head can be represented using Wait(Always(...)) or Wait(Later(...)).
final case class Wait[A](next: Eval[Streaming[A]]) extends Streaming[A] with Product with Serializable

Value Members

final def !=(arg0: Any): Boolean

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

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

Definition Classes
AnyRef → Any
def apply[A](a1: A, a2: A, as: A*): Streaming[A]

Create a stream from two or more values.
def apply[A](a: A): Streaming[A]

Create a stream consisting of a single value.
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def cons[A](a: A, ls: Eval[Streaming[A]]): Streaming[A]

Prepend a value to an Eval[Streaming[A]].
def cons[A](a: A, s: Streaming[A]): Streaming[A]

Prepend a value to a stream.
def continually[A](a: A): Streaming[A]

Continually return a constant value.
def defer[A](s: ⇒ Streaming[A]): Streaming[A]

Defer stream creation.
Defer stream creation.
Given an expression which creates a stream, this method defers that creation, allowing the head (if any) to be lazy.
def empty[A]: Streaming[A]

Create an empty stream of type A.
final def eq(arg0: AnyRef): Boolean

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

Definition Classes
AnyRef → Any
def finalize(): Unit

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

Stream of integers starting at n.
def fromFoldable[F[_], A](fa: F[A])(implicit F: Foldable[F]): Streaming[A]
def fromIterable[A](as: Iterable[A]): Streaming[A]

Create a stream from an iterable.
Create a stream from an iterable.
The stream will be eagerly evaluated.
def fromIteratorUnsafe[A](it: Iterator[A]): Streaming[A]

Create a stream from an iterator.
Create a stream from an iterator.
The stream will be created lazily, to support potentially large (or infinite) iterators. Iterators passed to this method should not be used elsewhere -- doing so will result in problems.
The use case for this method is code like .fromIterable, which creates an iterator for the express purpose of calling this method.
def fromList[A](as: List[A]): Streaming[A]

Create a stream from a list.
Create a stream from a list.
The stream will be eagerly evaluated.
def fromVector[A](as: Vector[A]): Streaming[A]

Create a stream from a vector.
Create a stream from a vector.
The stream will be eagerly evaluated.
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
def infinite[A](a: A)(f: (A) ⇒ A): Streaming[A]

Produce an infinite stream of values given an initial value and a tranformation function.
def interval(start: Int, end: Int): Streaming[Int]

Provide a stream of integers starting with start and ending with end (i.e.
Provide a stream of integers starting with start and ending with end (i.e. inclusive).
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def knot[A](f: (Eval[Streaming[A]]) ⇒ Streaming[A], memo: Boolean = false): Streaming[A]

Create a self-referential stream.
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
implicit def streamEq[A](implicit arg0: Eq[A]): Eq[Streaming[A]]

Definition Classes
StreamingInstances2
implicit val streamInstance: Traverse[Streaming] with MonadCombine[Streaming] with CoflatMap[Streaming]

Definition Classes
StreamingInstances
implicit def streamOrder[A](implicit arg0: Order[A]): Order[Streaming[A]]

Definition Classes
StreamingInstances
implicit def streamPartialOrder[A](implicit arg0: PartialOrder[A]): PartialOrder[Streaming[A]]

Definition Classes
StreamingInstances1
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
object syntax

Contains various Stream-specific syntax.
Contains various Stream-specific syntax.
To eanble this, say:
import cats.data.Stream.syntax._
This provides the %:: and %::: operators for constructing Streams lazily, and the %:: extract to use when pattern matching on Streams.
def thunk[A](f: () ⇒ A): Streaming[A]

Continually return the result of a thunk.
Continually return the result of a thunk.
This method only differs from continually in that the thunk may not be pure. For this reason (and unlike continually), this stream is memoized to ensure that repeated traversals produce the same results.
def toString(): String

Definition Classes
AnyRef → Any
def unfold[A](o: Option[A])(f: (A) ⇒ Option[A]): Streaming[A]

Produce a stream given an "unfolding" function.
Produce a stream given an "unfolding" function.
None represents an empty stream. Some(a) reprsents an initial element, and we can compute the tail (if any) via f(a).
def wait[A](ls: Eval[Streaming[A]]): Streaming[A]

Create a stream from an Eval[Streaming[A]] value.
Create a stream from an Eval[Streaming[A]] value.
Given an expression which creates a stream, this method defers that creation, allowing the head (if any) to be lazy.
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 Streaming | package data

object Streaming extends StreamingInstances

Type Members

final case class Cons[A](a: A, tail: Eval[Streaming[A]]) extends Streaming[A] with Product with Serializable

final case class Empty[A]() extends Streaming[A] with Product with Serializable

final case class Wait[A](next: Eval[Streaming[A]]) extends Streaming[A] with Product with Serializable

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def apply[A](a1: A, a2: A, as: A*): Streaming[A]

def apply[A](a: A): Streaming[A]

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def cons[A](a: A, ls: Eval[Streaming[A]]): Streaming[A]

def cons[A](a: A, s: Streaming[A]): Streaming[A]

def continually[A](a: A): Streaming[A]

def defer[A](s: ⇒ Streaming[A]): Streaming[A]

def empty[A]: Streaming[A]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def from(n: Int): Streaming[Int]

def fromFoldable[F[_], A](fa: F[A])(implicit F: Foldable[F]): Streaming[A]

def fromIterable[A](as: Iterable[A]): Streaming[A]

def fromIteratorUnsafe[A](it: Iterator[A]): Streaming[A]

def fromList[A](as: List[A]): Streaming[A]

def fromVector[A](as: Vector[A]): Streaming[A]

final def getClass(): Class[_]

def hashCode(): Int

def infinite[A](a: A)(f: (A) ⇒ A): Streaming[A]

def interval(start: Int, end: Int): Streaming[Int]

final def isInstanceOf[T0]: Boolean

def knot[A](f: (Eval[Streaming[A]]) ⇒ Streaming[A], memo: Boolean = false): Streaming[A]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

implicit def streamEq[A](implicit arg0: Eq[A]): Eq[Streaming[A]]

implicit val streamInstance: Traverse[Streaming] with MonadCombine[Streaming] with CoflatMap[Streaming]

implicit def streamOrder[A](implicit arg0: Order[A]): Order[Streaming[A]]

implicit def streamPartialOrder[A](implicit arg0: PartialOrder[A]): PartialOrder[Streaming[A]]

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

object syntax

def thunk[A](f: () ⇒ A): Streaming[A]

def toString(): String

def unfold[A](o: Option[A])(f: (A) ⇒ Option[A]): Streaming[A]

def wait[A](ls: Eval[Streaming[A]]): Streaming[A]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

Inherited from StreamingInstances

Inherited from StreamingInstances1

Inherited from StreamingInstances2

Inherited from AnyRef

Inherited from Any

Ungrouped