object ZStream extends ZStreamPlatformSpecificConstructors

Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. ZStream
  2. ZStreamPlatformSpecificConstructors
  3. AnyRef
  4. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Type Members

  1. final class AccessPartiallyApplied[R] extends AnyVal
  2. final class AccessStreamPartiallyApplied[R] extends AnyVal
  3. final class AccessZIOPartiallyApplied[R] extends AnyVal
  4. trait Emit[+R, -E, -A, +B] extends (ZIO[R, Option[E], Chunk[A]]) ⇒ B

    An Emit[R, E, A, B] represents an asynchronous callback that can be called multiple times.

    An Emit[R, E, A, B] represents an asynchronous callback that can be called multiple times. The callback can be called with a value of type ZIO[R, Option[E], Chunk[A]], where succeeding with a Chunk[A] indicates to emit those elements, failing with Some[E] indicates to terminate with that error, and failing with None indicates to terminate with an end of stream signal.

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

  6. final class ProvideSomeLayer[R0, -R, +E, +A] extends AnyVal
  7. type Pull[-R, +E, +O] = ZIO[R, Option[E], Chunk[O]]
  8. implicit final class RefineToOrDieOps[R, E <: Throwable, A] extends AnyVal
  9. final class ServiceAtPartiallyApplied[Service] extends AnyVal
  10. final class ServiceWithPartiallyApplied[Service] extends AnyVal
  11. final class ServiceWithStreamPartiallyApplied[Service] extends AnyVal
  12. implicit final class SortedByKey[R, E, K, A] extends AnyRef

    Provides extension methods for streams that are sorted by distinct keys.

  13. implicit final class SyntaxOps[-R, +E, O] extends AnyRef
  14. sealed trait TerminationStrategy extends AnyRef
  15. final class UpdateService[-R, +E, +O, M] extends AnyVal
  16. final class UpdateServiceAt[-R, +E, +A, Service] extends AnyVal
  17. final class WhenCaseZIO[R, E, A] extends AnyVal
  18. final class WhenZIO[R, E] extends AnyVal
  19. trait ZStreamConstructor[Input] extends AnyRef

    A ZStreamConstructor[Input] knows how to construct a ZStream value from an input of type Input.

    A ZStreamConstructor[Input] knows how to construct a ZStream value from an input of type Input. This allows the type of the ZStream value constructed to depend on Input.

  20. trait ZStreamConstructorLowPriority1 extends ZStreamConstructorLowPriority2
  21. trait ZStreamConstructorLowPriority2 extends ZStreamConstructorLowPriority3
  22. trait ZStreamConstructorLowPriority3 extends AnyRef
  23. trait ZStreamConstructorPlatformSpecific extends ZStreamConstructorLowPriority1
    Definition Classes
    ZStreamPlatformSpecificConstructors

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 val DefaultChunkSize: Int(4096)

    The default chunk size used by the various combinators and constructors of ZStream.

  5. def absolve[R, E, O](xs: ZStream[R, E, Either[E, O]]): ZStream[R, E, O]

    Submerges the error case of an Either into the ZStream.

  6. def access[R]: AccessPartiallyApplied[R]

    Accesses the environment of the stream.

  7. def accessStream[R]: AccessStreamPartiallyApplied[R]

    Accesses the environment of the stream in the context of a stream.

  8. def accessZIO[R]: AccessZIOPartiallyApplied[R]

    Accesses the environment of the stream in the context of an effect.

  9. def acquireReleaseExitWith[R, E, A](acquire: ZIO[R, E, A])(release: (A, Exit[Any, Any]) ⇒ URIO[R, Any]): ZStream[R, E, A]

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

  10. def acquireReleaseWith[R, E, A](acquire: ZIO[R, E, A])(release: (A) ⇒ URIO[R, Any]): ZStream[R, E, A]

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

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

    Creates a pure stream from a variable list of values

  12. def apply[R, E, O](process: ZManaged[R, Nothing, ZIO[R, Option[E], Chunk[O]]]): ZStream[R, E, O]

    Creates a new ZStream from a managed effect that yields chunks.

    Creates a new ZStream from a managed effect that yields chunks. The effect will be evaluated repeatedly until it fails with a None (to signify stream end) or a Some(E) (to signify stream failure).

    The stream evaluation guarantees proper acquisition and release of the ZManaged.

  13. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  14. def async[R, E, A](register: (Emit[R, E, A, Future[Boolean]]) ⇒ 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.

    Definition Classes
    ZStreamPlatformSpecificConstructors
  15. def asyncInterrupt[R, E, A](register: (Emit[R, E, A, Future[Boolean]]) ⇒ 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.

    Definition Classes
    ZStreamPlatformSpecificConstructors
  16. def asyncManaged[R, E, A](register: ((ZIO[R, Option[E], Chunk[A]]) ⇒ Future[Boolean]) ⇒ ZManaged[R, E, Any], 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 itself returns an a managed resource. The optionality of the error type E can be used to signal the end of the stream, by setting it to None.

    Definition Classes
    ZStreamPlatformSpecificConstructors
  17. def asyncMaybe[R, E, A](register: (Emit[R, E, A, Future[Boolean]]) ⇒ 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.

    Definition Classes
    ZStreamPlatformSpecificConstructors
  18. def asyncZIO[R, E, A](register: (Emit[R, E, A, Future[Boolean]]) ⇒ 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.

    Definition Classes
    ZStreamPlatformSpecificConstructors
  19. def blocking[R, E, A](stream: ZStream[R, E, A]): ZStream[R, E, A]

    Locks the execution of the specified stream to the blocking executor.

    Locks the execution of the specified stream to the blocking executor. Any streams that are composed after this one will automatically be shifted back to the previous executor.

  20. def clone(): AnyRef
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... ) @native()
  21. def concatAll[R, E, O](streams: Chunk[ZStream[R, E, O]]): ZStream[R, E, O]

    Concatenates all of the streams in the chunk to one stream.

  22. def die(ex: ⇒ Throwable): ZStream[Any, Nothing, Nothing]

    The stream that dies with the ex.

  23. def dieMessage(msg: ⇒ String): ZStream[Any, Nothing, Nothing]

    The stream that dies with an exception described by msg.

  24. def done[E, A](exit: Exit[E, A]): ZStream[Any, E, A]

    The stream that ends with the zio.Exit value exit.

  25. val empty: ZStream[Any, Nothing, Nothing]

    The empty stream

  26. def environment[R]: ZStream[R, Nothing, R]

    Accesses the whole environment of the stream.

  27. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  28. def equals(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  29. def execute[R, E](zio: ZIO[R, E, Any]): ZStream[R, E, Nothing]

    Creates a stream that executes the specified effect but emits no elements.

  30. def fail[E](error: ⇒ E): ZStream[Any, E, Nothing]

    The stream that always fails with the error

  31. def failCause[E](cause: ⇒ Cause[E]): ZStream[Any, E, Nothing]

    The stream that always fails with cause.

  32. def finalize(): Unit
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  33. def finalizer[R](finalizer: URIO[R, Any]): ZStream[R, Nothing, Any]

    Creates a one-element stream that never fails and executes the finalizer when it ends.

  34. def from[Input](input: ⇒ Input)(implicit constructor: ZStreamConstructor[Input]): Out

    Constructs a ZStream value of the appropriate type for the specified input.

  35. def fromChunk[O](c: ⇒ Chunk[O]): ZStream[Any, Nothing, O]

    Creates a stream from a zio.Chunk of values

    Creates a stream from a zio.Chunk of values

    c

    a chunk of values

    returns

    a finite stream of values

  36. def fromChunkHub[R, E, O](hub: ZHub[Nothing, R, Any, E, Nothing, Chunk[O]]): ZStream[R, E, O]

    Creates a stream from a subscription to a hub.

  37. def fromChunkHubManaged[R, E, O](hub: ZHub[Nothing, R, Any, E, Nothing, Chunk[O]]): ZManaged[Any, Nothing, ZStream[R, E, O]]

    Creates a stream from a subscription to a hub in the context of a managed effect.

    Creates a stream from a subscription to a hub in the context of a managed effect. The managed effect describes subscribing to receive messages from the hub while the stream describes taking messages from the hub.

  38. def fromChunkHubManagedWithShutdown[R, E, O](hub: ZHub[Nothing, R, Any, E, Nothing, Chunk[O]]): ZManaged[Any, Nothing, ZStream[R, E, O]]

    Creates a stream from a subscription to a hub in the context of a managed effect.

    Creates a stream from a subscription to a hub in the context of a managed effect. The managed effect describes subscribing to receive messages from the hub while the stream describes taking messages from the hub.

    The hub will be shut down once the stream is closed.

  39. def fromChunkHubWithShutdown[R, E, O](hub: ZHub[Nothing, R, Any, E, Nothing, Chunk[O]]): ZStream[R, E, O]

    Creates a stream from a subscription to a hub.

    Creates a stream from a subscription to a hub.

    The hub will be shut down once the stream is closed.

  40. def fromChunkQueue[R, E, O](queue: ZQueue[Nothing, R, Any, E, Nothing, Chunk[O]]): ZStream[R, E, O]

    Creates a stream from a queue of values

  41. def fromChunkQueueWithShutdown[R, E, O](queue: ZQueue[Nothing, R, Any, E, Nothing, Chunk[O]]): ZStream[R, E, O]

    Creates a stream from a queue of values.

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

  42. def fromChunks[O](cs: Chunk[O]*): ZStream[Any, Nothing, O]

    Creates a stream from an arbitrary number of chunks.

  43. def fromHub[R, E, A](hub: ZHub[Nothing, R, Any, E, Nothing, A], maxChunkSize: Int = DefaultChunkSize): ZStream[R, E, A]

    Creates a stream from a subscription to a hub.

  44. def fromHubManaged[R, E, A](hub: ZHub[Nothing, R, Any, E, Nothing, A], maxChunkSize: Int = DefaultChunkSize): ZManaged[Any, Nothing, ZStream[R, E, A]]

    Creates a stream from a subscription to a hub in the context of a managed effect.

    Creates a stream from a subscription to a hub in the context of a managed effect. The managed effect describes subscribing to receive messages from the hub while the stream describes taking messages from the hub.

  45. def fromHubManagedWithShutdown[R, E, A](hub: ZHub[Nothing, R, Any, E, Nothing, A], maxChunkSize: Int = DefaultChunkSize): ZManaged[Any, Nothing, ZStream[R, E, A]]

    Creates a stream from a subscription to a hub in the context of a managed effect.

    Creates a stream from a subscription to a hub in the context of a managed effect. The managed effect describes subscribing to receive messages from the hub while the stream describes taking messages from the hub.

    The hub will be shut down once the stream is closed.

  46. def fromHubWithShutdown[R, E, A](hub: ZHub[Nothing, R, Any, E, Nothing, A], maxChunkSize: Int = DefaultChunkSize): ZStream[R, E, A]

    Creates a stream from a subscription to a hub.

    Creates a stream from a subscription to a hub.

    The hub will be shut down once the stream is closed.

  47. def fromInputStream(is: ⇒ InputStream, chunkSize: Int = ZStream.DefaultChunkSize): ZStream[Any, IOException, Byte]

    Creates a stream from a java.io.InputStream

    Creates a stream from a java.io.InputStream

    Definition Classes
    ZStreamPlatformSpecificConstructors
  48. def fromInputStreamManaged[R](is: ZManaged[R, IOException, InputStream], chunkSize: Int = ZStream.DefaultChunkSize): ZStream[R, IOException, Byte]

    Creates a stream from a managed java.io.InputStream value.

    Creates a stream from a managed java.io.InputStream value.

    Definition Classes
    ZStreamPlatformSpecificConstructors
  49. def fromInputStreamZIO[R](is: ZIO[R, IOException, InputStream], chunkSize: Int = ZStream.DefaultChunkSize): ZStream[R, IOException, Byte]

    Creates a stream from a java.io.InputStream.

    Creates a stream from a java.io.InputStream. Ensures that the input stream is closed after it is exhausted.

    Definition Classes
    ZStreamPlatformSpecificConstructors
  50. def fromIterable[O](as: ⇒ Iterable[O]): ZStream[Any, Nothing, O]

    Creates a stream from an iterable collection of values

  51. def fromIterableZIO[R, E, O](iterable: ZIO[R, E, Iterable[O]]): ZStream[R, E, O]

    Creates a stream from an effect producing a value of type Iterable[A]

  52. def fromIterator[A](iterator: ⇒ Iterator[A], maxChunkSize: Int = 1): ZStream[Any, Throwable, A]

    Creates a stream from an iterator that may throw exceptions.

  53. def fromIteratorManaged[R, A](iterator: ZManaged[R, Throwable, Iterator[A]]): ZStream[R, Throwable, A]

    Creates a stream from a managed iterator

  54. def fromIteratorSucceed[A](iterator: ⇒ Iterator[A], maxChunkSize: Int = 1): ZStream[Any, Nothing, A]

    Creates a stream from an iterator that does not throw exceptions.

  55. def fromIteratorZIO[R, A](iterator: ZIO[R, Throwable, Iterator[A]]): ZStream[R, Throwable, A]

    Creates a stream from an iterator that may potentially throw exceptions

  56. def fromJavaIterator[A](iterator: ⇒ Iterator[A]): ZStream[Any, Throwable, A]

    Creates a stream from a Java iterator that may throw exceptions

  57. def fromJavaIteratorManaged[R, A](iterator: ZManaged[R, Throwable, Iterator[A]]): ZStream[R, Throwable, A]

    Creates a stream from a managed iterator

  58. def fromJavaIteratorSucceed[A](iterator: ⇒ Iterator[A]): ZStream[Any, Nothing, A]

    Creates a stream from a Java iterator

  59. def fromJavaIteratorZIO[R, A](iterator: ZIO[R, Throwable, Iterator[A]]): ZStream[R, Throwable, A]

    Creates a stream from a Java iterator that may potentially throw exceptions

  60. def fromQueue[R, E, O](queue: ZQueue[Nothing, R, Any, E, Nothing, O], maxChunkSize: Int = DefaultChunkSize): ZStream[R, E, O]

    Creates a stream from a queue of values

    Creates a stream from a queue of values

    maxChunkSize

    Maximum number of queued elements to put in one chunk in the stream

  61. def fromQueueWithShutdown[R, E, O](queue: ZQueue[Nothing, R, Any, E, Nothing, O], maxChunkSize: Int = DefaultChunkSize): ZStream[R, E, O]

    Creates a stream from a queue of values.

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

    maxChunkSize

    Maximum number of queued elements to put in one chunk in the stream

  62. def fromSchedule[R, A](schedule: Schedule[R, Any, A]): ZStream[R with Has[Clock], Nothing, A]

    Creates a stream from a zio.Schedule that does not require any further input.

    Creates a stream from a zio.Schedule that does not require any further input. The stream will emit an element for each value output from the schedule, continuing for as long as the schedule continues.

  63. def fromTQueue[A](queue: TQueue[A]): ZStream[Any, Nothing, A]

    Creates a stream from a zio.stm.TQueue of values.

  64. def fromZIO[R, E, A](fa: ZIO[R, E, A]): ZStream[R, E, A]

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

  65. def fromZIOOption[R, E, A](fa: ZIO[R, Option[E], A]): ZStream[R, E, A]

    Creates a stream from an effect producing a value of type A or an empty Stream

  66. final def getClass(): Class[_]
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  67. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  68. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  69. 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))), ...

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

    Creates a single-valued stream from a managed resource

  71. def mergeAll[R, E, O](n: Int, outputBuffer: Int = 16)(streams: ZStream[R, E, O]*): ZStream[R, E, O]

    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 chunks may be buffered by this operator.

  72. def mergeAllUnbounded[R, E, O](outputBuffer: Int = 16)(streams: ZStream[R, E, O]*): ZStream[R, E, O]

    Like mergeAll, but runs all streams concurrently.

  73. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  74. val never: ZStream[Any, Nothing, Nothing]

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

  75. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  76. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  77. def paginate[R, E, A, S](s: S)(f: (S) ⇒ (A, Option[S])): ZStream[Any, Nothing, A]

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

    Like unfold, 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.

  78. def paginateChunk[A, S](s: S)(f: (S) ⇒ (Chunk[A], Option[S])): ZStream[Any, Nothing, A]

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

    Like unfoldChunk, 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.

  79. def paginateChunkZIO[R, E, A, S](s: S)(f: (S) ⇒ ZIO[R, E, (Chunk[A], Option[S])]): ZStream[R, E, A]

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

    Like unfoldChunkZIO, 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.

  80. def paginateZIO[R, E, A, S](s: S)(f: (S) ⇒ ZIO[R, E, (A, Option[S])]): ZStream[R, E, A]

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

    Like unfoldZIO, 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.

  81. def range(min: Int, max: Int, chunkSize: Int = DefaultChunkSize): ZStream[Any, Nothing, Int]

    Constructs a stream from a range of integers (lower bound included, upper bound not included)

  82. def repeat[A](a: ⇒ A): ZStream[Any, Nothing, A]

    Repeats the provided value infinitely.

  83. def repeatWithSchedule[R, A](a: ⇒ A, schedule: Schedule[R, A, _]): ZStream[R with Has[Clock], Nothing, A]

    Repeats the value using the provided schedule.

  84. def repeatZIO[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.

  85. def repeatZIOChunk[R, E, A](fa: ZIO[R, E, Chunk[A]]): ZStream[R, E, A]

    Creates a stream from an effect producing chunks of A values which repeats forever.

  86. def repeatZIOChunkOption[R, E, A](fa: ZIO[R, Option[E], Chunk[A]]): ZStream[R, E, A]

    Creates a stream from an effect producing chunks of A values until it fails with None.

  87. def repeatZIOOption[R, E, A](fa: ZIO[R, Option[E], A]): ZStream[R, E, A]

    Creates a stream from an effect producing values of type A until it fails with None.

  88. def repeatZIOWithSchedule[R, E, A](effect: ZIO[R, E, A], schedule: Schedule[R, A, Any]): ZStream[R with Has[Clock], E, A]

    Creates a stream from an effect producing a value of type A, which is repeated using the specified schedule.

  89. def service[A](implicit arg0: zio.Tag[A]): ZStream[Has[A], Nothing, A]

    Accesses the specified service in the environment of the effect.

  90. def serviceAt[Service]: ServiceAtPartiallyApplied[Service]

    Accesses the service corresponding to the specified key in the environment.

  91. def serviceWith[Service]: ServiceWithPartiallyApplied[Service]

    Accesses the specified service in the environment of the stream in the context of an effect.

  92. def serviceWithStream[Service]: ServiceWithStreamPartiallyApplied[Service]

    Accesses the specified service in the environment of the stream in the context of a stream.

  93. def succeed[A](a: ⇒ A): ZStream[Any, Nothing, A]

    Creates a single-valued pure stream

  94. final def synchronized[T0](arg0: ⇒ T0): T0
    Definition Classes
    AnyRef
  95. def tick(interval: zio.Duration): ZStream[Has[Clock], Nothing, Unit]

    A stream that emits Unit values spaced by the specified duration.

  96. def toString(): String
    Definition Classes
    AnyRef → Any
  97. def unfold[S, A](s: S)(f: (S) ⇒ Option[(A, S)]): ZStream[Any, Nothing, A]

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

  98. def unfoldChunk[S, A](s: S)(f: (S) ⇒ Option[(Chunk[A], S)]): ZStream[Any, Nothing, A]

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

  99. def unfoldChunkZIO[R, E, A, S](s: S)(f: (S) ⇒ ZIO[R, E, Option[(Chunk[A], S)]]): ZStream[R, E, A]

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

  100. def unfoldZIO[R, E, A, S](s: S)(f: (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

  101. val unit: ZStream[Any, Nothing, Unit]

    A stream that contains a single Unit value.

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

    Creates a stream produced from an effect

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

    Creates a stream produced from a ZManaged

  104. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  105. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  106. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... ) @native()
  107. def when[R, E, O](b: ⇒ Boolean)(zStream: ⇒ ZStream[R, E, O]): ZStream[R, E, O]

    Returns the specified stream if the given condition is satisfied, otherwise returns an empty stream.

  108. def whenCase[R, E, A, O](a: ⇒ A)(pf: PartialFunction[A, ZStream[R, E, O]]): ZStream[R, E, O]

    Returns the resulting stream when the given PartialFunction is defined for the given value, otherwise returns an empty stream.

  109. def whenCaseZIO[R, E, A](a: ZIO[R, E, A]): WhenCaseZIO[R, E, A]

    Returns the resulting stream when the given PartialFunction is defined for the given effectful value, otherwise returns an empty stream.

  110. def whenZIO[R, E](b: ZIO[R, E, Boolean]): WhenZIO[R, E]

    Returns the specified stream if the given effectful condition is satisfied, otherwise returns an empty stream.

  111. object TerminationStrategy
  112. object ZStreamConstructor extends ZStreamConstructorPlatformSpecific

Deprecated Value Members

  1. def accessM[R]: AccessZIOPartiallyApplied[R]

    Accesses the environment of the stream in the context of an effect.

    Accesses the environment of the stream in the context of an effect.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use accessZIO

  2. def bracket[R, E, A](acquire: ZIO[R, E, A])(release: (A) ⇒ URIO[R, Any]): ZStream[R, E, A]

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

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

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use acquireReleaseWith

  3. def bracketExit[R, E, A](acquire: ZIO[R, E, A])(release: (A, Exit[Any, Any]) ⇒ URIO[R, Any]): ZStream[R, E, A]

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

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

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use acquireReleaseExitWith

  4. def crossN[R, E, A, B, C, D, F](zStream1: ZStream[R, E, A], zStream2: ZStream[R, E, B], zStream3: ZStream[R, E, C], zStream4: ZStream[R, E, D])(f: (A, B, C, D) ⇒ F): ZStream[R, E, F]

    Composes the specified streams to create a cartesian product of elements with a specified function.

    Composes the specified streams to create a cartesian product of elements with a specified function. Subsequent stream would be run multiple times, for every combination of elements in the prior streams.

    See also ZStream#zipN[R,E,A,B,C,D,F]* for the more common point-wise variant.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use cross

  5. def crossN[R, E, A, B, C, D](zStream1: ZStream[R, E, A], zStream2: ZStream[R, E, B], zStream3: ZStream[R, E, C])(f: (A, B, C) ⇒ D): ZStream[R, E, D]

    Composes the specified streams to create a cartesian product of elements with a specified function.

    Composes the specified streams to create a cartesian product of elements with a specified function. Subsequent stream would be run multiple times, for every combination of elements in the prior streams.

    See also ZStream#zipN[R,E,A,B,C,D]* for the more common point-wise variant.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use cross

  6. def crossN[R, E, A, B, C](zStream1: ZStream[R, E, A], zStream2: ZStream[R, E, B])(f: (A, B) ⇒ C): ZStream[R, E, C]

    Composes the specified streams to create a cartesian product of elements with a specified function.

    Composes the specified streams to create a cartesian product of elements with a specified function. Subsequent streams would be run multiple times, for every combination of elements in the prior streams.

    See also ZStream#zipN[R,E,A,B,C]* for the more common point-wise variant.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use cross

  7. def effectAsync[R, E, A](register: (Emit[R, E, A, Future[Boolean]]) ⇒ 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.

    Definition Classes
    ZStreamPlatformSpecificConstructors
    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use async

  8. def effectAsyncInterrupt[R, E, A](register: (Emit[R, E, A, Future[Boolean]]) ⇒ 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.

    Definition Classes
    ZStreamPlatformSpecificConstructors
    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use asyncInterrupt

  9. def effectAsyncM[R, E, A](register: (Emit[R, E, A, Future[Boolean]]) ⇒ 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.

    Definition Classes
    ZStreamPlatformSpecificConstructors
    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use asyncZIO

  10. def effectAsyncMaybe[R, E, A](register: (Emit[R, E, A, Future[Boolean]]) ⇒ 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.

    Definition Classes
    ZStreamPlatformSpecificConstructors
    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use asyncMaybe

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

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

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use fromZIO

  12. def fromEffectOption[R, E, A](fa: ZIO[R, Option[E], A]): ZStream[R, E, A]

    Creates a stream from an effect producing a value of type A or an empty Stream

    Creates a stream from an effect producing a value of type A or an empty Stream

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use fromZIOOption

  13. def fromInputStreamEffect[R](is: ZIO[R, IOException, InputStream], chunkSize: Int = ZStream.DefaultChunkSize): ZStream[R, IOException, Byte]

    Creates a stream from a java.io.InputStream.

    Creates a stream from a java.io.InputStream. Ensures that the input stream is closed after it is exhausted.

    Definition Classes
    ZStreamPlatformSpecificConstructors
    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use fromInputStreamZIO

  14. def fromIterableM[R, E, O](iterable: ZIO[R, E, Iterable[O]]): ZStream[R, E, O]

    Creates a stream from an effect producing a value of type Iterable[A]

    Creates a stream from an effect producing a value of type Iterable[A]

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use fromIterableZIO

  15. def fromIteratorEffect[R, A](iterator: ZIO[R, Throwable, Iterator[A]]): ZStream[R, Throwable, A]

    Creates a stream from an iterator that may potentially throw exceptions

    Creates a stream from an iterator that may potentially throw exceptions

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use fromIteratorZIO

  16. def fromIteratorTotal[A](iterator: ⇒ Iterator[A], maxChunkSize: Int = 1): ZStream[Any, Nothing, A]

    Creates a stream from an iterator that does not throw exceptions.

    Creates a stream from an iterator that does not throw exceptions.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use fromIteratorSucceed

  17. def fromJavaIteratorEffect[R, A](iterator: ZIO[R, Throwable, Iterator[A]]): ZStream[R, Throwable, A]

    Creates a stream from a Java iterator that may potentially throw exceptions

    Creates a stream from a Java iterator that may potentially throw exceptions

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use fromJavaIteratorZIO

  18. def fromJavaIteratorTotal[A](iterator: ⇒ Iterator[A]): ZStream[Any, Nothing, A]

    Creates a stream from a Java iterator

    Creates a stream from a Java iterator

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use fromJavaIteratorSucceed

  19. def halt[E](cause: ⇒ Cause[E]): ZStream[Any, E, Nothing]

    The stream that always halts with cause.

    The stream that always halts with cause.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use failCause

  20. def paginateChunkM[R, E, A, S](s: S)(f: (S) ⇒ ZIO[R, E, (Chunk[A], Option[S])]): ZStream[R, E, A]

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

    Like unfoldChunkM, 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.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use paginateChunkZIO

  21. def paginateM[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.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use paginateZIO

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

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

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use repeatZIO

  23. def repeatEffectChunk[R, E, A](fa: ZIO[R, E, Chunk[A]]): ZStream[R, E, A]

    Creates a stream from an effect producing chunks of A values which repeats forever.

    Creates a stream from an effect producing chunks of A values which repeats forever.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use repeatZIOChunk

  24. def repeatEffectChunkOption[R, E, A](fa: ZIO[R, Option[E], Chunk[A]]): ZStream[R, E, A]

    Creates a stream from an effect producing chunks of A values until it fails with None.

    Creates a stream from an effect producing chunks of A values until it fails with None.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use repeatZIOChunkOption

  25. def repeatEffectOption[R, E, A](fa: ZIO[R, Option[E], A]): ZStream[R, E, A]

    Creates a stream from an effect producing values of type A until it fails with None.

    Creates a stream from an effect producing values of type A until it fails with None.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use repeatZIOOption

  26. def repeatEffectWith[R, E, A](effect: ZIO[R, E, A], schedule: Schedule[R, A, Any]): ZStream[R with Has[Clock], E, A]

    Creates a stream from an effect producing a value of type A, which is repeated using the specified schedule.

    Creates a stream from an effect producing a value of type A, which is repeated using the specified schedule.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use repeatZIOWithSchedule

  27. def repeatWith[R, A](a: ⇒ A, schedule: Schedule[R, A, _]): ZStream[R with Has[Clock], Nothing, A]

    Repeats the value using the provided schedule.

    Repeats the value using the provided schedule.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use repeatWithSchedule

  28. def services[A, B, C, D](implicit arg0: zio.Tag[A], arg1: zio.Tag[B], arg2: zio.Tag[C], arg3: zio.Tag[D]): ZStream[Has[A] with Has[B] with Has[C] with Has[D], Nothing, (A, B, C, D)]

    Accesses the specified services in the environment of the stream.

    Accesses the specified services in the environment of the stream.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use service

  29. def services[A, B, C](implicit arg0: zio.Tag[A], arg1: zio.Tag[B], arg2: zio.Tag[C]): ZStream[Has[A] with Has[B] with Has[C], Nothing, (A, B, C)]

    Accesses the specified services in the environment of the stream.

    Accesses the specified services in the environment of the stream.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use service

  30. def services[A, B](implicit arg0: zio.Tag[A], arg1: zio.Tag[B]): ZStream[Has[A] with Has[B], Nothing, (A, B)]

    Accesses the specified services in the environment of the effect.

    Accesses the specified services in the environment of the effect.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use service

  31. def unfoldChunkM[R, E, A, S](s: S)(f: (S) ⇒ ZIO[R, E, Option[(Chunk[A], S)]]): ZStream[R, E, A]

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

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

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use unfoldChunkZIO

  32. def unfoldM[R, E, A, S](s: S)(f: (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

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

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use unfoldZIO

  33. def whenCaseM[R, E, A](a: ZIO[R, E, A]): WhenCaseZIO[R, E, A]

    Returns the resulting stream when the given PartialFunction is defined for the given effectful value, otherwise returns an empty stream.

    Returns the resulting stream when the given PartialFunction is defined for the given effectful value, otherwise returns an empty stream.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use whenCaseZIO

  34. def whenM[R, E](b: ZIO[R, E, Boolean]): WhenZIO[R, E]

    Returns the specified stream if the given effectful condition is satisfied, otherwise returns an empty stream.

    Returns the specified stream if the given effectful condition is satisfied, otherwise returns an empty stream.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use whenZIO

  35. def zipN[R, E, A, B, C, D, F](zStream1: ZStream[R, E, A], zStream2: ZStream[R, E, B], zStream3: ZStream[R, E, C], zStream4: ZStream[R, E, D])(f: (A, B, C, D) ⇒ F): ZStream[R, E, F]

    Returns an effect that executes the specified effects in parallel, combining their results with the specified f function.

    Returns an effect that executes the specified effects in parallel, combining their results with the specified f function. If any effect fails, then the other effects will be interrupted.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use zip

  36. def zipN[R, E, A, B, C, D](zStream1: ZStream[R, E, A], zStream2: ZStream[R, E, B], zStream3: ZStream[R, E, C])(f: (A, B, C) ⇒ D): ZStream[R, E, D]

    Zips with specified streams together with the specified function.

    Zips with specified streams together with the specified function.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use zip

  37. def zipN[R, E, A, B, C](zStream1: ZStream[R, E, A], zStream2: ZStream[R, E, B])(f: (A, B) ⇒ C): ZStream[R, E, C]

    Zips the specified streams together with the specified function.

    Zips the specified streams together with the specified function.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use zip

Inherited from ZStreamPlatformSpecificConstructors

Inherited from AnyRef

Inherited from Any

Ungrouped