ZManagedZStreamSyntax

Instance Constructors

new ZManagedZStreamSyntax(self: ZStream[R, E, A])

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
Any
final def ##(): Int

Definition Classes
Any
final def ==(arg0: Any): Boolean

Definition Classes
Any
final def asInstanceOf[T0]: T0

Definition Classes
Any
def getClass(): Class[_ <: AnyVal]

Definition Classes
AnyVal → Any
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
final def runFoldManaged[S](s: ⇒ S)(f: (S, A) ⇒ S)(implicit trace: ZTraceElement): ZManaged[R, E, S]

Executes a pure fold over the stream of values.
Executes a pure fold over the stream of values. Returns a managed value that represents the scope of the stream.
final def runFoldManagedZIO[R1 <: R, E1 >: E, S](s: ⇒ S)(f: (S, A) ⇒ ZIO[R1, E1, S])(implicit trace: ZTraceElement): ZManaged[R1, E1, S]

Executes an effectful fold over the stream of values.
Executes an effectful fold over the stream of values. Returns a managed value that represents the scope of the stream.
final def runFoldWhileManaged[S](s: ⇒ S)(cont: (S) ⇒ Boolean)(f: (S, A) ⇒ S)(implicit trace: ZTraceElement): ZManaged[R, E, S]

Executes a pure fold over the stream of values.
Executes a pure fold over the stream of values. Returns a managed value that represents the scope of the stream. Stops the fold early when the condition is not fulfilled.
final def runFoldWhileManagedZIO[R1 <: R, E1 >: E, S](s: ⇒ S)(cont: (S) ⇒ Boolean)(f: (S, A) ⇒ ZIO[R1, E1, S])(implicit trace: ZTraceElement): ZManaged[R1, E1, S]

Executes an effectful fold over the stream of values.
Executes an effectful fold over the stream of values. Returns a managed value that represents the scope of the stream. Stops the fold early when the condition is not fulfilled. Example:
```
Stream(1)
  .fold(0)(_ <= 4)((s, a) => UIO(s + a))  // Managed[Nothing, Int]
  .use(ZIO.succeed)                       // UIO[Int] == 5
```
cont
function which defines the early termination condition
final def runForeachChunkManaged[R1 <: R, E1 >: E](f: (Chunk[A]) ⇒ ZIO[R1, E1, Any])(implicit trace: ZTraceElement): ZManaged[R1, E1, Unit]

Like ZStream#runForeachChunk, but returns a scoped ZIO so the finalization order can be controlled.
final def runForeachScoped[R1 <: R, E1 >: E](f: (A) ⇒ ZIO[R1, E1, Any])(implicit trace: ZTraceElement): ZManaged[R1, E1, Unit]

Like ZStream#foreach, but returns a ZManaged so the finalization order can be controlled.
final def runForeachWhileManaged[R1 <: R, E1 >: E](f: (A) ⇒ ZIO[R1, E1, Boolean])(implicit trace: ZTraceElement): ZManaged[R1, E1, Unit]

Like ZStream#runForeachWhile, but returns a scoped ZIO so the finalization order can be controlled.
final def runIntoHubManaged[R1 <: R, E1 >: E](hub: ⇒ ZHub[R1, Nothing, Nothing, Any, Take[E1, A], Any])(implicit trace: ZTraceElement): ZManaged[R1, E1, Unit]

Like ZStream#runIntoHub, but provides the result as a ZManaged to allow for scope composition.
final def runIntoQueueElementsManaged[R1 <: R, E1 >: E](queue: ⇒ ZQueue[R1, Nothing, Nothing, Any, Exit[Option[E1], A], Any])(implicit trace: ZTraceElement): ZManaged[R1, E1, Unit]

Like ZStream#runIntoQueue, but provides the result as a ZManaged to allow for scope composition.
final def runIntoQueueManaged[R1 <: R, E1 >: E](queue: ⇒ ZQueue[R1, Nothing, Nothing, Any, Take[E1, A], Any])(implicit trace: ZTraceElement): ZManaged[R1, E1, Unit]

Like ZStream#runIntoQueue, but provides the result as a ZManaged to allow for scope composition.
def runManaged[R1 <: R, E1 >: E, B](sink: ⇒ ZSink[R1, E1, A, Any, B])(implicit trace: ZTraceElement): ZManaged[R1, E1, B]
def toString(): String

Definition Classes
Any

Deprecated Value Members

final def foldManaged[S](s: ⇒ S)(f: (S, A) ⇒ S)(implicit trace: ZTraceElement): ZManaged[R, E, S]

Executes a pure fold over the stream of values.
Executes a pure fold over the stream of values. Returns a managed value that represents the scope of the stream.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) user runFoldManaged
final def foldManagedM[R1 <: R, E1 >: E, S](s: ⇒ S)(f: (S, A) ⇒ ZIO[R1, E1, S])(implicit trace: ZTraceElement): ZManaged[R1, E1, S]

Executes an effectful fold over the stream of values.
Executes an effectful fold over the stream of values. Returns a managed value that represents the scope of the stream.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use runFoldScopedManaged
final def foldManagedZIO[R1 <: R, E1 >: E, S](s: ⇒ S)(f: (S, A) ⇒ ZIO[R1, E1, S])(implicit trace: ZTraceElement): ZManaged[R1, E1, S]

Executes an effectful fold over the stream of values.
Executes an effectful fold over the stream of values. Returns a managed value that represents the scope of the stream.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use runFoldManagedZIO
final def foldWhileManaged[S](s: ⇒ S)(cont: (S) ⇒ Boolean)(f: (S, A) ⇒ S)(implicit trace: ZTraceElement): ZManaged[R, E, S]

Executes a pure fold over the stream of values.
Executes a pure fold over the stream of values. Returns a managed value that represents the scope of the stream. Stops the fold early when the condition is not fulfilled.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use runFoldWhileManaged
final def foldWhileManagedM[R1 <: R, E1 >: E, S](s: ⇒ S)(cont: (S) ⇒ Boolean)(f: (S, A) ⇒ ZIO[R1, E1, S])(implicit trace: ZTraceElement): ZManaged[R1, E1, S]

Executes an effectful fold over the stream of values.
Executes an effectful fold over the stream of values. Returns a managed value that represents the scope of the stream. Stops the fold early when the condition is not fulfilled. Example:
```
Stream(1)
  .forever                                // an infinite Stream of 1's
  .fold(0)(_ <= 4)((s, a) => UIO(s + a))  // Managed[Nothing, Int]
  .use(ZIO.succeed)                       // UIO[Int] == 5
```
cont
function which defines the early termination condition

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use runFoldWhileManagedZIO
final def foldWhileManagedZIO[R1 <: R, E1 >: E, S](s: ⇒ S)(cont: (S) ⇒ Boolean)(f: (S, A) ⇒ ZIO[R1, E1, S])(implicit trace: ZTraceElement): ZManaged[R1, E1, S]

Executes an effectful fold over the stream of values.
Executes an effectful fold over the stream of values. Returns a managed value that represents the scope of the stream. Stops the fold early when the condition is not fulfilled. Example:
```
Stream(1)
  .forever                                // an infinite Stream of 1's
  .fold(0)(_ <= 4)((s, a) => UIO(s + a))  // Managed[Nothing, Int]
  .use(ZIO.succeed)                       // UIO[Int] == 5
```
cont
function which defines the early termination condition

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use runFoldWhileManagedZIO
final def foreachChunkManaged[R1 <: R, E1 >: E](f: (Chunk[A]) ⇒ ZIO[R1, E1, Any])(implicit trace: ZTraceElement): ZManaged[R1, E1, Unit]

Like ZStream#runForeachChunk, but returns a ZManaged so the finalization order can be controlled.
Like ZStream#runForeachChunk, but returns a ZManaged so the finalization order can be controlled.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use runForeachChunkManaged
final def foreachManaged[R1 <: R, E1 >: E](f: (A) ⇒ ZIO[R1, E1, Any])(implicit trace: ZTraceElement): ZManaged[R1, E1, Unit]

Like ZStream#foreach, but returns a ZManaged so the finalization order can be controlled.
Like ZStream#foreach, but returns a ZManaged so the finalization order can be controlled.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) run runForeachManaged
final def foreachWhileManaged[R1 <: R, E1 >: E](f: (A) ⇒ ZIO[R1, E1, Boolean])(implicit trace: ZTraceElement): ZManaged[R1, E1, Unit]

Like ZStream#runForeachWhile, but returns a ZManaged so the finalization order can be controlled.
Like ZStream#runForeachWhile, but returns a ZManaged so the finalization order can be controlled.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use runForeachWhileManaged
final def intoHubManaged[R1 <: R, E1 >: E](hub: ⇒ ZHub[R1, Nothing, Nothing, Any, Take[E1, A], Any])(implicit trace: ZTraceElement): ZManaged[R1, E1, Unit]

Like ZStream#intoHub, but provides the result as a ZManaged to allow for scope composition.
Like ZStream#intoHub, but provides the result as a ZManaged to allow for scope composition.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use runIntoHubManaged
final def intoManaged[R1 <: R, E1 >: E](queue: ⇒ ZQueue[R1, Nothing, Nothing, Any, Take[E1, A], Any])(implicit trace: ZTraceElement): ZManaged[R1, E1, Unit]

Like ZStream#into, but provides the result as a ZManaged to allow for scope composition.
Like ZStream#into, but provides the result as a ZManaged to allow for scope composition.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use runIntoQueueManaged
final def intoQueueManaged[R1 <: R, E1 >: E](queue: ⇒ ZQueue[R1, Nothing, Nothing, Any, Take[E1, A], Any])(implicit trace: ZTraceElement): ZManaged[R1, E1, Unit]

Like ZStream#ntoQueue, but provides the result as a ZManaged to allow for scope composition.
Like ZStream#ntoQueue, but provides the result as a ZManaged to allow for scope composition.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use runIntoQueueManaged
final def runFoldManagedM[R1 <: R, E1 >: E, S](s: ⇒ S)(f: (S, A) ⇒ ZIO[R1, E1, S])(implicit trace: ZTraceElement): ZManaged[R1, E1, S]

Executes an effectful fold over the stream of values.
Executes an effectful fold over the stream of values. Returns a managed value that represents the scope of the stream.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use runFoldManagedZIO
final def runFoldWhileManagedM[R1 <: R, E1 >: E, S](s: ⇒ S)(cont: (S) ⇒ Boolean)(f: (S, A) ⇒ ZIO[R1, E1, S])(implicit trace: ZTraceElement): ZManaged[R1, E1, S]

Executes an effectful fold over the stream of values.
Executes an effectful fold over the stream of values. Returns a managed value that represents the scope of the stream. Stops the fold early when the condition is not fulfilled. Example:
```
Stream(1)
  .forever                                // an infinite Stream of 1's
  .fold(0)(_ <= 4)((s, a) => UIO(s + a))  // Managed[Nothing, Int]
  .use(ZIO.succeed)                       // UIO[Int] == 5
```
cont
function which defines the early termination condition

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use runFoldWhileManagedZIO
final def runIntoElementsManaged[R1 <: R, E1 >: E](queue: ⇒ ZQueue[R1, Nothing, Nothing, Any, Exit[Option[E1], A], Any])(implicit trace: ZTraceElement): ZManaged[R1, E1, Unit]

Like ZStream#runInto, but provides the result as a ZManaged to allow for scope composition.
Like ZStream#runInto, but provides the result as a ZManaged to allow for scope composition.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use runIntoQueueElementsManaged
final def runIntoManaged[R1 <: R, E1 >: E](queue: ⇒ ZQueue[R1, Nothing, Nothing, Any, Take[E1, A], Any])(implicit trace: ZTraceElement): ZManaged[R1, E1, Unit]

Like ZStream#runInto, but provides the result as a ZManaged to allow for scope composition.
Like ZStream#runInto, but provides the result as a ZManaged to allow for scope composition.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use runIntoQueueManaged

Related Doc: package managed

implicit final class ZManagedZStreamSyntax[R, E, A] extends AnyVal

Instance Constructors

new ZManagedZStreamSyntax(self: ZStream[R, E, A])

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def getClass(): Class[_ <: AnyVal]

final def isInstanceOf[T0]: Boolean

final def runFoldManaged[S](s: ⇒ S)(f: (S, A) ⇒ S)(implicit trace: ZTraceElement): ZManaged[R, E, S]

final def runFoldManagedZIO[R1 <: R, E1 >: E, S](s: ⇒ S)(f: (S, A) ⇒ ZIO[R1, E1, S])(implicit trace: ZTraceElement): ZManaged[R1, E1, S]

final def runFoldWhileManaged[S](s: ⇒ S)(cont: (S) ⇒ Boolean)(f: (S, A) ⇒ S)(implicit trace: ZTraceElement): ZManaged[R, E, S]

final def runFoldWhileManagedZIO[R1 <: R, E1 >: E, S](s: ⇒ S)(cont: (S) ⇒ Boolean)(f: (S, A) ⇒ ZIO[R1, E1, S])(implicit trace: ZTraceElement): ZManaged[R1, E1, S]

final def runForeachChunkManaged[R1 <: R, E1 >: E](f: (Chunk[A]) ⇒ ZIO[R1, E1, Any])(implicit trace: ZTraceElement): ZManaged[R1, E1, Unit]

final def runForeachScoped[R1 <: R, E1 >: E](f: (A) ⇒ ZIO[R1, E1, Any])(implicit trace: ZTraceElement): ZManaged[R1, E1, Unit]

final def runForeachWhileManaged[R1 <: R, E1 >: E](f: (A) ⇒ ZIO[R1, E1, Boolean])(implicit trace: ZTraceElement): ZManaged[R1, E1, Unit]

final def runIntoHubManaged[R1 <: R, E1 >: E](hub: ⇒ ZHub[R1, Nothing, Nothing, Any, Take[E1, A], Any])(implicit trace: ZTraceElement): ZManaged[R1, E1, Unit]

final def runIntoQueueElementsManaged[R1 <: R, E1 >: E](queue: ⇒ ZQueue[R1, Nothing, Nothing, Any, Exit[Option[E1], A], Any])(implicit trace: ZTraceElement): ZManaged[R1, E1, Unit]

final def runIntoQueueManaged[R1 <: R, E1 >: E](queue: ⇒ ZQueue[R1, Nothing, Nothing, Any, Take[E1, A], Any])(implicit trace: ZTraceElement): ZManaged[R1, E1, Unit]

def runManaged[R1 <: R, E1 >: E, B](sink: ⇒ ZSink[R1, E1, A, Any, B])(implicit trace: ZTraceElement): ZManaged[R1, E1, B]

def toString(): String

Deprecated Value Members

final def foldManaged[S](s: ⇒ S)(f: (S, A) ⇒ S)(implicit trace: ZTraceElement): ZManaged[R, E, S]

final def foldManagedM[R1 <: R, E1 >: E, S](s: ⇒ S)(f: (S, A) ⇒ ZIO[R1, E1, S])(implicit trace: ZTraceElement): ZManaged[R1, E1, S]

final def foldManagedZIO[R1 <: R, E1 >: E, S](s: ⇒ S)(f: (S, A) ⇒ ZIO[R1, E1, S])(implicit trace: ZTraceElement): ZManaged[R1, E1, S]

final def foldWhileManaged[S](s: ⇒ S)(cont: (S) ⇒ Boolean)(f: (S, A) ⇒ S)(implicit trace: ZTraceElement): ZManaged[R, E, S]

final def foldWhileManagedM[R1 <: R, E1 >: E, S](s: ⇒ S)(cont: (S) ⇒ Boolean)(f: (S, A) ⇒ ZIO[R1, E1, S])(implicit trace: ZTraceElement): ZManaged[R1, E1, S]

final def foldWhileManagedZIO[R1 <: R, E1 >: E, S](s: ⇒ S)(cont: (S) ⇒ Boolean)(f: (S, A) ⇒ ZIO[R1, E1, S])(implicit trace: ZTraceElement): ZManaged[R1, E1, S]

final def foreachChunkManaged[R1 <: R, E1 >: E](f: (Chunk[A]) ⇒ ZIO[R1, E1, Any])(implicit trace: ZTraceElement): ZManaged[R1, E1, Unit]

final def foreachManaged[R1 <: R, E1 >: E](f: (A) ⇒ ZIO[R1, E1, Any])(implicit trace: ZTraceElement): ZManaged[R1, E1, Unit]

final def foreachWhileManaged[R1 <: R, E1 >: E](f: (A) ⇒ ZIO[R1, E1, Boolean])(implicit trace: ZTraceElement): ZManaged[R1, E1, Unit]

final def intoHubManaged[R1 <: R, E1 >: E](hub: ⇒ ZHub[R1, Nothing, Nothing, Any, Take[E1, A], Any])(implicit trace: ZTraceElement): ZManaged[R1, E1, Unit]

final def intoManaged[R1 <: R, E1 >: E](queue: ⇒ ZQueue[R1, Nothing, Nothing, Any, Take[E1, A], Any])(implicit trace: ZTraceElement): ZManaged[R1, E1, Unit]

final def intoQueueManaged[R1 <: R, E1 >: E](queue: ⇒ ZQueue[R1, Nothing, Nothing, Any, Take[E1, A], Any])(implicit trace: ZTraceElement): ZManaged[R1, E1, Unit]

final def runFoldManagedM[R1 <: R, E1 >: E, S](s: ⇒ S)(f: (S, A) ⇒ ZIO[R1, E1, S])(implicit trace: ZTraceElement): ZManaged[R1, E1, S]

final def runFoldWhileManagedM[R1 <: R, E1 >: E, S](s: ⇒ S)(cont: (S) ⇒ Boolean)(f: (S, A) ⇒ ZIO[R1, E1, S])(implicit trace: ZTraceElement): ZManaged[R1, E1, S]

final def runIntoElementsManaged[R1 <: R, E1 >: E](queue: ⇒ ZQueue[R1, Nothing, Nothing, Any, Exit[Option[E1], A], Any])(implicit trace: ZTraceElement): ZManaged[R1, E1, Unit]

final def runIntoManaged[R1 <: R, E1 >: E](queue: ⇒ ZQueue[R1, Nothing, Nothing, Any, Take[E1, A], Any])(implicit trace: ZTraceElement): ZManaged[R1, E1, Unit]

Inherited from AnyVal

Inherited from Any

Ungrouped