Packages

object ZSink extends ZSinkPlatformSpecificConstructors

Linear Supertypes
ZSinkPlatformSpecificConstructors, AnyRef, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. ZSink
  2. ZSinkPlatformSpecificConstructors
  3. AnyRef
  4. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. Protected

Type Members

  1. final class EnvironmentWithPartiallyApplied[R] extends AnyVal
  2. final class EnvironmentWithSinkPartiallyApplied[R] extends AnyVal
  3. final class EnvironmentWithZIOPartiallyApplied[R] extends AnyVal
  4. final class ServiceAtPartiallyApplied[Service] extends AnyVal
  5. final class ServiceWithPartiallyApplied[Service] extends AnyVal
  6. final class ServiceWithSinkPartiallyApplied[Service] extends AnyVal
  7. final class ServiceWithZIOPartiallyApplied[Service] extends AnyVal
  8. final class UnwrapScopedPartiallyApplied[R] extends AnyVal

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 asInstanceOf[T0]: T0
    Definition Classes
    Any
  5. def clone(): AnyRef
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.CloneNotSupportedException]) @native()
  6. def collectAll[In](implicit trace: Trace): ZSink[Any, Nothing, In, Nothing, Chunk[In]]
  7. def collectAllN[In](n: => Int)(implicit trace: Trace): ZSink[Any, Nothing, In, In, Chunk[In]]

    A sink that collects first n elements into a chunk.

    A sink that collects first n elements into a chunk. Note that the chunk is preallocated and must fit in memory.

  8. def collectAllToMap[In, K](key: (In) => K)(f: (In, In) => In)(implicit trace: Trace): ZSink[Any, Nothing, In, Nothing, Map[K, In]]

    A sink that collects all of its inputs into a map.

    A sink that collects all of its inputs into a map. The keys are extracted from inputs using the keying function key; if multiple inputs use the same key, they are merged using the f function.

  9. def collectAllToMapN[Err, In, K](n: => Long)(key: (In) => K)(f: (In, In) => In)(implicit trace: Trace): ZSink[Any, Err, In, In, Map[K, In]]

    A sink that collects first n keys into a map.

    A sink that collects first n keys into a map. The keys are calculated from inputs using the keying function key; if multiple inputs use the the same key, they are merged using the f function.

  10. def collectAllToSet[In](implicit trace: Trace): ZSink[Any, Nothing, In, Nothing, Set[In]]

    A sink that collects all of its inputs into a set.

  11. def collectAllToSetN[In](n: => Long)(implicit trace: Trace): ZSink[Any, Nothing, In, In, Set[In]]

    A sink that collects first n distinct inputs into a set.

  12. def collectAllUntil[In](p: (In) => Boolean)(implicit trace: Trace): ZSink[Any, Nothing, In, In, Chunk[In]]

    Accumulates incoming elements into a chunk until predicate p is satisfied.

  13. def collectAllUntilZIO[Env, Err, In](p: (In) => ZIO[Env, Err, Boolean])(implicit trace: Trace): ZSink[Env, Err, In, In, Chunk[In]]

    Accumulates incoming elements into a chunk until effectful predicate p is satisfied.

  14. def collectAllWhile[In](p: (In) => Boolean)(implicit trace: Trace): ZSink[Any, Nothing, In, In, Chunk[In]]

    Accumulates incoming elements into a chunk as long as they verify predicate p.

  15. def collectAllWhileZIO[Env, Err, In](p: (In) => ZIO[Env, Err, Boolean])(implicit trace: Trace): ZSink[Env, Err, In, In, Chunk[In]]

    Accumulates incoming elements into a chunk as long as they verify effectful predicate p.

  16. def count(implicit trace: Trace): ZSink[Any, Nothing, Any, Nothing, Long]

    A sink that counts the number of elements fed to it.

  17. def die(e: => Throwable)(implicit trace: Trace): ZSink[Any, Nothing, Any, Nothing, Nothing]

    Creates a sink halting with the specified Throwable.

  18. def dieMessage(m: => String)(implicit trace: Trace): ZSink[Any, Nothing, Any, Nothing, Nothing]

    Creates a sink halting with the specified message, wrapped in a RuntimeException.

  19. def digest(digest: => MessageDigest): ZSink[Any, Nothing, Byte, Nothing, Chunk[Byte]]

    Creates a sink which digests incoming bytes using Java's MessageDigest class, returning the digest value.

    Creates a sink which digests incoming bytes using Java's MessageDigest class, returning the digest value.

    Definition Classes
    ZSinkPlatformSpecificConstructors
  20. def drain(implicit trace: Trace): ZSink[Any, Nothing, Any, Nothing, Unit]

    A sink that ignores its inputs.

  21. def dropUntil[In](p: (In) => Boolean)(implicit trace: Trace): ZSink[Any, Nothing, In, In, Any]

    Drops incoming elements until the predicate p is satisfied.

  22. def dropUntilZIO[R, InErr, In](p: (In) => ZIO[R, InErr, Boolean])(implicit trace: Trace): ZSink[R, InErr, In, In, Any]

    Drops incoming elements until the effectful predicate p is satisfied.

  23. def dropWhile[In](p: (In) => Boolean)(implicit trace: Trace): ZSink[Any, Nothing, In, In, Any]

    Drops incoming elements as long as the predicate p is satisfied.

  24. def dropWhileZIO[R, InErr, In](p: (In) => ZIO[R, InErr, Boolean])(implicit trace: Trace): ZSink[R, InErr, In, In, Any]

    Drops incoming elements as long as the effectful predicate p is satisfied.

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

    Accesses the whole environment of the sink.

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

    Accesses the environment of the sink.

  27. def environmentWithSink[R]: EnvironmentWithSinkPartiallyApplied[R]

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

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

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

  29. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  30. def equals(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef → Any
  31. def fail[E](e: => E)(implicit trace: Trace): ZSink[Any, E, Any, Nothing, Nothing]

    A sink that always fails with the specified error.

  32. def failCause[E](e: => Cause[E])(implicit trace: Trace): ZSink[Any, E, Any, Nothing, Nothing]

    Creates a sink halting with a specified cause.

  33. def finalize(): Unit
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.Throwable])
  34. def fold[In, S](z: => S)(contFn: (S) => Boolean)(f: (S, In) => S)(implicit trace: Trace): ZSink[Any, Nothing, In, In, S]

    A sink that folds its inputs with the provided function, termination predicate and initial state.

  35. def foldChunks[In, S](z: => S)(contFn: (S) => Boolean)(f: (S, Chunk[In]) => S)(implicit trace: Trace): ZSink[Any, Nothing, In, Nothing, S]

    A sink that folds its input chunks with the provided function, termination predicate and initial state.

    A sink that folds its input chunks with the provided function, termination predicate and initial state. contFn condition is checked only for the initial value and at the end of processing of each chunk. f and contFn must preserve chunking-invariance.

  36. def foldChunksZIO[Env, Err, In, S](z: => S)(contFn: (S) => Boolean)(f: (S, Chunk[In]) => ZIO[Env, Err, S])(implicit trace: Trace): ZSink[Env, Err, In, In, S]

    A sink that effectfully folds its input chunks with the provided function, termination predicate and initial state.

    A sink that effectfully folds its input chunks with the provided function, termination predicate and initial state. contFn condition is checked only for the initial value and at the end of processing of each chunk. f and contFn must preserve chunking-invariance.

  37. def foldLeft[In, S](z: => S)(f: (S, In) => S)(implicit trace: Trace): ZSink[Any, Nothing, In, Nothing, S]

    A sink that folds its inputs with the provided function and initial state.

  38. def foldLeftChunks[In, S](z: => S)(f: (S, Chunk[In]) => S)(implicit trace: Trace): ZSink[Any, Nothing, In, Nothing, S]

    A sink that folds its input chunks with the provided function and initial state.

    A sink that folds its input chunks with the provided function and initial state. f must preserve chunking-invariance.

  39. def foldLeftChunksZIO[R, Err, In, S](z: => S)(f: (S, Chunk[In]) => ZIO[R, Err, S])(implicit trace: Trace): ZSink[R, Err, In, Nothing, S]

    A sink that effectfully folds its input chunks with the provided function and initial state.

    A sink that effectfully folds its input chunks with the provided function and initial state. f must preserve chunking-invariance.

  40. def foldLeftZIO[R, Err, In, S](z: => S)(f: (S, In) => ZIO[R, Err, S])(implicit trace: Trace): ZSink[R, Err, In, In, S]

    A sink that effectfully folds its inputs with the provided function and initial state.

  41. def foldUntil[In, S](z: => S, max: => Long)(f: (S, In) => S)(implicit trace: Trace): ZSink[Any, Nothing, In, In, S]

    Creates a sink that folds elements of type In into a structure of type S until max elements have been folded.

    Creates a sink that folds elements of type In into a structure of type S until max elements have been folded.

    Like foldWeighted, but with a constant cost function of 1.

  42. def foldUntilZIO[Env, Err, In, S](z: => S, max: => Long)(f: (S, In) => ZIO[Env, Err, S])(implicit trace: Trace): ZSink[Env, Err, In, In, S]

    Creates a sink that effectfully folds elements of type In into a structure of type S until max elements have been folded.

    Creates a sink that effectfully folds elements of type In into a structure of type S until max elements have been folded.

    Like foldWeightedZIO, but with a constant cost function of 1.

  43. def foldWeighted[In, S](z: => S)(costFn: (S, In) => Long, max: => Long)(f: (S, In) => S)(implicit trace: Trace): ZSink[Any, Nothing, In, In, S]

    Creates a sink that folds elements of type In into a structure of type S, until max worth of elements (determined by the costFn) have been folded.

    Creates a sink that folds elements of type In into a structure of type S, until max worth of elements (determined by the costFn) have been folded.

    Note

    Elements that have an individual cost larger than max will force the sink to cross the max cost. See foldWeightedDecompose for a variant that can handle these cases.

  44. def foldWeightedDecompose[In, S](z: => S)(costFn: (S, In) => Long, max: => Long, decompose: (In) => Chunk[In])(f: (S, In) => S)(implicit trace: Trace): ZSink[Any, Nothing, In, In, S]

    Creates a sink that folds elements of type In into a structure of type S, until max worth of elements (determined by the costFn) have been folded.

    Creates a sink that folds elements of type In into a structure of type S, until max worth of elements (determined by the costFn) have been folded.

    The decompose function will be used for decomposing elements that cause an S aggregate to cross max into smaller elements. For example:

    Stream(1, 5, 1)
      .transduce(
        ZSink
          .foldWeightedDecompose(List[Int]())((i: Int) => i.toLong, 4,
            (i: Int) => Chunk(i - 1, 1)) { (acc, el) =>
            el :: acc
          }
          .map(_.reverse)
      )
      .runCollect

    The stream would emit the elements List(1), List(4), List(1, 1).

    Be vigilant with this function, it has to generate "simpler" values or the fold may never end. A value is considered indivisible if decompose yields the empty chunk or a single-valued chunk. In these cases, there is no other choice than to yield a value that will cross the threshold.

    The foldWeightedDecomposeZIO allows the decompose function to return a ZIO value, and consequently it allows the sink to fail.

  45. def foldWeightedDecomposeZIO[Env, Err, In, S](z: => S)(costFn: (S, In) => ZIO[Env, Err, Long], max: => Long, decompose: (In) => ZIO[Env, Err, Chunk[In]])(f: (S, In) => ZIO[Env, Err, S])(implicit trace: Trace): ZSink[Env, Err, In, In, S]

    Creates a sink that effectfully folds elements of type In into a structure of type S, until max worth of elements (determined by the costFn) have been folded.

    Creates a sink that effectfully folds elements of type In into a structure of type S, until max worth of elements (determined by the costFn) have been folded.

    The decompose function will be used for decomposing elements that cause an S aggregate to cross max into smaller elements. Be vigilant with this function, it has to generate "simpler" values or the fold may never end. A value is considered indivisible if decompose yields the empty chunk or a single-valued chunk. In these cases, there is no other choice than to yield a value that will cross the threshold.

    See foldWeightedDecompose for an example.

  46. def foldWeightedZIO[Env, Err, In, S](z: => S)(costFn: (S, In) => ZIO[Env, Err, Long], max: Long)(f: (S, In) => ZIO[Env, Err, S])(implicit trace: Trace): ZSink[Env, Err, In, In, S]

    Creates a sink that effectfully folds elements of type In into a structure of type S, until max worth of elements (determined by the costFn) have been folded.

    Creates a sink that effectfully folds elements of type In into a structure of type S, until max worth of elements (determined by the costFn) have been folded.

    Note

    Elements that have an individual cost larger than max will force the sink to cross the max cost. See foldWeightedDecomposeZIO for a variant that can handle these cases.

  47. def foldZIO[Env, Err, In, S](z: => S)(contFn: (S) => Boolean)(f: (S, In) => ZIO[Env, Err, S])(implicit trace: Trace): ZSink[Env, Err, In, In, S]

    A sink that effectfully folds its inputs with the provided function, termination predicate and initial state.

  48. def foreach[R, Err, In](f: (In) => ZIO[R, Err, Any])(implicit trace: Trace): ZSink[R, Err, In, Nothing, Unit]

    A sink that executes the provided effectful function for every element fed to it.

  49. def foreachChunk[R, Err, In](f: (Chunk[In]) => ZIO[R, Err, Any])(implicit trace: Trace): ZSink[R, Err, In, Nothing, Unit]

    A sink that executes the provided effectful function for every chunk fed to it.

  50. def foreachChunkWhile[R, Err, In](f: (Chunk[In]) => ZIO[R, Err, Boolean])(implicit trace: Trace): ZSink[R, Err, In, In, Unit]

    A sink that executes the provided effectful function for every chunk fed to it until f evaluates to false.

  51. def foreachWhile[R, Err, In](f: (In) => ZIO[R, Err, Boolean])(implicit trace: Trace): ZSink[R, Err, In, In, Unit]

    A sink that executes the provided effectful function for every element fed to it until f evaluates to false.

  52. def fromChannel[R, E, In, L, Z](channel: ZChannel[R, ZNothing, Chunk[In], Any, E, Chunk[L], Z]): ZSink[R, E, In, L, Z]

    Creates a sink from a zio.stream.ZChannel

  53. final def fromFile(file: => File, position: => Long = 0L, options: => Set[OpenOption] = Set(WRITE, TRUNCATE_EXISTING, CREATE))(implicit trace: Trace): ZSink[Any, Throwable, Byte, Byte, Long]

    Uses the provided File to create a ZSink that consumes byte chunks and writes them to the File.

    Uses the provided File to create a ZSink that consumes byte chunks and writes them to the File. The sink will yield count of bytes written.

    Definition Classes
    ZSinkPlatformSpecificConstructors
  54. final def fromFileName(name: => String, position: => Long = 0L, options: => Set[OpenOption] = Set(WRITE, TRUNCATE_EXISTING, CREATE))(implicit trace: Trace): ZSink[Any, Throwable, Byte, Byte, Long]

    Uses the provided Path represented as a string to create a ZSink that consumes byte chunks and writes them to the File.

    Uses the provided Path represented as a string to create a ZSink that consumes byte chunks and writes them to the File. The sink will yield count of bytes written.

    Definition Classes
    ZSinkPlatformSpecificConstructors
  55. final def fromFileURI(uri: => URI, position: => Long = 0L, options: => Set[OpenOption] = Set(WRITE, TRUNCATE_EXISTING, CREATE))(implicit trace: Trace): ZSink[Any, Throwable, Byte, Byte, Long]

    Uses the provided URI to create a ZSink that consumes byte chunks and writes them to the File.

    Uses the provided URI to create a ZSink that consumes byte chunks and writes them to the File. The sink will yield count of bytes written.

    Definition Classes
    ZSinkPlatformSpecificConstructors
  56. def fromHub[I](hub: => Hub[I])(implicit trace: Trace): ZSink[Any, Nothing, I, Nothing, Unit]

    Create a sink which publishes each element to the specified hub.

  57. def fromHubWithShutdown[I](hub: => Hub[I])(implicit trace: Trace): ZSink[Any, Nothing, I, Nothing, Unit]

    Create a sink which publishes each element to the specified hub.

    Create a sink which publishes each element to the specified hub. The hub will be shutdown once the stream is closed.

  58. final def fromOutputStream(os: => OutputStream)(implicit trace: Trace): ZSink[Any, IOException, Byte, Byte, Long]

    Uses the provided OutputStream to create a ZSink that consumes byte chunks and writes them to the OutputStream.

    Uses the provided OutputStream to create a ZSink that consumes byte chunks and writes them to the OutputStream. The sink will yield the count of bytes written.

    The caller of this function is responsible for closing the OutputStream.

    Definition Classes
    ZSinkPlatformSpecificConstructors
  59. final def fromOutputStreamScoped(os: => ZIO[Scope, IOException, OutputStream])(implicit trace: Trace): ZSink[Any, IOException, Byte, Byte, Long]

    Uses the provided OutputStream resource to create a ZSink that consumes byte chunks and writes them to the OutputStream.

    Uses the provided OutputStream resource to create a ZSink that consumes byte chunks and writes them to the OutputStream. The sink will yield the count of bytes written.

    The OutputStream will be automatically closed after the stream is finished or an error occurred.

    Definition Classes
    ZSinkPlatformSpecificConstructors
  60. final def fromPath(path: => Path, position: => Long = 0L, options: => Set[OpenOption] = Set(WRITE, TRUNCATE_EXISTING, CREATE))(implicit trace: Trace): ZSink[Any, Throwable, Byte, Byte, Long]

    Uses the provided Path to create a ZSink that consumes byte chunks and writes them to the File.

    Uses the provided Path to create a ZSink that consumes byte chunks and writes them to the File. The sink will yield count of bytes written.

    Definition Classes
    ZSinkPlatformSpecificConstructors
  61. def fromPush[R, E, I, L, Z](push: ZIO[Scope with R, Nothing, (Option[Chunk[I]]) => ZIO[R, (Either[E, Z], Chunk[L]), Unit]])(implicit trace: Trace): ZSink[R, E, I, L, Z]

    Creates a sink from a chunk processing function.

  62. def fromQueue[I](queue: => Enqueue[I])(implicit trace: Trace): ZSink[Any, Nothing, I, Nothing, Unit]

    Create a sink which enqueues each element into the specified queue.

  63. def fromQueueWithShutdown[I](queue: => Enqueue[I])(implicit trace: Trace): ZSink[Any, Nothing, I, Nothing, Unit]

    Create a sink which enqueues each element into the specified queue.

    Create a sink which enqueues each element into the specified queue. The queue will be shutdown once the stream is closed.

  64. def fromZIO[R, E, Z](b: => ZIO[R, E, Z])(implicit trace: Trace): ZSink[R, E, Any, Nothing, Z]

    Creates a single-value sink produced from an effect

  65. final def getClass(): Class[_ <: AnyRef]
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  66. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  67. def head[In](implicit trace: Trace): ZSink[Any, Nothing, In, In, Option[In]]

    Creates a sink containing the first value.

  68. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  69. def last[In](implicit trace: Trace): ZSink[Any, Nothing, In, In, Option[In]]

    Creates a sink containing the last value.

  70. def leftover[L](c: => Chunk[L])(implicit trace: Trace): ZSink[Any, Nothing, Any, L, Unit]

    Creates a sink that does not consume any input but provides the given chunk as its leftovers

  71. def log(message: => String)(implicit trace: Trace): ZSink[Any, Nothing, Any, Nothing, Unit]

    Logs the specified message at the current log level.

  72. def logAnnotate[R, E, In, L, Z](annotations: => Set[LogAnnotation])(sink: ZSink[R, E, In, L, Z])(implicit trace: Trace): ZSink[R, E, In, L, Z]

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

  73. def logAnnotate[R, E, In, L, Z](annotation: => LogAnnotation, annotations: LogAnnotation*)(sink: ZSink[R, E, In, L, Z])(implicit trace: Trace): ZSink[R, E, In, L, Z]

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

  74. def logAnnotate[R, E, In, L, Z](key: => String, value: => String)(sink: ZSink[R, E, In, L, Z])(implicit trace: Trace): ZSink[R, E, In, L, Z]

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

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

    Retrieves the log annotations associated with the current scope.

  76. def logDebug(message: => String)(implicit trace: Trace): ZSink[Any, Nothing, Any, Nothing, Unit]

    Logs the specified message at the debug log level.

  77. def logError(message: => String)(implicit trace: Trace): ZSink[Any, Nothing, Any, Nothing, Unit]

    Logs the specified message at the error log level.

  78. def logErrorCause(cause: => Cause[Any])(implicit trace: Trace): ZSink[Any, Nothing, Any, Nothing, Unit]

    Logs the specified cause as an error.

  79. def logFatal(message: => String)(implicit trace: Trace): ZSink[Any, Nothing, Any, Nothing, Unit]

    Logs the specified message at the fatal log level.

  80. def logInfo(message: => String)(implicit trace: Trace): ZSink[Any, Nothing, Any, Nothing, Unit]

    Logs the specified message at the informational log level.

  81. def logLevel[R, E, In, L, Z](level: LogLevel)(sink: ZSink[R, E, In, L, Z])(implicit trace: Trace): ZSink[R, E, In, L, Z]

    Sets the log level for streams composed after this.

  82. def logSpan[R, E, In, L, Z](label: => String)(sink: ZSink[R, E, In, L, Z])(implicit trace: Trace): ZSink[R, E, In, L, Z]

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

  83. def logTrace(message: => String)(implicit trace: Trace): ZSink[Any, Nothing, Any, Nothing, Unit]

    Logs the specified message at the trace log level.

  84. def logWarning(message: => String)(implicit trace: Trace): ZSink[Any, Nothing, Any, Nothing, Unit]

    Logs the specified message at the warning log level.

  85. def mkString(implicit trace: Trace): ZSink[Any, Nothing, Any, Nothing, String]
  86. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  87. def never(implicit trace: Trace): ZSink[Any, Nothing, Any, Nothing, Nothing]
  88. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  89. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  90. def service[Z](implicit arg0: Tag[Z], trace: Trace): ZSink[Z, Nothing, Any, Nothing, Z]

    Accesses the specified service in the environment of the effect.

  91. def serviceAt[Service]: ZStream.ServiceAtPartiallyApplied[Service]

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

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

    Accesses the specified service in the environment of the sink.

  93. def serviceWithSink[Service]: ServiceWithSinkPartiallyApplied[Service]

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

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

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

  95. def succeed[Z](z: => Z)(implicit trace: Trace): ZSink[Any, Nothing, Any, Nothing, Z]

    A sink that immediately ends with the specified value.

  96. def sum[A](implicit A: Numeric[A], trace: Trace): ZSink[Any, Nothing, A, Nothing, A]

    A sink that sums incoming numeric values.

  97. def suspend[Env, E, In, Leftover, Done](sink: => ZSink[Env, E, In, Leftover, Done])(implicit trace: Trace): ZSink[Env, E, In, Leftover, Done]

    Returns a lazily constructed sink that may require effects for its creation.

  98. final def synchronized[T0](arg0: => T0): T0
    Definition Classes
    AnyRef
  99. def take[In](n: Int)(implicit trace: Trace): ZSink[Any, Nothing, In, In, Chunk[In]]

    A sink that takes the specified number of values.

  100. def timed(implicit trace: Trace): ZSink[Any, Nothing, Any, Nothing, zio.Duration]
  101. def toString(): String
    Definition Classes
    AnyRef → Any
  102. def unwrap[R, E, In, L, Z](zio: => ZIO[R, E, ZSink[R, E, In, L, Z]])(implicit trace: Trace): ZSink[R, E, In, L, Z]

    Creates a sink produced from an effect.

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

    Creates a sink produced from a scoped effect.

  104. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  105. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  106. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException]) @native()

Inherited from ZSinkPlatformSpecificConstructors

Inherited from AnyRef

Inherited from Any

Ungrouped