ZPipeline

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def apply[I]: ZPipeline[Any, Nothing, I, I]

A shorter version of ZPipeline.identity, which can facilitate more compact definition of pipelines.

ZPipeline[Int].filter(_ % 2 != 0)

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def collect[In, Out](f: PartialFunction[In, Out]): ZPipeline[Any, Nothing, In, Out]

Creates a pipeline that collects elements with the specified partial function.

ZPipeline.collect[Option[Int], Int] { case Some(v) => v }

def die(e: ⇒ Throwable): ZPipeline[Any, Nothing, Any, Nothing]

Creates a transducer that always dies with the specified exception.

ZPipeline.die(new IllegalStateException)

def dropUntil[In](f: (In) ⇒ Boolean): ZPipeline[Any, Nothing, In, In]

Creates a pipeline that drops elements until the specified predicate evaluates to true.

ZPipeline.dropUntil[Int](_ > 100)

def dropWhile[In](f: (In) ⇒ Boolean): ZPipeline[Any, Nothing, In, In]

Creates a pipeline that drops elements while the specified predicate evaluates to true.

ZPipeline.dropWhile[Int](_ <= 100)

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def fail[E](e: ⇒ E): ZPipeline[Any, E, Any, Nothing]

Creates a pipeline that always fails with the specified value.

def failCause[E](cause: ⇒ Cause[E]): ZPipeline[Any, E, Any, Nothing]

Creates a transducer that always dies with the specified exception.

def filter[In](f: (In) ⇒ Boolean): ZPipeline[Any, Nothing, In, In]

Creates a pipeline that filters elements according to the specified predicate.

def finalize(): Unit

def fold[I, O](out0: O)(contFn: (O) ⇒ Boolean)(f: (O, I) ⇒ O): ZPipeline[Any, Nothing, I, O]

A stateful fold that will emit the state and reset to the starting state every time the specified predicate returns false.

def foldLeft[In, Out](z: Out)(f: (Out, In) ⇒ Out): ZPipeline[Any, Nothing, In, Out]

Creates a pipeline from the provided fold function, which operates on the state and the elements of the source stream.

val counter = ZPipeline.foldLeft(0)((count, _) => count + 1)

def foldLeftZIO[R, E, I, O](z: O)(f: (O, I) ⇒ ZIO[R, E, O]): ZPipeline[R, E, I, O]

Creates a transducer by effectfully folding over a structure of type O.

def foldUntil[I, O](z: O, max: Long)(f: (O, I) ⇒ O): ZPipeline[Any, Nothing, I, O]

Creates a transducer that folds elements of type I into a structure of type O until max elements have been folded.

def foldUntilZIO[R, E, I, O](z: O, max: Long)(f: (O, I) ⇒ ZIO[R, E, O]): ZPipeline[R, E, I, O]

Creates a transducer that effectfully folds elements of type I into a structure of type O until max elements have been folded.

def foldZIO[R, E, I, O](out0: O)(contFn: (O) ⇒ Boolean)(f: (O, I) ⇒ ZIO[R, E, O]): ZPipeline[R, E, I, O]

A stateful fold that will emit the state and reset to the starting state every time the specified predicate returns false.

def fromZIO[R, E, A](zio: ZIO[R, E, A]): ZPipeline[R, E, Any, A]

Creates a pipeline that effectfully maps elements to the specified effectfully-computed value.

final def getClass(): Class[_]

def hashCode(): Int

def identity[A]: ZPipeline[Any, Nothing, A, A]

The identity pipeline, which does not modify streams in any way.

final def isInstanceOf[T0]: Boolean

def map[In, Out](f: (In) ⇒ Out): ZPipeline[Any, Nothing, In, Out]

Creates a pipeline that maps elements with the specified function.

def mapZIO[Env0, Err0, In, Out](f: (In) ⇒ ZIO[Env0, Err0, Out]): ZPipeline[Env0, Err0, In, Out]

Creates a pipeline that maps elements with the specified effectful function.

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def succeed[A](a: ⇒ A): ZPipeline[Any, Nothing, Any, A]

Creates a pipeline that always succeeds with the specified value.

final def synchronized[T0](arg0: ⇒ T0): T0

def takeUntil[In](f: (In) ⇒ Boolean): ZPipeline[Any, Nothing, In, In]

Creates a pipeline that takes elements until the specified predicate evaluates to true.

def takeWhile[In](f: (In) ⇒ Boolean): ZPipeline[Any, Nothing, In, In]

Creates a pipeline that takes elements while the specified predicate evaluates to true.

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def foldLeftM[R, E, I, O](z: O)(f: (O, I) ⇒ ZIO[R, E, O]): ZPipeline[R, E, I, O]

Creates a transducer by effectfully folding over a structure of type O.

def foldM[R, E, I, O](out0: O)(contFn: (O) ⇒ Boolean)(f: (O, I) ⇒ ZIO[R, E, O]): ZPipeline[R, E, I, O]

A stateful fold that will emit the state and reset to the starting state every time the specified predicate returns false.

def foldUntilM[R, E, I, O](z: O, max: Long)(f: (O, I) ⇒ ZIO[R, E, O]): ZPipeline[R, E, I, O]

Creates a transducer that effectfully folds elements of type I into a structure of type O until max elements have been folded.

def fromEffect[R, E, A](zio: ZIO[R, E, A]): ZPipeline[R, E, Any, A]

Creates a pipeline that effectfully maps elements to the specified effectfully-computed value.

def halt[E](cause: ⇒ Cause[E]): ZPipeline[Any, E, Any, Nothing]

Creates a transducer that always dies with the specified exception.

def mapM[Env0, Err0, In, Out](f: (In) ⇒ ZIO[Env0, Err0, Out]): ZPipeline[Env0, Err0, In, Out]

Creates a pipeline that maps elements with the specified effectful function.