Stream

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def apply[E, A](pull: Managed[E, Pull[Any, E, A]]): Stream[E, A]

See ZStream.apply[R,E,A]*

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

See ZStream.apply[A]*

final def asInstanceOf[T0]: T0

final def bracket[E, A](acquire: IO[E, A])(release: (A) ⇒ UIO[_]): Stream[E, A]

See ZStream.bracket

def clone(): AnyRef

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

See ZStream.die

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

See ZStream.dieMessage

final def effectAsync[E, A](register: ((IO[Option[E], A]) ⇒ Unit) ⇒ Unit, outputBuffer: Int = 16): Stream[E, A]

See ZStream.effectAsync

final def effectAsyncInterrupt[E, A](register: ((IO[Option[E], A]) ⇒ Unit) ⇒ Either[Canceler, Stream[E, A]], outputBuffer: Int = 16): Stream[E, A]

See ZStream.effectAsyncInterrupt

final def effectAsyncM[E, A](register: ((IO[Option[E], A]) ⇒ Unit) ⇒ IO[E, _], outputBuffer: Int = 16): Stream[E, A]

See ZStream.effectAsyncM

final def effectAsyncMaybe[E, A](register: ((IO[Option[E], A]) ⇒ Unit) ⇒ Option[Stream[E, A]], outputBuffer: Int = 16): Stream[E, A]

See ZStream.effectAsyncMaybe

final val empty: Stream[Nothing, Nothing]

See ZStream.empty

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

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

See ZStream.fail

def finalize(): Unit

final def finalizer(finalizer: UIO[_]): Stream[Nothing, Nothing]

See ZStream.finalizer

final def flatten[E, A](fa: Stream[E, Stream[E, A]]): Stream[E, A]

See ZStream.flatten

final def flattenPar[E, A](n: Int, outputBuffer: Int = 16)(fa: Stream[E, Stream[E, A]]): Stream[E, A]

See ZStream.flattenPar

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

See ZStream.fromChunk

final def fromEffect[E, A](fa: IO[E, A]): Stream[E, A]

See ZStream.fromEffect

def fromInputStream(is: InputStream, chunkSize: Int = ZStreamChunk.DefaultChunkSize): ZStreamChunk[Blocking, IOException, Byte]

Uses the provided RIO value to create a ZStream of byte chunks, backed by the resulting InputStream.

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

See ZStream.fromIterable

final def fromIterator[E, A](iterator: IO[E, Iterator[A]]): Stream[E, A]

See ZStream.fromIterator

final def fromIteratorManaged[E, A](iterator: Managed[E, Iterator[A]]): Stream[E, A]

See ZStream.fromIteratorManaged

final def fromPull[E, A](pull: Pull[Any, E, A]): Stream[E, A]

See ZStream.fromPull

final def fromQueue[E, A](queue: ZQueue[_, _, Any, E, _, A]): Stream[E, A]

See ZStream.fromQueue

final def fromQueueWithShutdown[E, A](queue: ZQueue[_, _, Any, E, _, A]): Stream[E, A]

See ZStream.fromQueueWithShutdown

final def getClass(): Class[_]

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

See ZStream.halt

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

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

See ZStream.iterate

final def managed[E, A](managed: Managed[E, A]): Stream[E, A]

See ZStream.managed

final def mergeAll[E, A](n: Int, outputBuffer: Int = 16)(streams: Stream[E, A]*): Stream[E, A]

See ZStream.mergeAll

final def ne(arg0: AnyRef): Boolean

final val never: Stream[Nothing, Nothing]

See ZStream.never

final def notify(): Unit

final def notifyAll(): Unit

final def paginate[E, A, S](s: S)(f: (S) ⇒ IO[E, (A, Option[S])]): Stream[E, A]

See ZStream.paginate

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

See ZStream.range

final def repeatEffect[E, A](fa: IO[E, A]): Stream[E, A]

See ZStream.repeatEffect

final def repeatEffectWith[E, A](fa: IO[E, A], schedule: Schedule[Unit, _]): ZStream[Clock, E, A]

See ZStream.repeatEffectWith

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

See ZStream.succeed

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

def toString(): String

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

See ZStream.unfold

final def unfoldM[E, A, S](s: S)(f0: (S) ⇒ IO[E, Option[(A, S)]]): Stream[E, A]

See ZStream.unfoldM

final def unwrap[E, A](fa: IO[E, Stream[E, A]]): Stream[E, A]

See ZStream.unwrap

final def unwrapManaged[E, A](fa: Managed[E, ZStream[Any, E, A]]): Stream[E, A]

See ZStream.unwrapManaged

final def wait(): Unit

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

final def wait(arg0: Long): Unit

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