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, L1 >: L, Z1](that: ZSink[R1, E1, I1, L1, Z1]): ZSink[R1, E1, I1, L1, Z1]

   Operator alias for zipParRight.

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

   Operator alias for zipRight.

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

   Operator alias for zipParLeft.

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

   Operator alias for zipPar.

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

   Operator alias for zipLeft.

8.  final def <*>[R1 <: R, E1 >: E, I1 <: I, L1 >: L, Z1, Z2](that: ZSink[R1, E1, I1, L1, Z1])(implicit ev: <:<[L, I1]): ZSink[R1, E1, I1, L1, (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, L, 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( ... ) @native()

13.  def collectAllWhileWith[S](z: S)(p: (Z) ⇒ Boolean)(f: (S, Z) ⇒ S)(implicit ev: <:<[L, I]): ZSink[R, E, I, L, 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, L, Z]

    Transforms this sink's input elements.

15.  def contramapChunks[I2](f: (Chunk[I2]) ⇒ Chunk[I]): ZSink[R, E, I2, L, Z]

    Transforms this sink's input chunks.

    Transforms this sink's input chunks. f must preserve chunking-invariance

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

    Effectfully transforms this sink's input chunks.

    Effectfully transforms this sink's input chunks. f must preserve chunking-invariance

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

    Effectfully transforms this sink's input elements.

18.  def dimap[I2, Z2](f: (I2) ⇒ I, g: (Z) ⇒ Z2): ZSink[R, E, I2, L, 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, L, 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, L, Z2]

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

    Effectfully transforms both input chunks and result of this sink using the provided functions. f and g must preserve chunking-invariance

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, L, Z2]

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

22.  def dropLeftover: ZSink[R, E, I, Nothing, Z]
23.  final def eq(arg0: AnyRef): Boolean

    Definition Classes

    AnyRef

24.  def equals(arg0: Any): Boolean

    Definition Classes

    AnyRef → Any

25.  def exposeLeftover: ZSink[R, E, I, Nothing, (Z, Chunk[L])]
26.  def finalize(): Unit

    Attributes

    protected[lang]

    Definition Classes

    AnyRef

    Annotations

    @throws( classOf[java.lang.Throwable] )

27.  def flatMap[R1 <: R, E1 >: E, I2 <: I, L2, Z2](f: (Z) ⇒ ZSink[R1, E1, I2, L2, Z2])(implicit ev: <:<[L, I2]): ZSink[R1, E1, I2, L2, 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.

28.  def foldM[R1 <: R, E2, I2 <: I, L2, Z2](failure: (E) ⇒ ZSink[R1, E2, I2, L2, Z2], success: (Z) ⇒ ZSink[R1, E2, I2, L2, Z2])(implicit ev: <:<[L, I2]): ZSink[R1, E2, I2, L2, Z2]
29.  final def getClass(): Class[_]

    Definition Classes

    AnyRef → Any

    Annotations

    @native()

30.  def hashCode(): Int

    Definition Classes

    AnyRef → Any

    Annotations

    @native()

31.  final def isInstanceOf[T0]: Boolean

    Definition Classes

    Any

32.  def map[Z2](f: (Z) ⇒ Z2): ZSink[R, E, I, L, Z2]

    Transforms this sink's result.

33.  def mapError[E2](f: (E) ⇒ E2): ZSink[R, E2, I, L, Z]

    Transforms the errors emitted by this sink using f.

34.  def mapM[R1 <: R, E1 >: E, Z2](f: (Z) ⇒ ZIO[R1, E1, Z2]): ZSink[R1, E1, I, L, Z2]

    Effectfully transforms this sink's result.

35.  final def ne(arg0: AnyRef): Boolean

    Definition Classes

    AnyRef

36.  final def notify(): Unit

    Definition Classes

    AnyRef

    Annotations

    @native()

37.  final def notifyAll(): Unit

    Definition Classes

    AnyRef

    Annotations

    @native()

38.  def provide(r: R)(implicit ev: NeedsEnv[R]): ZSink[Any, E, I, L, Z]

    Provides the sink with its required environment, which eliminates its dependency on R.

39.  val push: ZManaged[R, Nothing, Push[R, E, I, L, Z]]
40.  final def race[R1 <: R, E1 >: E, A0, I1 <: I, L1 >: L, Z1 >: Z](that: ZSink[R1, E1, I1, L1, Z1]): ZSink[R1, E1, I1, L1, Z1]

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

41.  final def raceBoth[R1 <: R, E1 >: E, I1 <: I, L1 >: L, Z1](that: ZSink[R1, E1, I1, L1, Z1]): ZSink[R1, E1, I1, L1, Either[Z, Z1]]

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

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

    Definition Classes

    AnyRef

43.  final def timed: ZSink[R with Clock, E, I, L, (Z, Duration)]

    Returns the sink that executes this one and times its execution.

44.  def toString(): String

    Definition Classes

    AnyRef → Any

45.  def toTransducer(implicit ev: <:<[L, I]): 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.

46.  def untilOutputM[R1 <: R, E1 >: E](f: (Z) ⇒ ZIO[R1, E1, Boolean])(implicit ev: <:<[L, I]): ZSink[R1, E1, I, L, Option[Z]]

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

47.  final def wait(): Unit

    Definition Classes

    AnyRef

    Annotations

    @throws( ... )

48.  final def wait(arg0: Long, arg1: Int): Unit

    Definition Classes

    AnyRef

    Annotations

    @throws( ... )

49.  final def wait(arg0: Long): Unit

    Definition Classes

    AnyRef

    Annotations

    @throws( ... ) @native()

50.  final def zip[R1 <: R, E1 >: E, I1 <: I, L1 >: L, Z1, Z2](that: ZSink[R1, E1, I1, L1, Z1])(implicit ev: <:<[L, I1]): ZSink[R1, E1, I1, L1, (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.

51.  final def zipLeft[R1 <: R, E1 >: E, I1 <: I, L1 >: L, Z1, Z2](that: ZSink[R1, E1, I1, L1, Z1])(implicit ev: <:<[L, I1]): ZSink[R1, E1, I1, L1, Z]

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

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

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

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

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

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

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

55.  final def zipRight[R1 <: R, E1 >: E, I1 <: I, L1 >: L, Z1, Z2](that: ZSink[R1, E1, I1, L1, Z1])(implicit ev: <:<[L, I1]): ZSink[R1, E1, I1, L1, Z1]

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

56.  final def zipWith[R1 <: R, E1 >: E, I1 <: I, L1 >: L, Z1, Z2](that: ZSink[R1, E1, I1, L1, Z1])(f: (Z, Z1) ⇒ Z2)(implicit ev: <:<[L, I1]): ZSink[R1, E1, I1, L1, 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.

57.  final def zipWithPar[R1 <: R, E1 >: E, I1 <: I, L1 >: L, Z1, Z2](that: ZSink[R1, E1, I1, L1, Z1])(f: (Z, Z1) ⇒ Z2): ZSink[R1, E1, I1, L1, Z2]

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

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

    Operator alias for race.