Object/Class

zio.stream

ZStream

Related Docs: class ZStream | package stream

Permalink

object ZStream extends ZStreamPlatformSpecificConstructors

Linear Supertypes
ZStreamPlatformSpecificConstructors, AnyRef, Any
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. trait Emit[+R, -E, -A, +B] extends (ZIO[R, Option[E], Chunk[A]]) ⇒ B

    Permalink

    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.

  2. final class EnvironmentWithPartiallyApplied[R] extends AnyVal

    Permalink
  3. final class EnvironmentWithStreamPartiallyApplied[R] extends AnyVal

    Permalink
  4. final class EnvironmentWithZIOPartiallyApplied[R] extends AnyVal

    Permalink
  5. sealed trait GroupBy[-R, +E, +K, +V] extends AnyRef

    Permalink

    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. sealed trait HaltStrategy extends AnyRef

    Permalink
  7. final class ProvideSomeLayer[R0, -R, +E, +A] extends AnyVal

    Permalink
  8. type Pull[-R, +E, +A] = ZIO[R, Option[E], Chunk[A]]

    Permalink
  9. implicit final class RefineToOrDieOps[R, E <: Throwable, A] extends AnyVal

    Permalink
  10. final class ScopedPartiallyApplied[R] extends AnyVal

    Permalink
  11. final class ServiceAtPartiallyApplied[Service] extends AnyVal

    Permalink
  12. final class ServiceWithPartiallyApplied[Service] extends AnyVal

    Permalink
  13. final class ServiceWithStreamPartiallyApplied[Service] extends AnyVal

    Permalink
  14. final class ServiceWithZIOPartiallyApplied[Service] extends AnyVal

    Permalink
  15. implicit final class SortedByKey[R, E, K, A] extends AnyRef

    Permalink

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

  16. implicit final class SyntaxOps[-R, +E, O] extends AnyRef

    Permalink
  17. final class UnwrapScopedPartiallyApplied[R] extends AnyVal

    Permalink
  18. final class UpdateService[-R, +E, +A, M] extends AnyVal

    Permalink
  19. final class UpdateServiceAt[-R, +E, +A, Service] extends AnyVal

    Permalink
  20. final class WhenCaseZIO[R, E, A] extends AnyVal

    Permalink
  21. final class WhenZIO[R, E] extends AnyVal

    Permalink
  22. trait ZStreamConstructor[Input] extends AnyRef

    Permalink

    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.

  23. trait ZStreamConstructorLowPriority1 extends ZStreamConstructorLowPriority2

    Permalink
  24. trait ZStreamConstructorLowPriority2 extends ZStreamConstructorLowPriority3

    Permalink
  25. trait ZStreamConstructorLowPriority3 extends AnyRef

    Permalink
  26. trait ZStreamConstructorPlatformSpecific extends ZStreamConstructorLowPriority1

    Permalink
    Definition Classes
    ZStreamPlatformSpecificConstructors

Value Members

  1. final def !=(arg0: Any): Boolean

    Permalink
    Definition Classes
    AnyRef → Any
  2. final def ##(): Int

    Permalink
    Definition Classes
    AnyRef → Any
  3. final def ==(arg0: Any): Boolean

    Permalink
    Definition Classes
    AnyRef → Any
  4. final val DefaultChunkSize: Int(4096)

    Permalink

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

  5. object HaltStrategy

    Permalink
  6. object ZStreamConstructor extends ZStreamConstructorPlatformSpecific

    Permalink
  7. def absolve[R, E, O](xs: ZStream[R, E, Either[E, O]])(implicit trace: Trace): ZStream[R, E, O]

    Permalink

    Submerges the error case of an Either into the ZStream.

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

    Permalink

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

  9. def acquireReleaseWith[R, E, A](acquire: ⇒ ZIO[R, E, A])(release: (A) ⇒ URIO[R, Any])(implicit trace: Trace): ZStream[R, E, A]

    Permalink

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

  10. def apply[A](as: A*)(implicit trace: Trace): ZStream[Any, Nothing, A]

    Permalink

    Creates a pure stream from a variable list of values

  11. final def asInstanceOf[T0]: T0

    Permalink
    Definition Classes
    Any
  12. def async[R, E, A](register: (Emit[R, E, A, Future[Boolean]]) ⇒ Unit, outputBuffer: ⇒ Int = 16)(implicit trace: Trace): ZStream[R, E, A]

    Permalink

    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
  13. def asyncInterrupt[R, E, A](register: (Emit[R, E, A, Future[Boolean]]) ⇒ Either[URIO[R, Any], ZStream[R, E, A]], outputBuffer: ⇒ Int = 16)(implicit trace: Trace): ZStream[R, E, A]

    Permalink

    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
  14. def asyncMaybe[R, E, A](register: (Emit[R, E, A, Future[Boolean]]) ⇒ Option[ZStream[R, E, A]], outputBuffer: ⇒ Int = 16)(implicit trace: Trace): ZStream[R, E, A]

    Permalink

    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
  15. def asyncScoped[R, E, A](register: ((ZIO[R, Option[E], Chunk[A]]) ⇒ Future[Boolean]) ⇒ ZIO[R with Scope, E, Any], outputBuffer: ⇒ Int = 16)(implicit trace: Trace): ZStream[R, E, A]

    Permalink

    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 scoped 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
  16. def asyncZIO[R, E, A](register: (Emit[R, E, A, Future[Boolean]]) ⇒ ZIO[R, E, Any], outputBuffer: ⇒ Int = 16)(implicit trace: Trace): ZStream[R, E, A]

    Permalink

    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
  17. def blocking[R, E, A](stream: ⇒ ZStream[R, E, A])(implicit trace: Trace): ZStream[R, E, A]

    Permalink

    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.

  18. def clone(): AnyRef

    Permalink
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  19. def concatAll[R, E, O](streams: ⇒ Chunk[ZStream[R, E, O]])(implicit trace: Trace): ZStream[R, E, O]

    Permalink

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

  20. def debug(value: ⇒ Any)(implicit trace: Trace): ZStream[Any, Nothing, Unit]

    Permalink

    Prints the specified message to the console for debugging purposes.

  21. def die(ex: ⇒ Throwable)(implicit trace: Trace): ZStream[Any, Nothing, Nothing]

    Permalink

    The stream that dies with the ex.

  22. def dieMessage(msg: ⇒ String)(implicit trace: Trace): ZStream[Any, Nothing, Nothing]

    Permalink

    The stream that dies with an exception described by msg.

  23. def done[E, A](exit: ⇒ Exit[E, A])(implicit trace: Trace): ZStream[Any, E, A]

    Permalink

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

  24. def empty(implicit trace: Trace): ZStream[Any, Nothing, Nothing]

    Permalink

    The empty stream

  25. def environment[R](implicit trace: Trace): ZStream[R, Nothing, ZEnvironment[R]]

    Permalink

    Accesses the whole environment of the stream.

  26. def environmentWith[R]: EnvironmentWithPartiallyApplied[R]

    Permalink

    Accesses the environment of the stream.

  27. def environmentWithStream[R]: EnvironmentWithStreamPartiallyApplied[R]

    Permalink

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

  28. def environmentWithZIO[R]: EnvironmentWithZIOPartiallyApplied[R]

    Permalink

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

  29. final def eq(arg0: AnyRef): Boolean

    Permalink
    Definition Classes
    AnyRef
  30. def equals(arg0: Any): Boolean

    Permalink
    Definition Classes
    AnyRef → Any
  31. def execute[R, E](zio: ⇒ ZIO[R, E, Any])(implicit trace: Trace): ZStream[R, E, Nothing]

    Permalink

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

  32. def fail[E](error: ⇒ E)(implicit trace: Trace): ZStream[Any, E, Nothing]

    Permalink

    The stream that always fails with the error

  33. def failCause[E](cause: ⇒ Cause[E])(implicit trace: Trace): ZStream[Any, E, Nothing]

    Permalink

    The stream that always fails with cause.

  34. def finalize(): Unit

    Permalink
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  35. def finalizer[R](finalizer: ⇒ URIO[R, Any])(implicit trace: Trace): ZStream[R, Nothing, Any]

    Permalink

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

  36. def from[Input](input: ⇒ Input)(implicit constructor: ZStreamConstructor[Input], trace: Trace): Out

    Permalink
  37. def fromChannel[R, E, A](channel: ZChannel[R, Any, Any, Any, E, Chunk[A], Any]): ZStream[R, E, A]

    Permalink

    Creates a stream from a zio.stream.ZChannel

  38. def fromChunk[O](chunk: ⇒ Chunk[O])(implicit trace: Trace): ZStream[Any, Nothing, O]

    Permalink

    Creates a stream from a zio.Chunk of values

    Creates a stream from a zio.Chunk of values

    returns

    a finite stream of values

  39. def fromChunkHub[O](hub: ⇒ Hub[Chunk[O]])(implicit trace: Trace): ZStream[Any, Nothing, O]

    Permalink

    Creates a stream from a subscription to a hub.

  40. def fromChunkHubScoped[O](hub: ⇒ Hub[Chunk[O]])(implicit trace: Trace): ZIO[Scope, Nothing, ZStream[Any, Nothing, O]]

    Permalink

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

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

  41. def fromChunkHubScopedWithShutdown[O](hub: ⇒ Hub[Chunk[O]])(implicit trace: Trace): ZIO[Scope, Nothing, ZStream[Any, Nothing, O]]

    Permalink

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

    Creates a stream from a subscription to a hub in the context of a scoped effect. The scoped 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.

  42. def fromChunkHubWithShutdown[O](hub: ⇒ Hub[Chunk[O]])(implicit trace: Trace): ZStream[Any, Nothing, O]

    Permalink

    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.

  43. def fromChunkQueue[O](queue: ⇒ Dequeue[Chunk[O]])(implicit trace: Trace): ZStream[Any, Nothing, O]

    Permalink

    Creates a stream from a queue of values

  44. def fromChunkQueueWithShutdown[O](queue: ⇒ Dequeue[Chunk[O]])(implicit trace: Trace): ZStream[Any, Nothing, O]

    Permalink

    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.

  45. def fromChunks[O](cs: Chunk[O]*)(implicit trace: Trace): ZStream[Any, Nothing, O]

    Permalink

    Creates a stream from an arbitrary number of chunks.

  46. def fromHub[A](hub: ⇒ Hub[A], maxChunkSize: ⇒ Int = DefaultChunkSize)(implicit trace: Trace): ZStream[Any, Nothing, A]

    Permalink

    Creates a stream from a subscription to a hub.

  47. def fromHubScoped[A](hub: ⇒ Hub[A], maxChunkSize: ⇒ Int = DefaultChunkSize)(implicit trace: Trace): ZIO[Scope, Nothing, ZStream[Any, Nothing, A]]

    Permalink

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

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

  48. def fromHubScopedWithShutdown[A](hub: ⇒ Hub[A], maxChunkSize: ⇒ Int = DefaultChunkSize)(implicit trace: Trace): ZIO[Scope, Nothing, ZStream[Any, Nothing, A]]

    Permalink

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

    Creates a stream from a subscription to a hub in the context of a scoped effect. The scoped 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.

  49. def fromHubWithShutdown[A](hub: ⇒ Hub[A], maxChunkSize: ⇒ Int = DefaultChunkSize)(implicit trace: Trace): ZStream[Any, Nothing, A]

    Permalink

    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.

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

    Permalink

    Creates a stream from a java.io.InputStream

  51. def fromInputStreamScoped[R](is: ⇒ ZIO[Scope with R, IOException, InputStream], chunkSize: ⇒ Int = ZStream.DefaultChunkSize)(implicit trace: Trace): ZStream[R, IOException, Byte]

    Permalink

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

  52. def fromInputStreamZIO[R](is: ⇒ ZIO[R, IOException, InputStream], chunkSize: ⇒ Int = ZStream.DefaultChunkSize)(implicit trace: Trace): ZStream[R, IOException, Byte]

    Permalink

    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.

  53. def fromIterable[O](as: ⇒ Iterable[O], chunkSize: ⇒ Int)(implicit trace: Trace): ZStream[Any, Nothing, O]

    Permalink

    Creates a stream from an iterable collection of values

  54. def fromIterable[O](as: ⇒ Iterable[O])(implicit trace: Trace): ZStream[Any, Nothing, O]

    Permalink

    Creates a stream from an iterable collection of values

  55. def fromIterableZIO[R, E, O](iterable: ⇒ ZIO[R, E, Iterable[O]], chunkSize: ⇒ Int)(implicit trace: Trace): ZStream[R, E, O]

    Permalink

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

  56. def fromIterableZIO[R, E, O](iterable: ⇒ ZIO[R, E, Iterable[O]])(implicit trace: Trace): ZStream[R, E, O]

    Permalink

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

  57. def fromIterator[A](iterator: ⇒ Iterator[A], maxChunkSize: ⇒ Int = DefaultChunkSize)(implicit trace: Trace): ZStream[Any, Throwable, A]

    Permalink

    Creates a stream from an iterator

  58. def fromIteratorScoped[R, A](iterator: ⇒ ZIO[Scope with R, Throwable, Iterator[A]], maxChunkSize: ⇒ Int = DefaultChunkSize)(implicit trace: Trace): ZStream[R, Throwable, A]

    Permalink

    Creates a stream from a scoped iterator

  59. def fromIteratorSucceed[A](iterator: ⇒ Iterator[A], maxChunkSize: ⇒ Int = DefaultChunkSize)(implicit trace: Trace): ZStream[Any, Nothing, A]

    Permalink

    Creates a stream from an iterator

  60. def fromIteratorZIO[R, A](iterator: ⇒ ZIO[R, Throwable, Iterator[A]], chunkSize: Int)(implicit trace: Trace): ZStream[R, Throwable, A]

    Permalink

    Creates a stream from an iterator that may potentially throw exceptions

  61. def fromIteratorZIO[R, A](iterator: ⇒ ZIO[R, Throwable, Iterator[A]])(implicit trace: Trace): ZStream[R, Throwable, A]

    Permalink

    Creates a stream from an iterator that may potentially throw exceptions

  62. def fromJavaIterator[A](iterator: ⇒ Iterator[A], chunkSize: Int)(implicit trace: Trace): ZStream[Any, Throwable, A]

    Permalink

    Creates a stream from a Java iterator that may throw exceptions

  63. def fromJavaIterator[A](iterator: ⇒ Iterator[A])(implicit trace: Trace): ZStream[Any, Throwable, A]

    Permalink

    Creates a stream from a Java iterator that may throw exceptions

  64. def fromJavaIteratorScoped[R, A](iterator: ⇒ ZIO[Scope with R, Throwable, Iterator[A]], chunkSize: Int)(implicit trace: Trace): ZStream[R, Throwable, A]

    Permalink

    Creates a stream from a scoped iterator

  65. def fromJavaIteratorScoped[R, A](iterator: ⇒ ZIO[Scope with R, Throwable, Iterator[A]])(implicit trace: Trace): ZStream[R, Throwable, A]

    Permalink

    Creates a stream from a scoped iterator

  66. def fromJavaIteratorSucceed[A](iterator: ⇒ Iterator[A], chunkSize: Int)(implicit trace: Trace): ZStream[Any, Nothing, A]

    Permalink

    Creates a stream from a Java iterator

  67. def fromJavaIteratorSucceed[A](iterator: ⇒ Iterator[A])(implicit trace: Trace): ZStream[Any, Nothing, A]

    Permalink

    Creates a stream from a Java iterator

  68. def fromJavaIteratorZIO[R, A](iterator: ⇒ ZIO[R, Throwable, Iterator[A]], chunkSize: Int)(implicit trace: Trace): ZStream[R, Throwable, A]

    Permalink

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

  69. def fromJavaIteratorZIO[R, A](iterator: ⇒ ZIO[R, Throwable, Iterator[A]])(implicit trace: Trace): ZStream[R, Throwable, A]

    Permalink

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

  70. def fromPull[R, E, A](zio: ZIO[Scope with R, Nothing, ZIO[R, Option[E], Chunk[A]]])(implicit trace: Trace): ZStream[R, E, A]

    Permalink

    Creates a stream from a ZIO effect that pulls elements from another stream.

    Creates a stream from a ZIO effect that pulls elements from another stream. See toPull for reference

  71. def fromQueue[O](queue: ⇒ Dequeue[O], maxChunkSize: ⇒ Int = DefaultChunkSize)(implicit trace: Trace): ZStream[Any, Nothing, O]

    Permalink

    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

  72. def fromQueueWithShutdown[O](queue: ⇒ Dequeue[O], maxChunkSize: ⇒ Int = DefaultChunkSize)(implicit trace: Trace): ZStream[Any, Nothing, O]

    Permalink

    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

  73. def fromSchedule[R, A](schedule: ⇒ Schedule[R, Any, A])(implicit trace: Trace): ZStream[R, Nothing, A]

    Permalink

    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.

  74. def fromTQueue[A](queue: ⇒ TDequeue[A])(implicit trace: Trace): ZStream[Any, Nothing, A]

    Permalink

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

  75. def fromZIO[R, E, A](fa: ⇒ ZIO[R, E, A])(implicit trace: Trace): ZStream[R, E, A]

    Permalink

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

  76. def fromZIOOption[R, E, A](fa: ⇒ ZIO[R, Option[E], A])(implicit trace: Trace): ZStream[R, E, A]

    Permalink

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

  77. final def getClass(): Class[_]

    Permalink
    Definition Classes
    AnyRef → Any
  78. def hashCode(): Int

    Permalink
    Definition Classes
    AnyRef → Any
  79. final def isInstanceOf[T0]: Boolean

    Permalink
    Definition Classes
    Any
  80. def iterate[A](a: ⇒ A)(f: (A) ⇒ A)(implicit trace: Trace): ZStream[Any, Nothing, A]

    Permalink

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

  81. def log(message: ⇒ String)(implicit trace: Trace): ZStream[Any, Nothing, Unit]

    Permalink

    Logs the specified message at the current log level.

  82. def logAnnotate(annotations: ⇒ Set[LogAnnotation])(implicit trace: Trace): ZStream[Any, Nothing, Unit]

    Permalink

    Annotates each log in streams composed after this with the specified log annotation.

  83. def logAnnotate(annotation: ⇒ LogAnnotation, annotations: LogAnnotation*)(implicit trace: Trace): ZStream[Any, Nothing, Unit]

    Permalink

    Annotates each log in streams composed after this with the specified log annotation.

  84. def logAnnotate(key: ⇒ String, value: ⇒ String)(implicit trace: Trace): ZStream[Any, Nothing, Unit]

    Permalink

    Annotates each log in streams composed after this with the specified log annotation.

  85. def logAnnotations(implicit trace: Trace): ZStream[Any, Nothing, Map[String, String]]

    Permalink

    Retrieves the log annotations associated with the current scope.

  86. def logDebug(message: ⇒ String)(implicit trace: Trace): ZStream[Any, Nothing, Unit]

    Permalink

    Logs the specified message at the debug log level.

  87. def logError(message: ⇒ String)(implicit trace: Trace): ZStream[Any, Nothing, Unit]

    Permalink

    Logs the specified message at the error log level.

  88. def logErrorCause(cause: ⇒ Cause[Any])(implicit trace: Trace): ZStream[Any, Nothing, Unit]

    Permalink

    Logs the specified cause as an error.

  89. def logFatal(message: ⇒ String)(implicit trace: Trace): ZStream[Any, Nothing, Unit]

    Permalink

    Logs the specified message at the fatal log level.

  90. def logInfo(message: ⇒ String)(implicit trace: Trace): ZStream[Any, Nothing, Unit]

    Permalink

    Logs the specified message at the informational log level.

  91. def logLevel(level: LogLevel)(implicit trace: Trace): ZStream[Any, Nothing, Unit]

    Permalink

    Sets the log level for streams composed after this.

  92. def logSpan(label: ⇒ String)(implicit trace: Trace): ZStream[Any, Nothing, Unit]

    Permalink

    Adjusts the label for the logging span for streams composed after this.

  93. def logTrace(message: ⇒ String)(implicit trace: Trace): ZStream[Any, Nothing, Unit]

    Permalink

    Logs the specified message at the trace log level.

  94. def logWarning(message: ⇒ String)(implicit trace: Trace): ZStream[Any, Nothing, Unit]

    Permalink

    Logs the specified message at the warning log level.

  95. def mergeAll[R, E, O](n: ⇒ Int, outputBuffer: ⇒ Int = 16)(streams: ZStream[R, E, O]*)(implicit trace: Trace): ZStream[R, E, O]

    Permalink

    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.

  96. def mergeAllUnbounded[R, E, O](outputBuffer: ⇒ Int = 16)(streams: ZStream[R, E, O]*)(implicit trace: Trace): ZStream[R, E, O]

    Permalink

    Like mergeAll, but runs all streams concurrently.

  97. final def ne(arg0: AnyRef): Boolean

    Permalink
    Definition Classes
    AnyRef
  98. def never(implicit trace: Trace): ZStream[Any, Nothing, Nothing]

    Permalink

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

  99. final def notify(): Unit

    Permalink
    Definition Classes
    AnyRef
  100. final def notifyAll(): Unit

    Permalink
    Definition Classes
    AnyRef
  101. def paginate[R, E, A, S](s: ⇒ S)(f: (S) ⇒ (A, Option[S]))(implicit trace: Trace): ZStream[Any, Nothing, A]

    Permalink

    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.

  102. def paginateChunk[A, S](s: ⇒ S)(f: (S) ⇒ (Chunk[A], Option[S]))(implicit trace: Trace): ZStream[Any, Nothing, A]

    Permalink

    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.

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

    Permalink

    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.

  104. def paginateZIO[R, E, A, S](s: ⇒ S)(f: (S) ⇒ ZIO[R, E, (A, Option[S])])(implicit trace: Trace): ZStream[R, E, A]

    Permalink

    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.

  105. def provideLayer[RIn, E, ROut, RIn2, ROut2](layer: ZLayer[RIn, E, ROut])(stream: ⇒ ZStream[ROut with RIn2, E, ROut2])(implicit ev: zio.EnvironmentTag[RIn2], tag: zio.EnvironmentTag[ROut], trace: Trace): ZStream[RIn with RIn2, E, ROut2]

    Permalink
  106. def range(min: ⇒ Int, max: ⇒ Int, chunkSize: ⇒ Int = DefaultChunkSize)(implicit trace: Trace): ZStream[Any, Nothing, Int]

    Permalink

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

  107. def repeat[A](a: ⇒ A)(implicit trace: Trace): ZStream[Any, Nothing, A]

    Permalink

    Repeats the provided value infinitely.

  108. def repeatWithSchedule[R, A](a: ⇒ A, schedule: ⇒ Schedule[R, A, _])(implicit trace: Trace): ZStream[R, Nothing, A]

    Permalink

    Repeats the value using the provided schedule.

  109. def repeatZIO[R, E, A](fa: ⇒ ZIO[R, E, A])(implicit trace: Trace): ZStream[R, E, A]

    Permalink

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

  110. def repeatZIOChunk[R, E, A](fa: ⇒ ZIO[R, E, Chunk[A]])(implicit trace: Trace): ZStream[R, E, A]

    Permalink

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

  111. def repeatZIOChunkOption[R, E, A](fa: ⇒ ZIO[R, Option[E], Chunk[A]])(implicit trace: Trace): ZStream[R, E, A]

    Permalink

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

  112. def repeatZIOOption[R, E, A](fa: ⇒ ZIO[R, Option[E], A])(implicit trace: Trace): ZStream[R, E, A]

    Permalink

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

  113. def repeatZIOWithSchedule[R, E, A](effect: ⇒ ZIO[R, E, A], schedule: ⇒ Schedule[R, A, Any])(implicit trace: Trace): ZStream[R, E, A]

    Permalink

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

  114. def scoped[R]: ScopedPartiallyApplied[R]

    Permalink

    Creates a single-valued stream from a scoped resource

  115. def service[A](implicit arg0: Tag[A], trace: Trace): ZStream[A, Nothing, A]

    Permalink

    Accesses the specified service in the environment of the effect.

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

    Permalink

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

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

    Permalink

    Accesses the specified service in the environment of the stream.

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

    Permalink

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

  119. def serviceWithZIO[Service]: ServiceWithZIOPartiallyApplied[Service]

    Permalink

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

  120. def succeed[A](a: ⇒ A)(implicit trace: Trace): ZStream[Any, Nothing, A]

    Permalink

    Creates a single-valued pure stream

  121. def suspend[R, E, A](stream: ⇒ ZStream[R, E, A]): ZStream[R, E, A]

    Permalink

    Returns a lazily constructed stream.

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

    Permalink
    Definition Classes
    AnyRef
  123. def tick(interval: ⇒ zio.Duration)(implicit trace: Trace): ZStream[Any, Nothing, Unit]

    Permalink

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

  124. def toString(): String

    Permalink
    Definition Classes
    AnyRef → Any
  125. def unfold[S, A](s: ⇒ S)(f: (S) ⇒ Option[(A, S)])(implicit trace: Trace): ZStream[Any, Nothing, A]

    Permalink

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

  126. def unfoldChunk[S, A](s: ⇒ S)(f: (S) ⇒ Option[(Chunk[A], S)])(implicit trace: Trace): ZStream[Any, Nothing, A]

    Permalink

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

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

    Permalink

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

  128. def unfoldZIO[R, E, A, S](s: ⇒ S)(f: (S) ⇒ ZIO[R, E, Option[(A, S)]])(implicit trace: Trace): ZStream[R, E, A]

    Permalink

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

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

    Permalink

    A stream that contains a single Unit value.

  130. def unwrap[R, E, A](fa: ⇒ ZIO[R, E, ZStream[R, E, A]])(implicit trace: Trace): ZStream[R, E, A]

    Permalink

    Creates a stream produced from an effect

  131. def unwrapScoped[R]: UnwrapScopedPartiallyApplied[R]

    Permalink

    Creates a stream produced from a scoped ZIO

  132. final def wait(): Unit

    Permalink
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  133. final def wait(arg0: Long, arg1: Int): Unit

    Permalink
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  134. final def wait(arg0: Long): Unit

    Permalink
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  135. def when[R, E, O](b: ⇒ Boolean)(zStream: ⇒ ZStream[R, E, O])(implicit trace: Trace): ZStream[R, E, O]

    Permalink

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

  136. def whenCase[R, E, A, O](a: ⇒ A)(pf: PartialFunction[A, ZStream[R, E, O]])(implicit trace: Trace): ZStream[R, E, O]

    Permalink

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

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

    Permalink

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

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

    Permalink

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

Inherited from ZStreamPlatformSpecificConstructors

Inherited from AnyRef

Inherited from Any

Ungrouped