Stream_Functions

implicit abstract val ConformsAnyProof: ConformsR[Any]

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def apply[A](as: A*): ZStream[Any, Nothing, A]

Creates a pure stream from a variable list of values

final def asInstanceOf[T0]: T0

final def bracket[R, E, A](acquire: ZIO[R, E, A])(release: (A) ⇒ ZIO[R, Nothing, _])(implicit arg0: ConformsR[R]): ZStream[R, E, A]

Creates a stream from a single value that will get cleaned up after the stream is consumed

def clone(): AnyRef

final def die(ex: Throwable): ZStream[Any, Nothing, Nothing]

The stream that always dies with ex.

final def dieMessage(msg: String): ZStream[Any, Nothing, Nothing]

The stream that always dies with an exception described by msg.

final val empty: ZStream[Any, Nothing, Nothing]

The empty stream

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

final def fail[E](error: E): ZStream[Any, E, Nothing]

The stream that always fails with error

def finalize(): Unit

final def finalizer[R](finalizer: ZIO[R, Nothing, _])(implicit arg0: ConformsR[R]): ZStream[R, Nothing, Nothing]

Creates a stream that emits no elements, never fails and executes the finalizer before it ends.

final def flatten[R, E, A](fa: ZStream[R, E, ZStream[R, E, A]])(implicit arg0: ConformsR[R]): ZStream[R, E, A]

Flattens nested streams.

final def flattenPar[R, E, A](n: Long, outputBuffer: Int = 16)(fa: ZStream[R, E, ZStream[R, E, A]])(implicit arg0: ConformsR[R]): ZStream[R, E, A]

Flattens a stream of streams into a stream by executing a non-deterministic concurrent merge.

final def fromChunk[A](c: Chunk[A]): ZStream[Any, Nothing, A]

Creates a stream from a zio.Chunk of values

final def fromEffect[R, E, A](fa: ZIO[R, E, A])(implicit arg0: ConformsR[R]): ZStream[R, E, A]

Creates a stream from an effect producing a value of type A

final def fromIterable[A](as: Iterable[A]): ZStream[Any, Nothing, A]

Creates a stream from an iterable collection of values

final def fromQueue[R, E, A](queue: ZQueue[_, _, R, E, _, A])(implicit arg0: ConformsR[R]): ZStream[R, E, A]

Creates a stream from a zio.ZQueue of values

final def getClass(): Class[_]

final def halt[E](cause: Cause[E]): ZStream[Any, E, Nothing]

The stream that always halts with cause.

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

final def managed[R, E, A](managed: ZManaged[R, E, A])(implicit arg0: ConformsR[R]): ZStream[R, E, A]

Creates a single-valued stream from a managed resource

final def mergeAll[R, E, A](n: Long, outputBuffer: Int = 16)(streams: ZStream[R, E, A]*)(implicit arg0: ConformsR[R]): ZStream[R, E, A]

Merges a variable list of streams in a non-deterministic fashion.

final def ne(arg0: AnyRef): Boolean

final val never: ZStream[Any, Nothing, Nothing]

The stream that never produces any value or fails with any error.

final def notify(): Unit

final def notifyAll(): Unit

final def range(min: Int, max: Int): Stream[Nothing, Int]

Constructs a stream from a range of integers (inclusive).

final def succeed[A](a: A): ZStream[Any, Nothing, A]

Creates a single-valued pure stream

final def succeedLazy[A](a: ⇒ A): ZStream[Any, Nothing, A]

Creates a single, lazily-evaluated-valued pure stream

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

def toString(): String

final def unfold[S, A](s: S)(f0: (S) ⇒ Option[(A, S)]): ZStream[Any, Nothing, A]

Creates a stream by peeling off the "layers" of a value of type S

final def unfoldM[R, E, A, S](s: S)(f0: (S) ⇒ ZIO[R, E, Option[(A, S)]])(implicit arg0: ConformsR[R]): ZStream[R, E, A]

Creates a stream by effectfully peeling off the "layers" of a value of type S

final def unwrap[R, E, A](fa: ZIO[R, E, ZStream[R, E, A]])(implicit arg0: ConformsR[R]): ZStream[R, E, A]

Creates a stream produced from an effect

final def wait(): Unit

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

final def wait(arg0: Long): Unit