Stream

Type Members

implicit final class PipeOps[F[_], I, O] extends AnyVal

Provides operations on effectful pipes for syntactic convenience.
implicit final class PurePipeOps[I, O] extends AnyVal

Provides operations on pure pipes for syntactic convenience.
implicit final class StreamInvariantOps[F[_], O] extends AnyVal
implicit final class StreamOptionOps[F[_], O] extends AnyVal
implicit final class StreamPureOps[+O] extends AnyVal

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[F[_], A](a: A*): Stream[F, A]
final def asInstanceOf[T0]: T0

Definition Classes
Any
def attemptEval[F[_], A](fa: F[A]): Stream[F, Attempt[A]]
def bracket[F[_], R, A](r: F[R])(use: (R) ⇒ Stream[F, A], release: (R) ⇒ F[Unit]): Stream[F, A]
def chunk[F[_], A](as: Chunk[A]): Stream[F, A]
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def cons[F[_], O](h: Stream[F, O])(c: Chunk[O]): Stream[F, O]
def constant[F[_], A](a: A, chunkSize: Int = 1): Stream[F, A]

The infinite Stream, always emits a.
The infinite Stream, always emits a. If for performance reasons it is good to emit a in chunks, specify size of chunk by chunkSize parameter
implicit def covaryPure[F[_], O](s: Stream[Pure, O]): Stream[F, O]
implicit def covaryPurePipe[F[_], I, O](p: Pipe[Pure, I, O]): Pipe[F, I, O]
implicit def covaryPurePipe2[F[_], I, I2, O](p: Pipe2[Pure, I, I2, O]): Pipe2[F, I, I2, O]
def emit[F[_], A](a: A): Stream[F, A]
def emits[F[_], A](a: Seq[A]): Stream[F, A]
def empty[F[_], A]: Stream[F, A]
final def eq(arg0: AnyRef): Boolean

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

Definition Classes
AnyRef → Any
def eval[F[_], A](fa: F[A]): Stream[F, A]
def evalScope[F[_], A](fa: Scope[F, A]): Stream[F, A]
def eval_[F[_], A](fa: F[A]): Stream[F, Nothing]
def fail[F[_]](e: Throwable): Stream[F, Nothing]
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def force[F[_], A](f: F[Stream[F, A]]): Stream[F, 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[F[_], A](start: A)(f: (A) ⇒ A): Stream[F, A]

An infinite Stream that repeatedly applies a given function to a start value.
An infinite Stream that repeatedly applies a given function to a start value. start is the first value emitted, followed by f(start), then f(f(start)), and so on.
def iterateEval[F[_], A](start: A)(f: (A) ⇒ F[A]): Stream[F, A]

Like iterate, but takes an effectful function for producing the next state.
Like iterate, but takes an effectful function for producing the next state. start is the first value emitted.
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def pure[A](a: A*): Stream[Pure, A]
def range[F[_]](start: Int, stopExclusive: Int, by: Int = 1): Stream[F, Int]

Lazily produce the range [start, stopExclusive).
Lazily produce the range [start, stopExclusive). If you want to produce the sequence in one chunk, instead of lazily, use emits(start until stopExclusive).
def ranges[F[_]](start: Int, stopExclusive: Int, size: Int): Stream[F, (Int, Int)]

Lazily produce a sequence of nonoverlapping ranges, where each range contains size integers, assuming the upper bound is exclusive.
Lazily produce a sequence of nonoverlapping ranges, where each range contains size integers, assuming the upper bound is exclusive. Example: ranges(0, 1000, 10) results in the pairs (0, 10), (10, 20), (20, 30) ... (990, 1000)
Note: The last emitted range may be truncated at stopExclusive. For instance, ranges(0,5,4) results in (0,4), (4,5).

Exceptions thrown
IllegalArgumentException if size <= 0
def repeatEval[F[_], A](a: F[A]): Stream[F, A]
implicit def streamCatchableInstance[F[_]]: Catchable[[a]Stream[F, a]]
def suspend[F[_], A](s: ⇒ Stream[F, A]): Stream[F, A]
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
def unfold[F[_], S, A](s0: S)(f: (S) ⇒ Option[(A, S)]): Stream[F, A]

Produce a (potentially infinite) stream from an unfold.
def unfoldEval[F[_], S, A](s0: S)(f: (S) ⇒ F[Option[(A, S)]]): Stream[F, A]

Like unfold, but takes an effectful function.
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 Stream | package fs2

object Stream

Type Members

implicit final class PipeOps[F[_], I, O] extends AnyVal

implicit final class PurePipeOps[I, O] extends AnyVal

implicit final class StreamInvariantOps[F[_], O] extends AnyVal

implicit final class StreamOptionOps[F[_], O] extends AnyVal

implicit final class StreamPureOps[+O] extends AnyVal

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def apply[F[_], A](a: A*): Stream[F, A]

final def asInstanceOf[T0]: T0

def attemptEval[F[_], A](fa: F[A]): Stream[F, Attempt[A]]

def bracket[F[_], R, A](r: F[R])(use: (R) ⇒ Stream[F, A], release: (R) ⇒ F[Unit]): Stream[F, A]

def chunk[F[_], A](as: Chunk[A]): Stream[F, A]

def clone(): AnyRef

def cons[F[_], O](h: Stream[F, O])(c: Chunk[O]): Stream[F, O]

def constant[F[_], A](a: A, chunkSize: Int = 1): Stream[F, A]

implicit def covaryPure[F[_], O](s: Stream[Pure, O]): Stream[F, O]

implicit def covaryPurePipe[F[_], I, O](p: Pipe[Pure, I, O]): Pipe[F, I, O]

implicit def covaryPurePipe2[F[_], I, I2, O](p: Pipe2[Pure, I, I2, O]): Pipe2[F, I, I2, O]

def emit[F[_], A](a: A): Stream[F, A]

def emits[F[_], A](a: Seq[A]): Stream[F, A]

def empty[F[_], A]: Stream[F, A]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def eval[F[_], A](fa: F[A]): Stream[F, A]

def evalScope[F[_], A](fa: Scope[F, A]): Stream[F, A]

def eval_[F[_], A](fa: F[A]): Stream[F, Nothing]

def fail[F[_]](e: Throwable): Stream[F, Nothing]

def finalize(): Unit

def force[F[_], A](f: F[Stream[F, A]]): Stream[F, A]

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def iterate[F[_], A](start: A)(f: (A) ⇒ A): Stream[F, A]

def iterateEval[F[_], A](start: A)(f: (A) ⇒ F[A]): Stream[F, A]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def pure[A](a: A*): Stream[Pure, A]

def range[F[_]](start: Int, stopExclusive: Int, by: Int = 1): Stream[F, Int]

def ranges[F[_]](start: Int, stopExclusive: Int, size: Int): Stream[F, (Int, Int)]

def repeatEval[F[_], A](a: F[A]): Stream[F, A]

implicit def streamCatchableInstance[F[_]]: Catchable[[a]Stream[F, a]]

def suspend[F[_], A](s: ⇒ Stream[F, A]): Stream[F, A]

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

def toString(): String

def unfold[F[_], S, A](s0: S)(f: (S) ⇒ Option[(A, S)]): Stream[F, A]

def unfoldEval[F[_], S, A](s0: S)(f: (S) ⇒ F[Option[(A, S)]]): Stream[F, A]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

Inherited from AnyRef

Inherited from Any

Ungrouped