Packages

object ZStream extends Serializable

Linear Supertypes
Serializable, Serializable, AnyRef, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. ZStream
  2. Serializable
  3. Serializable
  4. AnyRef
  5. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Type Members

  1. final class AccessMPartiallyApplied[R] extends AnyVal
  2. final class AccessPartiallyApplied[R] extends AnyVal
  3. final class GroupBy[-R, +E, +K, +V] extends AnyRef

    Representation of a grouped stream.

    Representation of a grouped stream. This allows to filter which groups will be processed. Once this is applied all groups will be processed in parallel and the results will be merged in arbitrary order.

  4. type Pull[-R, +E, +A] = ZIO[R, Option[E], A]

    Describes an effectful pull from a stream.

    Describes an effectful pull from a stream. The optionality of the error channel denotes normal termination of the stream when None and an error when Some(e: E).

Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##(): Int
    Definition Classes
    AnyRef → Any
  3. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  4. final def access[R]: AccessPartiallyApplied[R]

    Creates a stream from a value received from the accessed environment.

  5. final def accessM[R]: AccessMPartiallyApplied[R]

    Creates a stream from a value received from the effectfully accessed environment.

  6. final def apply[R, E, A](pull: ZManaged[R, E, Pull[R, E, A]]): ZStream[R, E, A]

    Creates a stream from a scoped Pull.

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

    Creates a pure stream from a variable list of values

  8. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  9. final def bracket[R, E, A](acquire: ZIO[R, E, A])(release: (A) ⇒ ZIO[R, Nothing, Any]): ZStream[R, E, A]

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

  10. final def bracketExit[R, E, A](acquire: ZIO[R, E, A])(release: (A, Exit[Any, Any]) ⇒ ZIO[R, Nothing, Any]): ZStream[R, E, A]

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

  11. def clone(): AnyRef
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... ) @native()
  12. final def die(ex: Throwable): Stream[Nothing, Nothing]

    The stream that always dies with ex.

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

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

  14. final def effectAsync[R, E, A](register: ((ZIO[R, Option[E], A]) ⇒ Unit) ⇒ Unit, outputBuffer: Int = 16): ZStream[R, E, A]

    Creates a stream from an asynchronous callback that can be called multiple times.

    Creates a stream from an asynchronous callback that can be called multiple times. The optionality of the error type E can be used to signal the end of the stream, by setting it to None.

  15. final def effectAsyncInterrupt[R, E, A](register: ((ZIO[R, Option[E], A]) ⇒ Unit) ⇒ Either[Canceler[R], ZStream[R, E, A]], outputBuffer: Int = 16): ZStream[R, E, A]

    Creates a stream from an asynchronous callback that can be called multiple times.

    Creates a stream from an asynchronous callback that can be called multiple times. The registration of the callback returns either a canceler or synchronously returns a stream. The optionality of the error type E can be used to signal the end of the stream, by setting it to None.

  16. final def effectAsyncM[R, E, A](register: ((ZIO[R, Option[E], A]) ⇒ Unit) ⇒ ZIO[R, E, Any], outputBuffer: Int = 16): ZStream[R, E, A]

    Creates a stream from an asynchronous callback that can be called multiple times The registration of the callback itself returns an effect.

    Creates a stream from an asynchronous callback that can be called multiple times The registration of the callback itself returns an effect. The optionality of the error type E can be used to signal the end of the stream, by setting it to None.

  17. final def effectAsyncMaybe[R, E, A](register: ((ZIO[R, Option[E], A]) ⇒ Unit) ⇒ Option[ZStream[R, E, A]], outputBuffer: Int = 16): ZStream[R, E, A]

    Creates a stream from an asynchronous callback that can be called multiple times.

    Creates a stream from an asynchronous callback that can be called multiple times. The registration of the callback can possibly return the stream synchronously. The optionality of the error type E can be used to signal the end of the stream, by setting it to None.

  18. final val empty: Stream[Nothing, Nothing]

    The empty stream

  19. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  20. def equals(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  21. final def fail[E](error: E): Stream[E, Nothing]

    The stream that always fails with error

  22. def finalize(): Unit
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  23. final def finalizer[R](finalizer: ZIO[R, Nothing, Any]): ZStream[R, Nothing, Nothing]

    Creates an empty stream that never fails and executes the finalizer when it ends.

  24. final def flatten[R, E, A](fa: ZStream[R, E, ZStream[R, E, A]]): ZStream[R, E, A]

    Flattens nested streams.

  25. final def flattenPar[R, E, A](n: Int, outputBuffer: Int = 16)(fa: ZStream[R, E, ZStream[R, E, A]]): ZStream[R, E, A]

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

    Flattens a stream of streams into a stream by executing a non-deterministic concurrent merge. Up to n streams may be consumed in parallel and up to outputBuffer elements may be buffered by this operator.

  26. final def flattenParUnbounded[R, E, A](outputBuffer: Int = 16)(fa: ZStream[R, E, ZStream[R, E, A]]): ZStream[R, E, A]

    Like flattenPar, but executes all streams concurrently.

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

    Creates a stream from a zio.Chunk of values

  28. final def fromEffect[R, E, A](fa: ZIO[R, E, A]): ZStream[R, E, A]

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

  29. final def fromInputStream(is: InputStream, chunkSize: Int = ZStreamChunk.DefaultChunkSize): StreamEffectChunk[Any, IOException, Byte]

    Creates a stream from a java.io.InputStream

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

    Creates a stream from an iterable collection of values

  31. final def fromIterator[R, E, A](iterator: ZIO[R, E, Iterator[A]]): ZStream[R, E, A]

    Creates a stream from an iterator

  32. final def fromIteratorManaged[R, E, A](iterator: ZManaged[R, E, Iterator[A]]): ZStream[R, E, A]

    Creates a stream from an iterator

  33. final def fromPull[R, E, A](pull: Pull[R, E, A]): ZStream[R, E, A]

    Creates a stream from a Pull.

  34. final def fromQueue[R, E, A](queue: ZQueue[Nothing, Any, R, E, Nothing, A]): ZStream[R, E, A]

    Creates a stream from a zio.ZQueue of values

  35. final def fromQueueWithShutdown[R, E, A](queue: ZQueue[Nothing, Any, R, E, Nothing, A]): ZStream[R, E, A]

    Creates a stream from a zio.ZQueue of values.

    Creates a stream from a zio.ZQueue of values. The queue will be shutdown once the stream is closed.

  36. final def getClass(): Class[_]
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  37. final def halt[E](cause: Cause[E]): ZStream[Any, E, Nothing]

    The stream that always halts with cause.

  38. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  39. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  40. final def iterate[A](a: A)(f: (A) ⇒ A): ZStream[Any, Nothing, A]

    The infinite stream of iterative function application: a, f(a), f(f(a)), f(f(f(a))), ...

  41. final def managed[R, E, A](managed: ZManaged[R, E, A]): ZStream[R, E, A]

    Creates a single-valued stream from a managed resource

  42. final def mergeAll[R, E, A](n: Int, outputBuffer: Int = 16)(streams: ZStream[R, E, A]*): ZStream[R, E, A]

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

    Merges a variable list of streams in a non-deterministic fashion. Up to n streams may be consumed in parallel and up to outputBuffer elements may be buffered by this operator.

  43. final def mergeAllUnbounded[R, E, A](outputBuffer: Int = 16)(streams: ZStream[R, E, A]*): ZStream[R, E, A]

    Like mergeAll, but runs all streams concurrently.

  44. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  45. final val never: Stream[Nothing, Nothing]

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

  46. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  47. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  48. final def paginate[R, E, A, S](s: S)(f: (S) ⇒ ZIO[R, E, (A, Option[S])]): ZStream[R, E, A]

    Like unfoldM, but allows the emission of values to end one step further than the unfolding of the state.

    Like unfoldM, but allows the emission of values to end one step further than the unfolding of the state. This is useful for embedding paginated APIs, hence the name.

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

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

  50. final def repeatEffect[R, E, A](fa: ZIO[R, E, A]): ZStream[R, E, A]

    Creates a stream from an effect producing a value of type A which repeats forever

  51. final def repeatEffectWith[R, E, A](fa: ZIO[R, E, A], schedule: Schedule[R, Unit, _]): ZStream[R, E, A]

    Creates a stream from an effect producing a value of type A which repeats using the specified schedule

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

    Creates a single-valued pure stream

  53. final def synchronized[T0](arg0: ⇒ T0): T0
    Definition Classes
    AnyRef
  54. def toString(): String
    Definition Classes
    AnyRef → Any
  55. final def unfold[S, A](s: S)(f0: (S) ⇒ Option[(A, S)]): Stream[Nothing, A]

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

  56. final def unfoldM[R, E, A, S](s: S)(f0: (S) ⇒ ZIO[R, E, Option[(A, S)]]): ZStream[R, E, A]

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

  57. final val unit: Stream[Nothing, Unit]

    The stream of units

  58. final def unwrap[R, E, A](fa: ZIO[R, E, ZStream[R, E, A]]): ZStream[R, E, A]

    Creates a stream produced from an effect

  59. final def unwrapManaged[R, E, A](fa: ZManaged[R, E, ZStream[R, E, A]]): ZStream[R, E, A]

    Creates a stream produced from a ZManaged

  60. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  61. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  62. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... ) @native()
  63. object GroupBy
  64. object Pull

Deprecated Value Members

  1. final def succeedLazy[A](a: ⇒ A): Stream[Nothing, A]
    Annotations
    @deprecated
    Deprecated

    (Since version 1.0.0) use succeed

Inherited from Serializable

Inherited from Serializable

Inherited from AnyRef

Inherited from Any

Ungrouped