Append

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

def +(other: String): String

final def ++[F2[x] >: F[x], O2 >: O](p2: ⇒ Process[F2, O2]): Process[F2, O2]

Alias for append

def ->[B](y: B): (Append[F, O], B)

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

final def append[F2[x] >: F[x], O2 >: O](p2: ⇒ Process[F2, O2]): Process[F2, O2]

If this process halts due to Cause.End, runs p2 after this.

final def asFinalizer: Process[F, O]

Mostly internal use function.

final def asInstanceOf[T0]: T0

final def attempt[F2[x] >: F[x], O2](f: (Throwable) ⇒ Process[F2, O2] = (t: Throwable) => emit(t)): Process[F2, \/[O2, O]]

Catch exceptions produced by this Process, not including termination by Continue, End, Kill and uses f to decide whether to resume a second process.

def awaitOption: Process[F, Option[O]]

Alias for this |> process1.awaitOption.

def buffer(n: Int): Process[F, O]

Alias for this |> process1.buffer(n).

def bufferAll: Process[F, O]

Alias for this |> process1.bufferAll.

def bufferBy(f: (O) ⇒ Boolean): Process[F, O]

Alias for this |> process1.bufferBy(f).

final def causedBy(cause: Cause): Process[F, O]

Attached cause when this Process terminates.

def chunk(n: Int): Process[F, Vector[O]]

Alias for this |> process1.chunk(n).

def chunkAll: Process[F, Vector[O]]

Alias for this |> process1.chunkAll.

def chunkBy(f: (O) ⇒ Boolean): Process[F, Vector[O]]

Alias for this |> process1.chunkBy(f).

def chunkBy2(f: (O, O) ⇒ Boolean): Process[F, Vector[O]]

Alias for this |> process1.chunkBy2(f).

def clone(): AnyRef

def collect[O2](pf: PartialFunction[O, O2]): Process[F, O2]

Alias for this |> process1.collect(pf).

def collectFirst[O2](pf: PartialFunction[O, O2]): Process[F, O2]

Alias for this |> process1.collectFirst(pf).

def delete(f: (O) ⇒ Boolean): Process[F, O]

Alias for this |> process1.delete(f).

final def disconnect(cause: EarlyCause): Process0[O]

Used when a Process1, Tee, or Wye is terminated by awaiting on a branch that is in the halted state or was killed.

def distinctConsecutive[O2 >: O](implicit O2: Equal[O2]): Process[F, O2]

Alias for this |> process1.distinctConsecutive.

def distinctConsecutiveBy[B](f: (O) ⇒ B)(implicit arg0: Equal[B]): Process[F, O]

Alias for this |> process1.distinctConsecutiveBy(f).

final def drain: Process[F, Nothing]

Ignore all outputs of this Process.

def drop(n: Int): Process[F, O]

Alias for this |> process1.drop(n).

def dropLast: Process[F, O]

Alias for this |> process1.dropLast.

def dropLastIf(p: (O) ⇒ Boolean): Process[F, O]

Alias for this |> process1.dropLastIf(p).

def dropRight(n: Int): Process[F, O]

Alias for this |> process1.dropRight(n).

def dropWhile(f: (O) ⇒ Boolean): Process[F, O]

Alias for this |> process1.dropWhile(f).

def either[O2 >: O, O3](p2: Process[Task, O3])(implicit S: Strategy): Process[Task, \/[O2, O3]]

Non-deterministic interleave of both streams.

def either[O2 >: O, O3](p2: Process[Task, O3])(implicit S: Strategy): Process[Task, \/[O2, O3]]

Non-deterministic interleave of both streams.

def ensuring(cond: (Append[F, O]) ⇒ Boolean, msg: ⇒ Any): Append[F, O]

def ensuring(cond: (Append[F, O]) ⇒ Boolean): Append[F, O]

def ensuring(cond: Boolean, msg: ⇒ Any): Append[F, O]

def ensuring(cond: Boolean): Append[F, O]

final def eq(arg0: AnyRef): Boolean

def evalMap[F2[x] >: F[x], O2](f: (O) ⇒ F2[O2]): Process[F2, O2]

Map over this Process to produce a stream of F-actions, then evaluate these actions.

def exists(f: (O) ⇒ Boolean): Process[F, Boolean]

Alias for this |> process1.exists(f)

def extend[F2[x] >: F[x], O2](f: (Process[F, O]) ⇒ Process[F2, O2]): Process[F2, O2]

Helper to modify the head and appended processes

final def fby[F2[x] >: F[x], O2 >: O](p2: ⇒ Process[F2, O2]): Process[F2, O2]

Alias for append

def filter(f: (O) ⇒ Boolean): Process[F, O]

Alias for this |> process1.filter(f).

def filterBy2(f: (O, O) ⇒ Boolean): Process[F, O]

Alias for this |> process1.filterBy2(f).

def finalize(): Unit

def find(f: (O) ⇒ Boolean): Process[F, O]

Alias for this |> process1.find(f)

final def flatMap[F2[x] >: F[x], O2](f: (O) ⇒ Process[F2, O2]): Process[F2, O2]

Generate a Process dynamically for each output of this Process, and sequence these processes using append.

def fold[B](b: B)(f: (B, O) ⇒ B): Process[F, B]

Alias for this |> process1.fold(b)(f).

def fold1[O2 >: O](f: (O2, O2) ⇒ O2): Process[F, O2]

Alias for this |> process1.fold1(f).

def fold1Map[M](f: (O) ⇒ M)(implicit M: Monoid[M]): Process[F, M]

Alias for this |> process1.fold1Map(f)(M).

def fold1Monoid[O2 >: O](implicit M: Monoid[O2]): Process[F, O2]

Alias for this |> process1.fold1Monoid(M)

def foldMap[M](f: (O) ⇒ M)(implicit M: Monoid[M]): Process[F, M]

Alias for this |> process1.foldMap(f)(M).

def foldMonoid[O2 >: O](implicit M: Monoid[O2]): Process[F, O2]

Alias for this |> process1.foldMonoid(M)

def foldSemigroup[O2 >: O](implicit M: Semigroup[O2]): Process[F, O2]

Alias for this |> process1.foldSemigroup(M).

def forall(f: (O) ⇒ Boolean): Process[F, Boolean]

Alias for this |> process1.forall(f)

def formatted(fmtstr: String): String

def gatherMap[F2[x] >: F[x], O2](bufSize: Int)(f: (O) ⇒ F2[O2])(implicit F: Nondeterminism[F2]): Process[F2, O2]

Map over this Process to produce a stream of F-actions, then evaluate these actions in batches of bufSize, allowing for nondeterminism in the evaluation order of each action in the batch.

final def getClass(): Class[_]

def handle[F2[x] >: F[x], O2](f: PartialFunction[Throwable, Process[F2, O2]])(implicit F: Catchable[F2]): Process[F2, O2]

Catch some of the exceptions generated by this Process, rethrowing any not handled by the given PartialFunction and stripping out any values emitted before the error.

val head: HaltEmitOrAwait[F, O]

def interleave[F2[x] >: F[x], O2 >: O](p2: Process[F2, O2]): Process[F2, O2]

Alternate emitting elements from this and p2, starting with this.

def intersperse[O2 >: O](sep: O2): Process[F, O2]

Alias for this |> process1.intersperse(sep).

final def isHalt: Boolean

Returns true, if this process is halted

final def isInstanceOf[T0]: Boolean

final def kill: Process[F, Nothing]

Causes this process to be terminated immediately with Kill cause, giving chance for any cleanup actions to be run

def last: Process[F, O]

Alias for this |> process1.last.

def lastOr[O2 >: O](o: ⇒ O2): Process[F, O2]

Alias for this |> process1.last.

final def map[O2](f: (O) ⇒ O2): Process[F, O2]

Transforms the output values of this Process using f.

def mapAccumulate[S, B](s: S)(f: (S, O) ⇒ (S, B)): Process[F, (S, B)]

Alias for this |> process1.mapAccumulate(s)(f).

def maximum[O2 >: O](implicit O2: Order[O2]): Process[F, O2]

Alias for this |> process1.maximum.

def maximumBy[B](f: (O) ⇒ B)(implicit arg0: Order[B]): Process[F, O]

Alias for this |> process1.maximumBy(f).

def maximumOf[B](f: (O) ⇒ B)(implicit arg0: Order[B]): Process[F, B]

Alias for this |> process1.maximumOf(f).

def merge[O2 >: O](p2: Process[Task, O2])(implicit S: Strategy): Process[Task, O2]

Non-deterministic interleave of both streams.

def merge[O2 >: O](p2: Process[Task, O2])(implicit S: Strategy): Process[Task, O2]

Non-deterministic interleave of both streams.

def minimum[O2 >: O](implicit O2: Order[O2]): Process[F, O2]

Alias for this |> process1.minimum.

def minimumBy[B](f: (O) ⇒ B)(implicit arg0: Order[B]): Process[F, O]

Alias for this |> process1.minimumBy(f).

def minimumOf[B](f: (O) ⇒ B)(implicit arg0: Order[B]): Process[F, B]

Alias for this |> process1.minimumOf(f).

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def observeOThrough[O2](ch: Channel[Task, O, O2]): Writer[Task, W, (O, O2)]

Returns result of channel evaluation on O side tupled with original output value passed to channel.

def observeOThrough[O2](ch: Channel[Task, O, O2]): Writer[Task, W, (O, O2)]

Returns result of channel evaluation on O side tupled with original output value passed to channel.

def observeWThrough[W2](ch: Channel[Task, W, W2]): Writer[Task, (W, W2), O]

Returns result of channel evaluation on W side tupled with original write value passed to channel.

def observeWThrough[W2](ch: Channel[Task, W, W2]): Writer[Task, (W, W2), O]

Returns result of channel evaluation on W side tupled with original write value passed to channel.

final def onComplete[F2[x] >: F[x], O2 >: O](p2: ⇒ Process[F2, O2]): Process[F2, O2]

Run p2 after this Process completes normally, or in the event of an error.

final def onFailure[F2[x] >: F[x], O2 >: O](f: (Throwable) ⇒ Process[F2, O2]): Process[F2, O2]

If this Process completes with an error, call f to produce the next state.

final def onHalt[F2[x] >: F[x], O2 >: O](f: (Cause) ⇒ Process[F2, O2]): Process[F2, O2]

When this Process halts, call f to produce the next state.

final def onKill[F2[x] >: F[x], O2 >: O](p: ⇒ Process[F2, O2]): Process[F2, O2]

Attach supplied process only if process has been killed.

def once: Process[F, O]

Alias for this |> Process.await1.

def partialAttempt[F2[x] >: F[x], O2](f: PartialFunction[Throwable, Process[F2, O2]])(implicit F: Catchable[F2]): Process[F2, \/[O2, O]]

Like attempt, but accepts a partial function.

final def pipe[O2](p1: Process1[O, O2]): Process[F, O2]

Feed the output of this Process as input of p1.

def prefixSums[O2 >: O](implicit N: Numeric[O2]): Process[F, O2]

Alias for this |> process1.prefixSums

def prepend[O2 >: O](os: Seq[O2]): Process[F, O2]

Prepend a sequence of elements to the output of this Process.

def reduce[O2 >: O](f: (O2, O2) ⇒ O2): Process[F, O2]

Alias for this |> process1.reduce(f).

def reduceMap[M](f: (O) ⇒ M)(implicit M: Semigroup[M]): Process[F, M]

Alias for this |> process1.reduceMap(f)(M).

def reduceMonoid[O2 >: O](implicit M: Monoid[O2]): Process[F, O2]

Alias for this |> process1.reduceMonoid(M).

def reduceSemigroup[O2 >: O](implicit M: Semigroup[O2]): Process[F, O2]

Alias for this |> process1.reduceSemigroup(M).

def repartition[O2 >: O](p: (O2) ⇒ IndexedSeq[O2])(implicit S: Semigroup[O2]): Process[F, O2]

Alias for this |> process1.repartition(p)(S)

def repartition2[O2 >: O](p: (O2) ⇒ (Option[O2], Option[O2]))(implicit S: Semigroup[O2]): Process[F, O2]

Alias for this |> process1.repartition2(p)(S)

final def repeat: Process[F, O]

Run this process until it halts, then run it again and again, as long as no errors or Kill occur.

final def run[F2[x] >: F[x]](implicit F: Monad[F2], C: Catchable[F2]): F2[Unit]

Run this Process, purely for its effects.

final def runFoldMap[F2[x] >: F[x], B](f: (O) ⇒ B)(implicit F: Monad[F2], C: Catchable[F2], B: Monoid[B]): F2[B]

Collect the outputs of this Process[F,O] into a Monoid B, given a Monad[F] in which we can catch exceptions.

final def runLast[F2[x] >: F[x], O2 >: O](implicit F: Monad[F2], C: Catchable[F2]): F2[Option[O2]]

Run this Process solely for its final emitted value, if one exists.

final def runLastOr[F2[x] >: F[x], O2 >: O](o2: ⇒ O2)(implicit F: Monad[F2], C: Catchable[F2]): F2[O2]

Run this Process solely for its final emitted value, if one exists, using o2 otherwise.

final def runLog[F2[x] >: F[x], O2 >: O](implicit F: Monad[F2], C: Catchable[F2]): F2[Vector[O2]]

Collect the outputs of this Process[F,O], given a Monad[F] in which we can catch exceptions.

def scan[B](b: B)(f: (B, O) ⇒ B): Process[F, B]

Alias for this |> process1.scan(b)(f).

def scan1[O2 >: O](f: (O2, O2) ⇒ O2): Process[F, O2]

Alias for this |> process1.scan1(f).

def scan1Map[M](f: (O) ⇒ M)(implicit M: Semigroup[M]): Process[F, M]

Alias for this |> process1.scan1Map(f)(M).

def scan1Monoid[O2 >: O](implicit M: Monoid[O2]): Process[F, O2]

Alias for this |> process1.scan1Monoid(M).

def scanMap[M](f: (O) ⇒ M)(implicit M: Monoid[M]): Process[F, M]

Alias for this |> process1.scanMap(f)(M).

def scanMonoid[O2 >: O](implicit M: Monoid[O2]): Process[F, O2]

Alias for this |> process1.scanMonoid(M).

def scanSemigroup[O2 >: O](implicit M: Semigroup[O2]): Process[F, O2]

Alias for this |> process1.scanSemigroup(M).

def shiftRight[O2 >: O](head: O2*): Process[F, O2]

Alias for this |> process1.shiftRight(head)

def sleepUntil[F2[x] >: F[x], O2 >: O](awaken: Process[F2, Boolean]): Process[F2, O2]

Delay running this Process until awaken becomes true for the first time.

def sliding(n: Int): Process[F, Vector[O]]

Alias for this |> process1.sliding(n).

def split(f: (O) ⇒ Boolean): Process[F, Vector[O]]

Alias for this |> process1.split(f)

def splitOn[P >: O](p: P)(implicit P: Equal[P]): Process[F, Vector[P]]

Alias for this |> process1.splitOn(p)

def splitWith(f: (O) ⇒ Boolean): Process[F, Vector[O]]

Alias for this |> process1.splitWith(f)

val stack: Vector[(Cause) ⇒ Trampoline[Process[F, O]]]

def stateScan[S, B](init: S)(f: (O) ⇒ State[S, B]): Process[F, B]

Alias for this |> process1.stateScan(init)(f).

final def step: HaltOrStep[F, O]

Run one step of an incremental traversal of this Process.

def sum[O2 >: O](implicit N: Numeric[O2]): Process[F, O2]

Alias for this |> process1.sum

final def suspendStep: Process0[HaltOrStep[F, O]]

p.suspendStep propagates exceptions to p.

final def swallowKill: Process[F, O]

For anly process terminating with Kill, this swallows the Kill and replaces it with End termination

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

def tail: Process[F, O]

Alias for this |> process1.tail.

def take(n: Int): Process[F, O]

Alias for this |> process1.take(n).

def takeRight(n: Int): Process[F, O]

Alias for this |> process1.takeRight(n).

def takeThrough(f: (O) ⇒ Boolean): Process[F, O]

Alias for this |> process1.takeThrough(f).

def takeWhile(f: (O) ⇒ Boolean): Process[F, O]

Alias for this |> process1.takeWhile(f).

final def tee[F2[x] >: F[x], O2, O3](p2: Process[F2, O2])(t: Tee[O, O2, O3]): Process[F2, O3]

Use a Tee to interleave or combine the outputs of this and p2.

def terminated: Process[F, Option[O]]

Alias for this |> process1.terminated.

def throughO[O2](ch: Channel[Task, O, O2]): Writer[Task, W, O2]

Feed this Writer's output through the provided effectful Channel.

def throughO[O2](ch: Channel[Task, O, O2]): Writer[Task, W, O2]

Feed this Writer's output through the provided effectful Channel.

def throughW[W2](ch: Channel[Task, W, W2]): Writer[Task, W2, O]

Feed this Writer's writes through the provided effectful Channel.

def throughW[W2](ch: Channel[Task, W, W2]): Writer[Task, W2, O]

Feed this Writer's writes through the provided effectful Channel.

def translate[G[_]](f: ~>[F, G]): Process[G, O]

Translate the request type from F to G, using the given polymorphic function.

final def trim: Process[F, O]

Remove any leading emitted values from this Process.

final def uncons[F2[x] >: F[x], O2 >: O](implicit F: Monad[F2], C: Catchable[F2]): F2[(O2, Process[F2, O2])]

final def unconsOption[F2[x] >: F[x], O2 >: O](implicit F: Monad[F2], C: Catchable[F2]): F2[Option[(O2, Process[F2, O2])]]

final def unemit: (Seq[O], Process[F, O])

Removes all emitted elements from the front of this Process.

def until[F2[x] >: F[x], O2 >: O](condition: Process[F2, Boolean]): Process[F2, O2]

Halts this Process as soon as condition becomes true.

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def when[F2[x] >: F[x], O2 >: O](condition: Process[F2, Boolean]): Process[F2, O2]

When condition is true, lets through any values in this process, otherwise blocks until condition becomes true again.

def zip[F2[x] >: F[x], O2](p2: Process[F2, O2]): Process[F2, (O, O2)]

Call tee with the zip Tee[O,O2,O3] defined in tee.scala.

def zipWith[F2[x] >: F[x], O2, O3](p2: Process[F2, O2])(f: (O, O2) ⇒ O3): Process[F2, O3]

Call tee with the zipWith Tee[O,O2,O3] defined in tee.scala.

def zipWithIndex[N](implicit arg0: Numeric[N]): Process[F, (O, N)]

Alias for this |> process1.zipWithIndex[A,N]*.

def zipWithIndex: Process[F, (O, Int)]

Alias for this |> process1.zipWithIndex[A]*.

def zipWithNext: Process[F, (O, Option[O])]

Alias for this |> process1.zipWithNext.

def zipWithPrevious: Process[F, (Option[O], O)]

Alias for this |> process1.zipWithPrevious.

def zipWithPreviousAndNext: Process[F, (Option[O], O, Option[O])]

Alias for this |> process1.zipWithPreviousAndNext.

def zipWithScan[B](z: B)(next: (O, B) ⇒ B): Process[F, (O, B)]

Alias for this |> process1.zipWithScan(z)(next).

def zipWithScan1[B](z: B)(next: (O, B) ⇒ B): Process[F, (O, B)]

Alias for this |> process1.zipWithScan(z)(next).

def zipWithState[B](z: B)(next: (O, B) ⇒ B): Process[F, (O, B)]

Alias for this |> process1.zipWithState(z)(next).

final def |>[O2](p2: Process1[O, O2]): Process[F, O2]

Operator alias for pipe.

def →[B](y: B): (Append[F, O], B)

def apply(input: Iterable[Any]): IndexedSeq[O]

Apply this Process to an Iterable.

def apply(input: Iterable[Any], input2: Iterable[Any]): IndexedSeq[O]

Apply a Wye to two Iterable inputs.

def apply(input: Iterable[Any], input2: Iterable[Any]): IndexedSeq[O]

Apply a Wye to two Iterable inputs.

def apply(input: Iterable[Any]): IndexedSeq[O]

Apply this Process to an Iterable.

def attachL[I0](f: Process1[I0, Any]): Wye[I0, Any, O]

Transform the left input of the given Wye using a Process1.

def attachL[I0](f: Process1[I0, Any]): Wye[I0, Any, O]

Transform the left input of the given Wye using a Process1.

def attachR[I1](f: Process1[I1, Any]): Wye[Any, I1, O]

Transform the right input of the given Wye using a Process1.

def attachR[I1](f: Process1[I1, Any]): Wye[Any, I1, O]

Transform the right input of the given Wye using a Process1.

def contramap[I0](f: (I0) ⇒ Any): Process1[I0, O]

Transform the input of this Process1.

def contramap[I0](f: (I0) ⇒ Any): Process1[I0, O]

Transform the input of this Process1.

def contramapL[I0](f: (I0) ⇒ Any): Wye[I0, Any, O]

Transform the left input to a Wye.

def contramapL[I0](f: (I0) ⇒ Any): Tee[I0, Any, O]

Transform the left input to a Tee.

def contramapL[I0](f: (I0) ⇒ Any): Wye[I0, Any, O]

Transform the left input to a Wye.

def contramapL[I0](f: (I0) ⇒ Any): Tee[I0, Any, O]

Transform the left input to a Tee.

def contramapR[I3](f: (I3) ⇒ Any): Wye[Any, I3, O]

Transform the right input to a Wye.

def contramapR[I3](f: (I3) ⇒ Any): Tee[Any, I3, O]

Transform the right input to a Tee.

def contramapR[I3](f: (I3) ⇒ Any): Wye[Any, I3, O]

Transform the right input to a Wye.

def contramapR[I3](f: (I3) ⇒ Any): Tee[Any, I3, O]

Transform the right input to a Tee.

def detach1L: Wye[Any, Any, O]

Converting requests for the left input into normal termination.

def detach1L: Wye[Any, Any, O]

Converting requests for the left input into normal termination.

def detach1R: Wye[Any, Any, O]

Converting requests for the right input into normal termination.

def detach1R: Wye[Any, Any, O]

Converting requests for the right input into normal termination.

def feed1(i: Any): Process1[Any, O]

Feed a single input to this Process1.

def feed1(i: Any): Process1[Any, O]

Feed a single input to this Process1.

def forwardFill(implicit S: Strategy): Process[Task, O]

Produce a continuous stream from a discrete stream by using the most recent value.

def forwardFill(implicit S: Strategy): Process[Task, O]

Produce a continuous stream from a discrete stream by using the most recent value.

def liftL[I2]: Process1[\/[Any, I2], \/[O, I2]]

Transform self to operate on the left hand side of an \/, passing through any values it receives on the right.

def liftL[I2]: Process1[\/[Any, I2], \/[O, I2]]

Transform self to operate on the left hand side of an \/, passing through any values it receives on the right.

def liftR[I0]: Process1[\/[I0, Any], \/[I0, O]]

Transform self to operate on the right hand side of an \/, passing through any values it receives on the left.

def liftR[I0]: Process1[\/[I0, Any], \/[I0, O]]

Transform self to operate on the right hand side of an \/, passing through any values it receives on the left.

def observeThrough[O2](ch: Channel[Task, O, O2]): Process[Task, (O, O2)]

Returns result of channel evaluation tupled with original value passed to channel.

def observeThrough[O2](ch: Channel[Task, O, O2]): Process[Task, (O, O2)]

Returns result of channel evaluation tupled with original value passed to channel.

def pipeIn[I0](p1: Process1[I0, Any]): Sink[Task, I0]

converts sink to sink that first pipes received I0 to supplied p1

def pipeIn[I0](p1: Process1[I0, Any]): Sink[Task, I0]

converts sink to sink that first pipes received I0 to supplied p1

val self: Process[Task, O]

val self: Process1[Any, O]

val self: Wye[Any, Any, O]

val self: Writer[Task, W, O]

val self: Tee[Any, Any, O]

val self: Sink[Task, Any]

val self: Process[Task, O]

val self: Wye[Any, Any, O]

val self: Writer[Task, W, O]

val self: Tee[Any, Any, O]

val self: Sink[Task, Any]

val self: Process1[Any, O]

val self: Any

val self: Any

def toSignal(implicit S: Strategy): Signal[O]

converts process to signal *

def toSignal(implicit S: Strategy): Signal[O]

converts process to signal *

final def wye[O2, O3](p2: Process[Task, O2])(y: Wye[O, O2, O3])(implicit S: Strategy): Process[Task, O3]

Like tee, but we allow the Wye to read non-deterministically from both sides at once.

final def wye[O2, O3](p2: Process[Task, O2])(y: Wye[O, O2, O3])(implicit S: Strategy): Process[Task, O3]

Like tee, but we allow the Wye to read non-deterministically from both sides at once.

def yip[O2](p2: Process[Task, O2])(implicit S: Strategy): Process[Task, (O, O2)]

Non-deterministic version of zip.

def yip[O2](p2: Process[Task, O2])(implicit S: Strategy): Process[Task, (O, O2)]

Non-deterministic version of zip.

def yipWith[O2, O3](p2: Process[Task, O2])(f: (O, O2) ⇒ O3)(implicit S: Strategy): Process[Task, O3]

Non-deterministic version of zipWith.

def yipWith[O2, O3](p2: Process[Task, O2])(f: (O, O2) ⇒ O3)(implicit S: Strategy): Process[Task, O3]

Non-deterministic version of zipWith.

def x: Append[F, O]

def x: Append[F, O]