abstract class ZSink[-R, +E, -I, +Z] extends AnyRef

Self Type
ZSink[R, E, I, Z]
Linear Supertypes
AnyRef, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. ZSink
  2. AnyRef
  3. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. Protected

Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##(): Int
    Definition Classes
    AnyRef → Any
  3. final def &>[R1 <: R, E1 >: E, I1 <: I, Z1](that: ZSink[R1, E1, I1, Z1]): ZSink[R1, E1, I1, Z1]

    Operator alias for zipParRight.

  4. final def *>[R1 <: R, E1 >: E, I1 <: I, Z1, Z2](that: ZSink[R1, E1, I1, Z1]): ZSink[R1, E1, I1, Z1]

    Operator alias for zipRight.

  5. final def <&[R1 <: R, E1 >: E, I1 <: I](that: ZSink[R1, E1, I1, Any]): ZSink[R1, E1, I1, Z]

    Operator alias for zipParLeft.

  6. final def <&>[R1 <: R, E1 >: E, I1 <: I, Z1](that: ZSink[R1, E1, I1, Z1]): ZSink[R1, E1, I1, (Z, Z1)]

    Operator alias for zipPar.

  7. final def <*[R1 <: R, E1 >: E, I1 <: I, Z1, Z2](that: ZSink[R1, E1, I1, Z1]): ZSink[R1, E1, I1, Z]

    Operator alias for zipLeft.

  8. final def <*>[R1 <: R, E1 >: E, I1 <: I, Z1, Z2](that: ZSink[R1, E1, I1, Z1]): ZSink[R1, E1, I1, (Z, Z1)]

    Operator alias for zip.

  9. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  10. def as[Z2](z: => Z2): ZSink[R, E, I, Z2]

    Replaces this sink's result with the provided value.

  11. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  12. def clone(): AnyRef
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.CloneNotSupportedException]) @native()
  13. def collectAllWhileWith[S](z: S)(p: (Z) => Boolean)(f: (S, Z) => S): ZSink[R, E, I, S]

    Repeatedly runs the sink for as long as its results satisfy the predicate p.

    Repeatedly runs the sink for as long as its results satisfy the predicate p. The sink's results will be accumulated using the stepping function f.

  14. def contramap[I2](f: (I2) => I): ZSink[R, E, I2, Z]

    Transforms this sink's input elements.

  15. def contramapChunks[I2](f: (Chunk[I2]) => Chunk[I]): ZSink[R, E, I2, Z]

    Transforms this sink's input chunks.

  16. def contramapChunksM[R1 <: R, E1 >: E, I2](f: (Chunk[I2]) => ZIO[R1, E1, Chunk[I]]): ZSink[R1, E1, I2, Z]

    Effectfully transforms this sink's input chunks.

  17. def contramapM[R1 <: R, E1 >: E, I2](f: (I2) => ZIO[R1, E1, I]): ZSink[R1, E1, I2, Z]

    Effectfully transforms this sink's input elements.

  18. def dimap[I2, Z2](f: (I2) => I, g: (Z) => Z2): ZSink[R, E, I2, Z2]

    Transforms both inputs and result of this sink using the provided functions.

  19. def dimapChunks[I2, Z2](f: (Chunk[I2]) => Chunk[I], g: (Z) => Z2): ZSink[R, E, I2, Z2]

    Transforms both input chunks and result of this sink using the provided functions.

  20. def dimapChunksM[R1 <: R, E1 >: E, I2, Z2](f: (Chunk[I2]) => ZIO[R1, E1, Chunk[I]], g: (Z) => ZIO[R1, E1, Z2]): ZSink[R1, E1, I2, Z2]

    Effectfully transforms both input chunks and result of this sink using the provided functions.

  21. def dimapM[R1 <: R, E1 >: E, I2, Z2](f: (I2) => ZIO[R1, E1, I], g: (Z) => ZIO[R1, E1, Z2]): ZSink[R1, E1, I2, Z2]

    Effectfully transforms both inputs and result of this sink using the provided functions.

  22. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  23. def equals(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef → Any
  24. def finalize(): Unit
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.Throwable])
  25. def flatMap[R1 <: R, E1 >: E, I2 <: I, Z2](f: (Z) => ZSink[R1, E1, I2, Z2]): ZSink[R1, E1, I2, Z2]

    Runs this sink until it yields a result, then uses that result to create another sink from the provided function which will continue to run until it yields a result.

    Runs this sink until it yields a result, then uses that result to create another sink from the provided function which will continue to run until it yields a result.

    This function essentially runs sinks in sequence.

  26. def foldCauseM[R1 <: R, E2, I2 <: I, Z2](failure: (Cause[E]) => ZSink[R1, E2, I2, Z2], success: (Z) => ZSink[R1, E2, I2, Z2]): ZSink[R1, E2, I2, Z2]
  27. def foldM[R1 <: R, E2, I2 <: I, Z2](failure: (E) => ZSink[R1, E2, I2, Z2], success: (Z) => ZSink[R1, E2, I2, Z2]): ZSink[R1, E2, I2, Z2]
  28. final def getClass(): Class[_ <: AnyRef]
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  29. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  30. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  31. def map[Z2](f: (Z) => Z2): ZSink[R, E, I, Z2]

    Transforms this sink's result.

  32. def mapError[E2](f: (E) => E2): ZSink[R, E2, I, Z]

    Transforms the errors emitted by this sink using f.

  33. def mapM[R1 <: R, E1 >: E, Z2](f: (Z) => ZIO[R1, E1, Z2]): ZSink[R1, E1, I, Z2]

    Effectfully transforms this sink's result.

  34. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  35. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  36. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  37. val push: ZManaged[R, Nothing, Push[R, E, I, Z]]
  38. final def race[R1 <: R, E1 >: E, A0, I1 <: I, Z1 >: Z](that: ZSink[R1, E1, I1, Z1]): ZSink[R1, E1, I1, Z1]

    Runs both sinks in parallel on the input, , returning the result or the error from the one that finishes first.

  39. final def raceBoth[R1 <: R, E1 >: E, A0, I1 <: I, Z1](that: ZSink[R1, E1, I1, Z1]): ZSink[R1, E1, I1, Either[Z, Z1]]

    Runs both sinks in parallel on the input, returning the result or the error from the one that finishes first.

  40. final def synchronized[T0](arg0: => T0): T0
    Definition Classes
    AnyRef
  41. def toString(): String
    Definition Classes
    AnyRef → Any
  42. def toTransducer: ZTransducer[R, E, I, Z]

    Converts this sink to a transducer that feeds incoming elements to the sink and emits the sink's results as outputs.

    Converts this sink to a transducer that feeds incoming elements to the sink and emits the sink's results as outputs. The sink will be restarted when it ends.

  43. def untilOutputM[R1 <: R, E1 >: E](f: (Z) => ZIO[R1, E1, Boolean]): ZSink[R1, E1, I, Option[Z]]

    Creates a sink that produces values until one verifies the predicate f.

  44. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  45. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  46. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException]) @native()
  47. final def zip[R1 <: R, E1 >: E, I1 <: I, Z1, Z2](that: ZSink[R1, E1, I1, Z1]): ZSink[R1, E1, I1, (Z, Z1)]

    Feeds inputs to this sink until it yields a result, then switches over to the provided sink until it yields a result, combining the two results in a tuple.

  48. final def zipLeft[R1 <: R, E1 >: E, I1 <: I, Z1, Z2](that: ZSink[R1, E1, I1, Z1]): ZSink[R1, E1, I1, Z]

    Like zip, but keeps only the result from the that sink.

  49. final def zipPar[R1 <: R, E1 >: E, I1 <: I, Z1](that: ZSink[R1, E1, I1, Z1]): ZSink[R1, E1, I1, (Z, Z1)]

    Runs both sinks in parallel on the input and combines the results in a tuple.

  50. final def zipParLeft[R1 <: R, E1 >: E, I1 <: I](that: ZSink[R1, E1, I1, Any]): ZSink[R1, E1, I1, Z]

    Like zipPar, but keeps only the result from this sink.

  51. final def zipParRight[R1 <: R, E1 >: E, I1 <: I, Z1](that: ZSink[R1, E1, I1, Z1]): ZSink[R1, E1, I1, Z1]

    Like zipPar, but keeps only the result from the that sink.

  52. final def zipRight[R1 <: R, E1 >: E, I1 <: I, Z1, Z2](that: ZSink[R1, E1, I1, Z1]): ZSink[R1, E1, I1, Z1]

    Like zip, but keeps only the result from this sink.

  53. final def zipWith[R1 <: R, E1 >: E, I1 <: I, Z1, Z2](that: ZSink[R1, E1, I1, Z1])(f: (Z, Z1) => Z2): ZSink[R1, E1, I1, Z2]

    Feeds inputs to this sink until it yields a result, then switches over to the provided sink until it yields a result, finally combining the two results with f.

  54. final def zipWithPar[R1 <: R, E1 >: E, I1 <: I, Z1, Z2](that: ZSink[R1, E1, I1, Z1])(f: (Z, Z1) => Z2): ZSink[R1, E1, I1, Z2]

    Runs both sinks in parallel on the input and combines the results using the provided function.

  55. final def |[R1 <: R, E1 >: E, A0, I1 <: I, Z1 >: Z](that: ZSink[R1, E1, I1, Z1]): ZSink[R1, E1, I1, Z1]

    Operator alias for race.

Inherited from AnyRef

Inherited from Any

Ungrouped