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

  2. 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 apply[R, E, A](pull: ZManaged[R, E, Pull[R, E, A]]): ZStream[R, E, A]

    Creates a stream from a scoped Pull.

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

    Creates a pure stream from a variable list of values

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

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

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

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

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

    The stream that always dies with ex.

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

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

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

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

  14. final def effectAsyncM[R, E, A](register: ((ZIO[R, Option[E], A]) ⇒ Unit) ⇒ ZIO[R, E, _], 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.

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

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

    The empty stream

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

    The stream that always fails with error

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

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

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

    Flattens nested streams.

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

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

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

    Creates a stream from a zio.Chunk of values

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

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

    Creates a stream from a java.io.InputStream

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

    Creates a stream from an iterable collection of values

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

    Creates a stream from an iterator

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

    Creates a stream from an iterator

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

    Creates a stream from a Pull.

  32. final def fromQueue[R, E, A](queue: ZQueue[_, _, R, E, _, A]): ZStream[R, E, A]

    Creates a stream from a zio.ZQueue of values

  33. final def fromQueueWithShutdown[R, E, A](queue: ZQueue[_, _, R, E, _, 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.

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

    The stream that always halts with cause.

  36. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  37. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  38. 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))), ...

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

    Creates a single-valued stream from a managed resource

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

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

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

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

  44. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  45. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  46. 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.

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

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

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

  49. final def repeatEffectWith[R, E, A](fa: ZIO[R, E, A], schedule: ZSchedule[R, Unit, _]): ZStream[R with Clock, E, A]

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

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

    Creates a single-valued pure stream

  51. final def synchronized[T0](arg0: ⇒ T0): T0
    Definition Classes
    AnyRef
  52. def toString(): String
    Definition Classes
    AnyRef → Any
  53. 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

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

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

    The stream of units

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

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

  58. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  59. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  60. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... ) @native()
  61. object GroupBy
  62. 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