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
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. The 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

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