Halt

Instance Constructors

new Halt(cause: Cause)

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
def +(other: String): String

Implicit information
This member is added by an implicit conversion from Halt to any2stringadd[Halt] performed by method any2stringadd in scala.Predef.
Definition Classes
any2stringadd
final def ++[F2[x] >: Nothing, O2 >: Nothing](p2: ⇒ Process[F2, O2]): Process[F2, O2]

Alias for append
Alias for append

Definition Classes
Process
def ->[B](y: B): (Halt, B)

Implicit information
This member is added by an implicit conversion from Halt to ArrowAssoc[Halt] performed by method ArrowAssoc in scala.Predef.
Definition Classes
ArrowAssoc
Annotations
@inline()
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def append[F2[x] >: Nothing, O2 >: Nothing](p2: ⇒ Process[F2, O2]): Process[F2, O2]

If this process halts due to Cause.End, runs p2 after this.
If this process halts due to Cause.End, runs p2 after this. Otherwise halts with whatever caused this to Halt.

Definition Classes
Process
final def asFinalizer: Process[Nothing, Nothing]

Mostly internal use function.
Mostly internal use function. Ensures this Process is run even when being kill-ed. Used to ensure resource safety in various combinators.

Definition Classes
Process
final def asInstanceOf[T0]: T0

Definition Classes
Any
final def attempt[F2[x] >: Nothing, O2](f: (Throwable) ⇒ Process[F2, O2] = (t: Throwable) => emit(t)): Process[F2, \/[O2, Nothing]]

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

Definition Classes
Process
def awaitOption: Process[Nothing, Option[Nothing]]

Alias for this |> process1.awaitOption.
Alias for this |> process1.awaitOption.

Definition Classes
Process1Ops
def buffer(n: Int): Process[Nothing, Nothing]

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

Definition Classes
Process1Ops
def bufferAll: Process[Nothing, Nothing]

Alias for this |> process1.bufferAll.
Alias for this |> process1.bufferAll.

Definition Classes
Process1Ops
def bufferBy(f: (Nothing) ⇒ Boolean): Process[Nothing, Nothing]

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

Definition Classes
Process1Ops
val cause: Cause
final def causedBy(cause: Cause): Process[Nothing, Nothing]

Attached cause when this Process terminates.
Attached cause when this Process terminates. See Cause.causedBy for semantics.

Definition Classes
Process
def chunk(n: Int): Process[Nothing, Vector[Nothing]]

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

Definition Classes
Process1Ops
def chunkAll: Process[Nothing, Vector[Nothing]]

Alias for this |> process1.chunkAll.
Alias for this |> process1.chunkAll.

Definition Classes
Process1Ops
def chunkBy(f: (Nothing) ⇒ Boolean): Process[Nothing, Vector[Nothing]]

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

Definition Classes
Process1Ops
def chunkBy2(f: (Nothing, Nothing) ⇒ Boolean): Process[Nothing, Vector[Nothing]]

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

Definition Classes
Process1Ops
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def collect[O2](pf: PartialFunction[Nothing, O2]): Process[Nothing, O2]

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

Definition Classes
Process1Ops
def collectFirst[O2](pf: PartialFunction[Nothing, O2]): Process[Nothing, O2]

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

Definition Classes
Process1Ops
def delete(f: (Nothing) ⇒ Boolean): Process[Nothing, Nothing]

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

Definition Classes
Process1Ops
final def disconnect(cause: EarlyCause): Process0[Nothing]

Used when a Process1, Tee, or Wye is terminated by awaiting on a branch that is in the halted state or was killed.
Used when a Process1, Tee, or Wye is terminated by awaiting on a branch that is in the halted state or was killed. Such a process is given the opportunity to emit any final values. All Awaits are converted to terminate with cause

Definition Classes
Process
def distinctConsecutive[O2 >: Nothing](implicit O2: Equal[O2]): Process[Nothing, O2]

Alias for this |> process1.distinctConsecutive.
Alias for this |> process1.distinctConsecutive.

Definition Classes
Process1Ops
def distinctConsecutiveBy[B](f: (Nothing) ⇒ B)(implicit arg0: Equal[B]): Process[Nothing, Nothing]

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

Definition Classes
Process1Ops
final def drain: Process[Nothing, Nothing]

Ignore all outputs of this Process.
Ignore all outputs of this Process.

Definition Classes
Process
def drop(n: Int): Process[Nothing, Nothing]

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

Definition Classes
Process1Ops
def dropLast: Process[Nothing, Nothing]

Alias for this |> process1.dropLast.
Alias for this |> process1.dropLast.

Definition Classes
Process1Ops
def dropLastIf(p: (Nothing) ⇒ Boolean): Process[Nothing, Nothing]

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

Definition Classes
Process1Ops
def dropRight(n: Int): Process[Nothing, Nothing]

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

Definition Classes
Process1Ops
def dropWhile(f: (Nothing) ⇒ Boolean): Process[Nothing, Nothing]

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

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

Non-deterministic interleave of both streams.
Non-deterministic interleave of both streams. Emits values whenever either is defined. Note this terminates after BOTH sides terminate

Implicit information
This member is added by an implicit conversion from Halt to SourceSyntax[O] performed by method SourceSyntax in scalaz.stream.Process.
Definition Classes
WyeOps
def either[O2 >: O, O3](p2: Process[Task, O3])(implicit S: Strategy): Process[Task, \/[O2, O3]]

Non-deterministic interleave of both streams.
Non-deterministic interleave of both streams. Emits values whenever either is defined. Note this terminates after BOTH sides terminate

Implicit information
This member is added by an implicit conversion from Halt to SourceSyntax[O] performed by method SourceSyntax in scalaz.stream.Process.
Definition Classes
WyeOps
def ensuring(cond: (Halt) ⇒ Boolean, msg: ⇒ Any): Halt

Implicit information
This member is added by an implicit conversion from Halt to Ensuring[Halt] performed by method Ensuring in scala.Predef.
Definition Classes
Ensuring
def ensuring(cond: (Halt) ⇒ Boolean): Halt

Implicit information
This member is added by an implicit conversion from Halt to Ensuring[Halt] performed by method Ensuring in scala.Predef.
Definition Classes
Ensuring
def ensuring(cond: Boolean, msg: ⇒ Any): Halt

Implicit information
This member is added by an implicit conversion from Halt to Ensuring[Halt] performed by method Ensuring in scala.Predef.
Definition Classes
Ensuring
def ensuring(cond: Boolean): Halt

Implicit information
This member is added by an implicit conversion from Halt to Ensuring[Halt] performed by method Ensuring in scala.Predef.
Definition Classes
Ensuring
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def evalMap[F2[x] >: Nothing, O2](f: (Nothing) ⇒ F2[O2]): Process[F2, O2]

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

Definition Classes
Process
def exists(f: (Nothing) ⇒ Boolean): Process[Nothing, Boolean]

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

Definition Classes
Process1Ops
final def fby[F2[x] >: Nothing, O2 >: Nothing](p2: ⇒ Process[F2, O2]): Process[F2, O2]

Alias for append
Alias for append

Definition Classes
Process
def filter(f: (Nothing) ⇒ Boolean): Process[Nothing, Nothing]

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

Definition Classes
Process1Ops
def filterBy2(f: (Nothing, Nothing) ⇒ Boolean): Process[Nothing, Nothing]

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

Definition Classes
Process1Ops
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def find(f: (Nothing) ⇒ Boolean): Process[Nothing, Nothing]

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

Definition Classes
Process1Ops
final def flatMap[F2[x] >: Nothing, O2](f: (Nothing) ⇒ Process[F2, O2]): Process[F2, O2]

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

Definition Classes
Process
def flatMapO[F2[x] >: F[x], W2 >: W, B](f: (O) ⇒ Writer[F2, W2, B]): Writer[F2, W2, B]

Implicit information
This member is added by an implicit conversion from Halt to WriterSyntax[F, W, O] performed by method toWriterSyntax in scalaz.stream.Process.
Definition Classes
WriterSyntax
def flatMapO[F2[x] >: F[x], W2 >: W, B](f: (O) ⇒ Writer[F2, W2, B]): Writer[F2, W2, B]

Implicit information
This member is added by an implicit conversion from Halt to WriterSyntax[F, W, O] performed by method toWriterSyntax in scalaz.stream.Process.
Definition Classes
WriterSyntax
def flatMapW[F2[x] >: F[x], W2, O2 >: O](f: (W) ⇒ Writer[F2, W2, O2]): Writer[F2, W2, O2]

Transform the write side of this Writer.
Transform the write side of this Writer.

Implicit information
This member is added by an implicit conversion from Halt to WriterSyntax[F, W, O] performed by method toWriterSyntax in scalaz.stream.Process.
Definition Classes
WriterSyntax
def flatMapW[F2[x] >: F[x], W2, O2 >: O](f: (W) ⇒ Writer[F2, W2, O2]): Writer[F2, W2, O2]

Transform the write side of this Writer.
Transform the write side of this Writer.

Implicit information
This member is added by an implicit conversion from Halt to WriterSyntax[F, W, O] performed by method toWriterSyntax in scalaz.stream.Process.
Definition Classes
WriterSyntax
def fold[B](b: B)(f: (B, Nothing) ⇒ B): Process[Nothing, B]

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

Definition Classes
Process1Ops
def fold1[O2 >: Nothing](f: (O2, O2) ⇒ O2): Process[Nothing, O2]

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

Definition Classes
Process1Ops
def fold1Map[M](f: (Nothing) ⇒ M)(implicit M: Monoid[M]): Process[Nothing, M]

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

Definition Classes
Process1Ops
def fold1Monoid[O2 >: Nothing](implicit M: Monoid[O2]): Process[Nothing, O2]

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

Definition Classes
Process1Ops
def foldMap[M](f: (Nothing) ⇒ M)(implicit M: Monoid[M]): Process[Nothing, M]

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

Definition Classes
Process1Ops
def foldMonoid[O2 >: Nothing](implicit M: Monoid[O2]): Process[Nothing, O2]

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

Definition Classes
Process1Ops
def foldSemigroup[O2 >: Nothing](implicit M: Semigroup[O2]): Process[Nothing, O2]

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

Definition Classes
Process1Ops
def forall(f: (Nothing) ⇒ Boolean): Process[Nothing, Boolean]

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

Definition Classes
Process1Ops
def formatted(fmtstr: String): String

Implicit information
This member is added by an implicit conversion from Halt to StringFormat[Halt] performed by method StringFormat in scala.Predef.
Definition Classes
StringFormat
Annotations
@inline()
def gather(bufSize: Int)(implicit F: Nondeterminism[F]): Process[F, O]

Read chunks of bufSize from input, then use Nondeterminism.gatherUnordered to run all these actions to completion.
Read chunks of bufSize from input, then use Nondeterminism.gatherUnordered to run all these actions to completion.

Implicit information
This member is added by an implicit conversion from Halt to EvalProcess[F, O] performed by method EvalProcess in scalaz.stream.Process.
Definition Classes
EvalProcess
def gather(bufSize: Int)(implicit F: Nondeterminism[F]): Process[F, O]

Read chunks of bufSize from input, then use Nondeterminism.gatherUnordered to run all these actions to completion.
Read chunks of bufSize from input, then use Nondeterminism.gatherUnordered to run all these actions to completion.

Implicit information
This member is added by an implicit conversion from Halt to EvalProcess[F, O] performed by method EvalProcess in scalaz.stream.Process.
Definition Classes
EvalProcess
def gatherMap[F2[x] >: Nothing, O2](bufSize: Int)(f: (Nothing) ⇒ 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.
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.

Definition Classes
Process
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def handle[F2[x] >: Nothing, 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.
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.

Definition Classes
Process
def interleave[F2[x] >: Nothing, O2 >: Nothing](p2: Process[F2, O2]): Process[F2, O2]

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

Definition Classes
TeeOps
def intersperse[O2 >: Nothing](sep: O2): Process[Nothing, O2]

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

Definition Classes
Process1Ops
final def isHalt: Boolean

Returns true, if this process is halted
Returns true, if this process is halted

Definition Classes
Process
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
final def kill: Process[Nothing, Nothing]

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

Definition Classes
Process
def last: Process[Nothing, Nothing]

Alias for this |> process1.last.
Alias for this |> process1.last.

Definition Classes
Process1Ops
def lastOr[O2 >: Nothing](o: ⇒ O2): Process[Nothing, O2]

Alias for this |> process1.last.
Alias for this |> process1.last.

Definition Classes
Process1Ops
final def map[O2](f: (Nothing) ⇒ O2): Process[Nothing, O2]

Transforms the output values of this Process using f.
Transforms the output values of this Process using f.

Definition Classes
Process
def mapAccumulate[S, B](s: S)(f: (S, Nothing) ⇒ (S, B)): Process[Nothing, (S, B)]

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

Definition Classes
Process1Ops
def mapO[B](f: (O) ⇒ B): Writer[F, W, B]

Map over the output side of this Writer.
Map over the output side of this Writer.

Implicit information
This member is added by an implicit conversion from Halt to WriterSyntax[F, W, O] performed by method toWriterSyntax in scalaz.stream.Process.
Definition Classes
WriterSyntax
def mapO[B](f: (O) ⇒ B): Writer[F, W, B]

Map over the output side of this Writer.
Map over the output side of this Writer.

Implicit information
This member is added by an implicit conversion from Halt to WriterSyntax[F, W, O] performed by method toWriterSyntax in scalaz.stream.Process.
Definition Classes
WriterSyntax
def mapOut[O2](f: (O) ⇒ O2)(implicit F: Functor[F]): Channel[F, Any, O2]

Transform the output of this Channel
Transform the output of this Channel

Implicit information
This member is added by an implicit conversion from Halt to ChannelSyntax[F, Any, O] performed by method toChannelSyntax in scalaz.stream.Process.
Definition Classes
ChannelSyntax
def mapOut[O2](f: (O) ⇒ O2)(implicit F: Functor[F]): Channel[F, Any, O2]

Transform the output of this Channel
Transform the output of this Channel

Implicit information
This member is added by an implicit conversion from Halt to ChannelSyntax[F, Any, O] performed by method toChannelSyntax in scalaz.stream.Process.
Definition Classes
ChannelSyntax
def mapW[W2](f: (W) ⇒ W2): Writer[F, W2, O]

Map over the write side of this Writer.
Map over the write side of this Writer.

Implicit information
This member is added by an implicit conversion from Halt to WriterSyntax[F, W, O] performed by method toWriterSyntax in scalaz.stream.Process.
Definition Classes
WriterSyntax
def mapW[W2](f: (W) ⇒ W2): Writer[F, W2, O]

Map over the write side of this Writer.
Map over the write side of this Writer.

Implicit information
This member is added by an implicit conversion from Halt to WriterSyntax[F, W, O] performed by method toWriterSyntax in scalaz.stream.Process.
Definition Classes
WriterSyntax
def maximum[O2 >: Nothing](implicit O2: Order[O2]): Process[Nothing, O2]

Alias for this |> process1.maximum.
Alias for this |> process1.maximum.

Definition Classes
Process1Ops
def maximumBy[B](f: (Nothing) ⇒ B)(implicit arg0: Order[B]): Process[Nothing, Nothing]

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

Definition Classes
Process1Ops
def maximumOf[B](f: (Nothing) ⇒ B)(implicit arg0: Order[B]): Process[Nothing, B]

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

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

Non-deterministic interleave of both streams.
Non-deterministic interleave of both streams. Emits values whenever either is defined. Note this terminates after BOTH sides terminate

Implicit information
This member is added by an implicit conversion from Halt to SourceSyntax[O] performed by method SourceSyntax in scalaz.stream.Process.
Definition Classes
WyeOps
def merge[O2 >: O](p2: Process[Task, O2])(implicit S: Strategy): Process[Task, O2]

Non-deterministic interleave of both streams.
Non-deterministic interleave of both streams. Emits values whenever either is defined. Note this terminates after BOTH sides terminate

Implicit information
This member is added by an implicit conversion from Halt to SourceSyntax[O] performed by method SourceSyntax in scalaz.stream.Process.
Definition Classes
WyeOps
def minimum[O2 >: Nothing](implicit O2: Order[O2]): Process[Nothing, O2]

Alias for this |> process1.minimum.
Alias for this |> process1.minimum.

Definition Classes
Process1Ops
def minimumBy[B](f: (Nothing) ⇒ B)(implicit arg0: Order[B]): Process[Nothing, Nothing]

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

Definition Classes
Process1Ops
def minimumOf[B](f: (Nothing) ⇒ B)(implicit arg0: Order[B]): Process[Nothing, B]

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

Definition Classes
Process1Ops
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def observe[F2[x] >: F[x]](f: Sink[F2, O]): Process[F2, O]

Attach a Sink to the output of this Process but echo the original.
Attach a Sink to the output of this Process but echo the original.

Implicit information
This member is added by an implicit conversion from Halt to ProcessSyntax[F, O] performed by method ProcessSyntax in scalaz.stream.Process.
Definition Classes
ProcessSyntax
def observe[F2[x] >: F[x]](f: Sink[F2, O]): Process[F2, O]

Attach a Sink to the output of this Process but echo the original.
Attach a Sink to the output of this Process but echo the original.

Implicit information
This member is added by an implicit conversion from Halt to ProcessSyntax[F, O] performed by method ProcessSyntax in scalaz.stream.Process.
Definition Classes
ProcessSyntax
def observeO(snk: Sink[F, O]): Writer[F, W, O]

Observe the output side of this Writer using the given Sink, keeping it available for subsequent processing.
Observe the output side of this Writer using the given Sink, keeping it available for subsequent processing. Also see drainO.

Implicit information
This member is added by an implicit conversion from Halt to WriterSyntax[F, W, O] performed by method toWriterSyntax in scalaz.stream.Process.
Definition Classes
WriterSyntax
def observeO(snk: Sink[F, O]): Writer[F, W, O]

Observe the output side of this Writer using the given Sink, keeping it available for subsequent processing.
Observe the output side of this Writer using the given Sink, keeping it available for subsequent processing. Also see drainO.

Implicit information
This member is added by an implicit conversion from Halt to WriterSyntax[F, W, O] performed by method toWriterSyntax in scalaz.stream.Process.
Definition Classes
WriterSyntax
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.
Returns result of channel evaluation on O side tupled with original output value passed to channel.

Implicit information
This member is added by an implicit conversion from Halt to WriterTaskSyntax[W, O] performed by method toWriterTaskSyntax in scalaz.stream.Process.
Definition Classes
WriterTaskSyntax
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.
Returns result of channel evaluation on O side tupled with original output value passed to channel.

Implicit information
This member is added by an implicit conversion from Halt to WriterTaskSyntax[W, O] performed by method toWriterTaskSyntax in scalaz.stream.Process.
Definition Classes
WriterTaskSyntax
def observeThrough[O2](ch: Channel[Task, O, O2]): Process[Task, (O, O2)]

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

Implicit information
This member is added by an implicit conversion from Halt to SourceSyntax[O] performed by method SourceSyntax in scalaz.stream.Process.
Definition Classes
SourceSyntax
def observeThrough[O2](ch: Channel[Task, O, O2]): Process[Task, (O, O2)]

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

Implicit information
This member is added by an implicit conversion from Halt to SourceSyntax[O] performed by method SourceSyntax in scalaz.stream.Process.
Definition Classes
SourceSyntax
def observeW(snk: Sink[F, W]): Writer[F, W, O]

Observe the write side of this Writer using the given Sink, keeping it available for subsequent processing.
Observe the write side of this Writer using the given Sink, keeping it available for subsequent processing. Also see drainW.

Implicit information
This member is added by an implicit conversion from Halt to WriterSyntax[F, W, O] performed by method toWriterSyntax in scalaz.stream.Process.
Definition Classes
WriterSyntax
def observeW(snk: Sink[F, W]): Writer[F, W, O]

Observe the write side of this Writer using the given Sink, keeping it available for subsequent processing.
Observe the write side of this Writer using the given Sink, keeping it available for subsequent processing. Also see drainW.

Implicit information
This member is added by an implicit conversion from Halt to WriterSyntax[F, W, O] performed by method toWriterSyntax in scalaz.stream.Process.
Definition Classes
WriterSyntax
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.
Returns result of channel evaluation on W side tupled with original write value passed to channel.

Implicit information
This member is added by an implicit conversion from Halt to WriterTaskSyntax[W, O] performed by method toWriterTaskSyntax in scalaz.stream.Process.
Definition Classes
WriterTaskSyntax
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.
Returns result of channel evaluation on W side tupled with original write value passed to channel.

Implicit information
This member is added by an implicit conversion from Halt to WriterTaskSyntax[W, O] performed by method toWriterTaskSyntax in scalaz.stream.Process.
Definition Classes
WriterTaskSyntax
final def onComplete[F2[x] >: Nothing, O2 >: Nothing](p2: ⇒ Process[F2, O2]): Process[F2, O2]

Run p2 after this Process completes normally, or in the event of an error.
Run p2 after this Process completes normally, or in the event of an error. This behaves almost identically to append, except that p1 append p2 will not run p2 if p1 halts with an Error or is killed. Any errors raised by this are reraised after p2 completes.
Note that p2 is made into a finalizer using asFinalizer, so we can be assured it is run even when this Process is being killed by a downstream consumer.

Definition Classes
Process
final def onFailure[F2[x] >: Nothing, O2 >: Nothing](f: (Throwable) ⇒ Process[F2, O2]): Process[F2, O2]

If this Process completes with an error, call f to produce the next state.
If this Process completes with an error, call f to produce the next state. f is responsible for reraising the error if that is the desired behavior. Since this function is often used for attaching resource deallocation logic, the result of f is made into a finalizer using asFinalizer, so we can be assured it is run even when this Process is being killed by a downstream consumer.

Definition Classes
Process
final def onHalt[F2[x] >: Nothing, O2 >: Nothing](f: (Cause) ⇒ Process[F2, O2]): Process[F2, O2]

When this Process halts, call f to produce the next state.
When this Process halts, call f to produce the next state. Note that this function may be used to swallow or handle errors.

Definition Classes
Process
final def onKill[F2[x] >: Nothing, O2 >: Nothing](p: ⇒ Process[F2, O2]): Process[F2, O2]

Attach supplied process only if process has been killed.
Attach supplied process only if process has been killed. Since this function is often used for attaching resource deallocation logic, the result of f is made into a finalizer using asFinalizer, so we can be assured it is run even when this Process is being killed by a downstream consumer.

Definition Classes
Process
def once: Process[Nothing, Nothing]

Alias for this |> Process.await1.
Alias for this |> Process.await1.

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

Like attempt, but accepts a partial function.
Like attempt, but accepts a partial function. Unhandled errors are rethrown.

Definition Classes
Process
final def pipe[O2](p1: Process1[Nothing, O2]): Process[Nothing, O2]

Feed the output of this Process as input of p1.
Feed the output of this Process as input of p1. The implementation will fuse the two processes, so this process will only generate values as they are demanded by p1. If p1 signals termination, this is killed with same reason giving it an opportunity to cleanup.

Definition Classes
Process
def pipeO[B](f: Process1[O, B]): Writer[F, W, B]

Pipe output side of this Writer
Pipe output side of this Writer

Implicit information
This member is added by an implicit conversion from Halt to WriterSyntax[F, W, O] performed by method toWriterSyntax in scalaz.stream.Process.
Definition Classes
WriterSyntax
def pipeO[B](f: Process1[O, B]): Writer[F, W, B]

Pipe output side of this Writer
Pipe output side of this Writer

Implicit information
This member is added by an implicit conversion from Halt to WriterSyntax[F, W, O] performed by method toWriterSyntax in scalaz.stream.Process.
Definition Classes
WriterSyntax
def pipeW[B](f: Process1[W, B]): Writer[F, B, O]

Pipe write side of this Writer
Pipe write side of this Writer

Implicit information
This member is added by an implicit conversion from Halt to WriterSyntax[F, W, O] performed by method toWriterSyntax in scalaz.stream.Process.
Definition Classes
WriterSyntax
def pipeW[B](f: Process1[W, B]): Writer[F, B, O]

Pipe write side of this Writer
Pipe write side of this Writer

Implicit information
This member is added by an implicit conversion from Halt to WriterSyntax[F, W, O] performed by method toWriterSyntax in scalaz.stream.Process.
Definition Classes
WriterSyntax
def prefixSums[O2 >: Nothing](implicit N: Numeric[O2]): Process[Nothing, O2]

Alias for this |> process1.prefixSums
Alias for this |> process1.prefixSums

Definition Classes
Process1Ops
def prepend[O2 >: Nothing](os: Seq[O2]): Process[Nothing, O2]

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

Definition Classes
Process
def reduce[O2 >: Nothing](f: (O2, O2) ⇒ O2): Process[Nothing, O2]

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

Definition Classes
Process1Ops
def reduceMap[M](f: (Nothing) ⇒ M)(implicit M: Semigroup[M]): Process[Nothing, M]

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

Definition Classes
Process1Ops
def reduceMonoid[O2 >: Nothing](implicit M: Monoid[O2]): Process[Nothing, O2]

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

Definition Classes
Process1Ops
def reduceSemigroup[O2 >: Nothing](implicit M: Semigroup[O2]): Process[Nothing, O2]

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

Definition Classes
Process1Ops
def repartition[O2 >: Nothing](p: (O2) ⇒ IndexedSeq[O2])(implicit S: Semigroup[O2]): Process[Nothing, O2]

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

Definition Classes
Process1Ops
def repartition2[O2 >: Nothing](p: (O2) ⇒ (Option[O2], Option[O2]))(implicit S: Semigroup[O2]): Process[Nothing, O2]

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

Definition Classes
Process1Ops
final def repeat: Process[Nothing, Nothing]

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

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

Run this Process, purely for its effects.
Run this Process, purely for its effects.

Definition Classes
Process
final def runFoldMap[F2[x] >: Nothing, B](f: (Nothing) ⇒ 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.
Collect the outputs of this Process[F,O] into a Monoid B, given a Monad[F] in which we can catch exceptions. This function is not tail recursive and relies on the Monad[F] to ensure stack safety.

Definition Classes
Process
final def runLast[F2[x] >: Nothing, O2 >: Nothing](implicit F: Monad[F2], C: Catchable[F2]): F2[Option[O2]]

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

Definition Classes
Process
final def runLastOr[F2[x] >: Nothing, O2 >: Nothing](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.
Run this Process solely for its final emitted value, if one exists, using o2 otherwise.

Definition Classes
Process
final def runLog[F2[x] >: Nothing, O2 >: Nothing](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.
Collect the outputs of this Process[F,O], given a Monad[F] in which we can catch exceptions. This function is not tail recursive and relies on the Monad[F] to ensure stack safety.

Definition Classes
Process
def scan[B](b: B)(f: (B, Nothing) ⇒ B): Process[Nothing, B]

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

Definition Classes
Process1Ops
def scan1[O2 >: Nothing](f: (O2, O2) ⇒ O2): Process[Nothing, O2]

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

Definition Classes
Process1Ops
def scan1Map[M](f: (Nothing) ⇒ M)(implicit M: Semigroup[M]): Process[Nothing, M]

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

Definition Classes
Process1Ops
def scan1Monoid[O2 >: Nothing](implicit M: Monoid[O2]): Process[Nothing, O2]

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

Definition Classes
Process1Ops
def scanMap[M](f: (Nothing) ⇒ M)(implicit M: Monoid[M]): Process[Nothing, M]

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

Definition Classes
Process1Ops
def scanMonoid[O2 >: Nothing](implicit M: Monoid[O2]): Process[Nothing, O2]

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

Definition Classes
Process1Ops
def scanSemigroup[O2 >: Nothing](implicit M: Semigroup[O2]): Process[Nothing, O2]

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

Definition Classes
Process1Ops
def sequence(bufSize: Int)(implicit F: Nondeterminism[F]): Process[F, O]

Read chunks of bufSize from input, then use Nondeterminism.gather to run all these actions to completion and return elements in order.
Read chunks of bufSize from input, then use Nondeterminism.gather to run all these actions to completion and return elements in order.

Implicit information
This member is added by an implicit conversion from Halt to EvalProcess[F, O] performed by method EvalProcess in scalaz.stream.Process.
Definition Classes
EvalProcess
def sequence(bufSize: Int)(implicit F: Nondeterminism[F]): Process[F, O]

Read chunks of bufSize from input, then use Nondeterminism.gather to run all these actions to completion and return elements in order.
Read chunks of bufSize from input, then use Nondeterminism.gather to run all these actions to completion and return elements in order.

Implicit information
This member is added by an implicit conversion from Halt to EvalProcess[F, O] performed by method EvalProcess in scalaz.stream.Process.
Definition Classes
EvalProcess
def shiftRight[O2 >: Nothing](head: O2*): Process[Nothing, O2]

Alias for this |> process1.shiftRight(head)
Alias for this |> process1.shiftRight(head)

Definition Classes
Process1Ops
def sleepUntil[F2[x] >: Nothing, O2 >: Nothing](awaken: Process[F2, Boolean]): Process[F2, O2]

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

Definition Classes
TeeOps
def sliding(n: Int): Process[Nothing, Vector[Nothing]]

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

Definition Classes
Process1Ops
def split(f: (Nothing) ⇒ Boolean): Process[Nothing, Vector[Nothing]]

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

Definition Classes
Process1Ops
def splitOn[P >: Nothing](p: P)(implicit P: Equal[P]): Process[Nothing, Vector[P]]

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

Definition Classes
Process1Ops
def splitWith(f: (Nothing) ⇒ Boolean): Process[Nothing, Vector[Nothing]]

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

Definition Classes
Process1Ops
def stateScan[S, B](init: S)(f: (Nothing) ⇒ State[S, B]): Process[Nothing, B]

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

Definition Classes
Process1Ops
final def step: HaltOrStep[Nothing, Nothing]

Run one step of an incremental traversal of this Process.
Run one step of an incremental traversal of this Process. This function is mostly intended for internal use. As it allows a Process to be observed and captured during its execution, users are responsible for ensuring resource safety.

Definition Classes
Process
def sum[O2 >: Nothing](implicit N: Numeric[O2]): Process[Nothing, O2]

Alias for this |> process1.sum
Alias for this |> process1.sum

Definition Classes
Process1Ops
final def suspendStep: Process0[HaltOrStep[Nothing, Nothing]]

p.suspendStep propagates exceptions to p.
p.suspendStep propagates exceptions to p.

Definition Classes
Process
final def swallowKill: Process[Nothing, Nothing]

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

Definition Classes
Process
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def tail: Process[Nothing, Nothing]

Alias for this |> process1.tail.
Alias for this |> process1.tail.

Definition Classes
Process1Ops
def take(n: Int): Process[Nothing, Nothing]

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

Definition Classes
Process1Ops
def takeRight(n: Int): Process[Nothing, Nothing]

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

Definition Classes
Process1Ops
def takeThrough(f: (Nothing) ⇒ Boolean): Process[Nothing, Nothing]

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

Definition Classes
Process1Ops
def takeWhile(f: (Nothing) ⇒ Boolean): Process[Nothing, Nothing]

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

Definition Classes
Process1Ops
final def tee[F2[x] >: Nothing, O2, O3](p2: Process[F2, O2])(t: Tee[Nothing, O2, O3]): Process[F2, O3]

Use a Tee to interleave or combine the outputs of this and p2.
Use a Tee to interleave or combine the outputs of this and p2. This can be used for zipping, interleaving, and so forth. Nothing requires that the Tee read elements from each Process in lockstep. It could read fifty elements from one side, then two elements from the other, then combine or interleave these values in some way, etc.
If at any point the Tee awaits on a side that has halted, we gracefully kill off the other side, then halt.
If at any point t terminates with cause c, both sides are killed, and the resulting Process terminates with c.

Definition Classes
Process
def terminated: Process[Nothing, Option[Nothing]]

Alias for this |> process1.terminated.
Alias for this |> process1.terminated.

Definition Classes
Process1Ops
def through[F2[x] >: F[x], O2](f: Channel[F2, O, O2]): Process[F2, O2]

Feed this Process through the given effectful Channel.
Feed this Process through the given effectful Channel.

Implicit information
This member is added by an implicit conversion from Halt to ProcessSyntax[F, O] performed by method ProcessSyntax in scalaz.stream.Process.
Definition Classes
ProcessSyntax
def through[F2[x] >: F[x], O2](f: Channel[F2, O, O2]): Process[F2, O2]

Feed this Process through the given effectful Channel.
Feed this Process through the given effectful Channel.

Implicit information
This member is added by an implicit conversion from Halt to ProcessSyntax[F, O] performed by method ProcessSyntax in scalaz.stream.Process.
Definition Classes
ProcessSyntax
def throughO[O2](ch: Channel[Task, O, O2]): Writer[Task, W, O2]

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

Implicit information
This member is added by an implicit conversion from Halt to WriterTaskSyntax[W, O] performed by method toWriterTaskSyntax in scalaz.stream.Process.
Definition Classes
WriterTaskSyntax
def throughO[O2](ch: Channel[Task, O, O2]): Writer[Task, W, O2]

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

Implicit information
This member is added by an implicit conversion from Halt to WriterTaskSyntax[W, O] performed by method toWriterTaskSyntax in scalaz.stream.Process.
Definition Classes
WriterTaskSyntax
def throughOption[F2[x] >: F[x], O2](f: Channel[F2, Option[O], O2]): Process[F2, O2]

Feed this Process through the given effectful Channel, signaling termination to f via None.
Feed this Process through the given effectful Channel, signaling termination to f via None. Useful to allow f to flush any buffered values to the output when it detects termination, see scalaz.stream.io.bufferedChannel combinator.

Implicit information
This member is added by an implicit conversion from Halt to ProcessSyntax[F, O] performed by method ProcessSyntax in scalaz.stream.Process.
Definition Classes
ProcessSyntax
def throughOption[F2[x] >: F[x], O2](f: Channel[F2, Option[O], O2]): Process[F2, O2]

Feed this Process through the given effectful Channel, signaling termination to f via None.
Feed this Process through the given effectful Channel, signaling termination to f via None. Useful to allow f to flush any buffered values to the output when it detects termination, see scalaz.stream.io.bufferedChannel combinator.

Implicit information
This member is added by an implicit conversion from Halt to ProcessSyntax[F, O] performed by method ProcessSyntax in scalaz.stream.Process.
Definition Classes
ProcessSyntax
def throughW[W2](ch: Channel[Task, W, W2]): Writer[Task, W2, O]

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

Implicit information
This member is added by an implicit conversion from Halt to WriterTaskSyntax[W, O] performed by method toWriterTaskSyntax in scalaz.stream.Process.
Definition Classes
WriterTaskSyntax
def throughW[W2](ch: Channel[Task, W, W2]): Writer[Task, W2, O]

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

Implicit information
This member is added by an implicit conversion from Halt to WriterTaskSyntax[W, O] performed by method toWriterTaskSyntax in scalaz.stream.Process.
Definition Classes
WriterTaskSyntax
def to[F2[x] >: F[x]](f: Sink[F2, O]): Process[F2, Unit]

Attaches Sink to this Process
Attaches Sink to this Process

Implicit information
This member is added by an implicit conversion from Halt to ProcessSyntax[F, O] performed by method ProcessSyntax in scalaz.stream.Process.
Definition Classes
ProcessSyntax
def to[F2[x] >: F[x]](f: Sink[F2, O]): Process[F2, Unit]

Attaches Sink to this Process
Attaches Sink to this Process

Implicit information
This member is added by an implicit conversion from Halt to ProcessSyntax[F, O] performed by method ProcessSyntax in scalaz.stream.Process.
Definition Classes
ProcessSyntax
def toChannel(implicit F: Functor[F]): Channel[F, Any, Any]

Converts Sink to Channel, that will perform the side effect and echo its input.
Converts Sink to Channel, that will perform the side effect and echo its input.

Implicit information
This member is added by an implicit conversion from Halt to SinkSyntax[F, Any] performed by method toSinkSyntax in scalaz.stream.Process.
Definition Classes
SinkSyntax
def toChannel(implicit F: Functor[F]): Channel[F, Any, Any]

Converts Sink to Channel, that will perform the side effect and echo its input.
Converts Sink to Channel, that will perform the side effect and echo its input.

Implicit information
This member is added by an implicit conversion from Halt to SinkSyntax[F, Any] performed by method toSinkSyntax in scalaz.stream.Process.
Definition Classes
SinkSyntax
def toMap[K, V](implicit isKV: <:<[O, (K, V)]): Map[K, V]

Converts this Process0 to a Map.
Converts this Process0 to a Map.

Implicit information
This member is added by an implicit conversion from Halt to Process0Syntax[O] performed by method Process0Syntax in scalaz.stream.Process.
Definition Classes
Process0Syntax
def toMap[K, V](implicit isKV: <:<[O, (K, V)]): Map[K, V]

Converts this Process0 to a Map.
Converts this Process0 to a Map.

Implicit information
This member is added by an implicit conversion from Halt to Process0Syntax[O] performed by method Process0Syntax in scalaz.stream.Process.
Definition Classes
Process0Syntax
def toSortedMap[K, V](implicit isKV: <:<[O, (K, V)], ord: scala.Ordering[K]): SortedMap[K, V]

Converts this Process0 to a SortedMap.
Converts this Process0 to a SortedMap.

Implicit information
This member is added by an implicit conversion from Halt to Process0Syntax[O] performed by method Process0Syntax in scalaz.stream.Process.
Definition Classes
Process0Syntax
def toSortedMap[K, V](implicit isKV: <:<[O, (K, V)], ord: scala.Ordering[K]): SortedMap[K, V]

Converts this Process0 to a SortedMap.
Converts this Process0 to a SortedMap.

Implicit information
This member is added by an implicit conversion from Halt to Process0Syntax[O] performed by method Process0Syntax in scalaz.stream.Process.
Definition Classes
Process0Syntax
def translate[G[_]](f: ~>[Nothing, G]): Process[G, Nothing]

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

Definition Classes
Process
final def trim: Process[Nothing, Nothing]

Remove any leading emitted values from this Process.
Remove any leading emitted values from this Process.

Definition Classes
Process
Annotations
@tailrec()
final def uncons[F2[x] >: Nothing, O2 >: Nothing](implicit F: Monad[F2], C: Catchable[F2]): F2[(O2, Process[F2, O2])]

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

Definition Classes
Process
final def unemit: (Seq[Nothing], Process[Nothing, Nothing])

Removes all emitted elements from the front of this Process.
Removes all emitted elements from the front of this Process. The second argument returned by this method is guaranteed to be an Await, Halt or an Append-- if there are multiple Emit's at the front of this process, the sequences are concatenated together.
If this Process does not begin with an Emit, returns the empty sequence along with this.

Definition Classes
Process
def until[F2[x] >: Nothing, O2 >: Nothing](condition: Process[F2, Boolean]): Process[F2, O2]

Halts this Process as soon as condition becomes true.
Halts this Process as soon as condition becomes true. Note that condition is checked before each and every read from this, so condition should return very quickly or be continuous to avoid holding up the output Process. Use condition.forwardFill to convert an infrequent discrete Process to a continuous one for use with this function.

Definition Classes
TeeOps
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
def when[F2[x] >: Nothing, O2 >: Nothing](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.
When condition is true, lets through any values in this process, otherwise blocks until condition becomes true again. Note that the condition is checked before each and every read from this, so condition should return very quickly or be continuous to avoid holding up the output Process. Use condition.forwardFill to convert an infrequent discrete Process to a continuous one for use with this function.

Definition Classes
TeeOps
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.
Like tee, but we allow the Wye to read non-deterministically from both sides at once.
If y is in the state of awaiting Both, this implementation will continue feeding y from either left or right side, until either it halts or _both_ sides halt.
If y is in the state of awaiting L, and the left input has halted, we halt. Likewise for the right side.
For as long as y permits it, this implementation will _always_ feed it any leading Emit elements from either side before issuing new F requests. More sophisticated chunking and fairness policies do not belong here, but should be built into the Wye and/or its inputs.
The strategy passed in must be stack-safe, otherwise this implementation will throw SOE. Preferably use one of the Strategys.Executor(es) based strategies

Implicit information
This member is added by an implicit conversion from Halt to SourceSyntax[O] performed by method SourceSyntax in scalaz.stream.Process.
Definition Classes
WyeOps
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.
Like tee, but we allow the Wye to read non-deterministically from both sides at once.
If y is in the state of awaiting Both, this implementation will continue feeding y from either left or right side, until either it halts or _both_ sides halt.
If y is in the state of awaiting L, and the left input has halted, we halt. Likewise for the right side.
For as long as y permits it, this implementation will _always_ feed it any leading Emit elements from either side before issuing new F requests. More sophisticated chunking and fairness policies do not belong here, but should be built into the Wye and/or its inputs.
The strategy passed in must be stack-safe, otherwise this implementation will throw SOE. Preferably use one of the Strategys.Executor(es) based strategies

Implicit information
This member is added by an implicit conversion from Halt to SourceSyntax[O] performed by method SourceSyntax in scalaz.stream.Process.
Definition Classes
WyeOps
def yipWith[O2, O3](p2: Process[Task, O2])(f: (O, O2) ⇒ O3)(implicit S: Strategy): Process[Task, O3]

Non-deterministic version of zipWith.
Non-deterministic version of zipWith. Note this terminates whenever one of streams terminate

Implicit information
This member is added by an implicit conversion from Halt to SourceSyntax[O] performed by method SourceSyntax in scalaz.stream.Process.
Definition Classes
WyeOps
def yipWith[O2, O3](p2: Process[Task, O2])(f: (O, O2) ⇒ O3)(implicit S: Strategy): Process[Task, O3]

Non-deterministic version of zipWith.
Non-deterministic version of zipWith. Note this terminates whenever one of streams terminate

Implicit information
This member is added by an implicit conversion from Halt to SourceSyntax[O] performed by method SourceSyntax in scalaz.stream.Process.
Definition Classes
WyeOps
def zip[F2[x] >: Nothing, O2](p2: Process[F2, O2]): Process[F2, (Nothing, O2)]

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

Definition Classes
TeeOps
def zipWith[F2[x] >: Nothing, O2, O3](p2: Process[F2, O2])(f: (Nothing, O2) ⇒ O3): Process[F2, O3]

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

Definition Classes
TeeOps
def zipWithIndex[N](implicit arg0: Numeric[N]): Process[Nothing, (Nothing, N)]

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

Definition Classes
Process1Ops
def zipWithIndex: Process[Nothing, (Nothing, Int)]

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

Definition Classes
Process1Ops
def zipWithNext: Process[Nothing, (Nothing, Option[Nothing])]

Alias for this |> process1.zipWithNext.
Alias for this |> process1.zipWithNext.

Definition Classes
Process1Ops
def zipWithPrevious: Process[Nothing, (Option[Nothing], Nothing)]

Alias for this |> process1.zipWithPrevious.
Alias for this |> process1.zipWithPrevious.

Definition Classes
Process1Ops
def zipWithPreviousAndNext: Process[Nothing, (Option[Nothing], Nothing, Option[Nothing])]

Alias for this |> process1.zipWithPreviousAndNext.
Alias for this |> process1.zipWithPreviousAndNext.

Definition Classes
Process1Ops
def zipWithScan[B](z: B)(next: (Nothing, B) ⇒ B): Process[Nothing, (Nothing, B)]

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

Definition Classes
Process1Ops
def zipWithScan1[B](z: B)(next: (Nothing, B) ⇒ B): Process[Nothing, (Nothing, B)]

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

Definition Classes
Process1Ops
def zipWithState[B](z: B)(next: (Nothing, B) ⇒ B): Process[Nothing, (Nothing, B)]

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

Definition Classes
Process1Ops
final def |>[O2](p2: Process1[Nothing, O2]): Process[Nothing, O2]

Operator alias for pipe.
Operator alias for pipe.

Definition Classes
Process
def →[B](y: B): (Halt, B)

Implicit information
This member is added by an implicit conversion from Halt to ArrowAssoc[Halt] performed by method ArrowAssoc in scala.Predef.
Definition Classes
ArrowAssoc

Shadowed Implicit Value Members

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

Apply this Process to an Iterable.
Apply this Process to an Iterable.
Implicit information
This member is added by an implicit conversion from Halt to Process1Syntax[Any, O] performed by method toProcess1Syntax in scalaz.stream.Process.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(halt: Process1Syntax[Any, O]).apply(input)
Definition Classes
Process1Syntax
def apply(input: Iterable[Any], input2: Iterable[Any]): IndexedSeq[O]

Apply a Wye to two Iterable inputs.
Apply a Wye to two Iterable inputs.
Implicit information
This member is added by an implicit conversion from Halt to WyeSyntax[Any, Any, O] performed by method toWyeSyntax in scalaz.stream.Process.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(halt: WyeSyntax[Any, Any, O]).apply(input, input2)
Definition Classes
WyeSyntax
def apply(input: Iterable[Any], input2: Iterable[Any]): IndexedSeq[O]

Apply a Wye to two Iterable inputs.
Apply a Wye to two Iterable inputs.
Implicit information
This member is added by an implicit conversion from Halt to WyeSyntax[Any, Any, O] performed by method toWyeSyntax in scalaz.stream.Process.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(halt: WyeSyntax[Any, Any, O]).apply(input, input2)
Definition Classes
WyeSyntax
def apply(input: Iterable[Any]): IndexedSeq[O]

Apply this Process to an Iterable.
Apply this Process to an Iterable.
Implicit information
This member is added by an implicit conversion from Halt to Process1Syntax[Any, O] performed by method toProcess1Syntax in scalaz.stream.Process.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(halt: Process1Syntax[Any, O]).apply(input)
Definition Classes
Process1Syntax
def attachL[I0](f: Process1[I0, Any]): Wye[I0, Any, O]

Transform the left input of the given Wye using a Process1.
Transform the left input of the given Wye using a Process1.
Implicit information
This member is added by an implicit conversion from Halt to WyeSyntax[Any, Any, O] performed by method toWyeSyntax in scalaz.stream.Process.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(halt: WyeSyntax[Any, Any, O]).attachL(f)
Definition Classes
WyeSyntax
def attachL[I0](f: Process1[I0, Any]): Wye[I0, Any, O]

Transform the left input of the given Wye using a Process1.
Transform the left input of the given Wye using a Process1.
Implicit information
This member is added by an implicit conversion from Halt to WyeSyntax[Any, Any, O] performed by method toWyeSyntax in scalaz.stream.Process.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(halt: WyeSyntax[Any, Any, O]).attachL(f)
Definition Classes
WyeSyntax
def attachR[I1](f: Process1[I1, Any]): Wye[Any, I1, O]

Transform the right input of the given Wye using a Process1.
Transform the right input of the given Wye using a Process1.
Implicit information
This member is added by an implicit conversion from Halt to WyeSyntax[Any, Any, O] performed by method toWyeSyntax in scalaz.stream.Process.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(halt: WyeSyntax[Any, Any, O]).attachR(f)
Definition Classes
WyeSyntax
def attachR[I1](f: Process1[I1, Any]): Wye[Any, I1, O]

Transform the right input of the given Wye using a Process1.
Transform the right input of the given Wye using a Process1.
Implicit information
This member is added by an implicit conversion from Halt to WyeSyntax[Any, Any, O] performed by method toWyeSyntax in scalaz.stream.Process.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(halt: WyeSyntax[Any, Any, O]).attachR(f)
Definition Classes
WyeSyntax
def contramap[I0](f: (I0) ⇒ Any): Process1[I0, O]

Transform the input of this Process1.
Transform the input of this Process1.
Implicit information
This member is added by an implicit conversion from Halt to Process1Syntax[Any, O] performed by method toProcess1Syntax in scalaz.stream.Process.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(halt: Process1Syntax[Any, O]).contramap(f)
Definition Classes
Process1Syntax
def contramap[I0](f: (I0) ⇒ Any): Channel[F, I0, O]

Transform the input of this Channel.
Transform the input of this Channel.
Implicit information
This member is added by an implicit conversion from Halt to ChannelSyntax[F, Any, O] performed by method toChannelSyntax in scalaz.stream.Process.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(halt: ChannelSyntax[F, Any, O]).contramap(f)
Definition Classes
ChannelSyntax
def contramap[I0](f: (I0) ⇒ Any): Process1[I0, O]

Transform the input of this Process1.
Transform the input of this Process1.
Implicit information
This member is added by an implicit conversion from Halt to Process1Syntax[Any, O] performed by method toProcess1Syntax in scalaz.stream.Process.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(halt: Process1Syntax[Any, O]).contramap(f)
Definition Classes
Process1Syntax
def contramap[I0](f: (I0) ⇒ Any): Channel[F, I0, O]

Transform the input of this Channel.
Transform the input of this Channel.
Implicit information
This member is added by an implicit conversion from Halt to ChannelSyntax[F, Any, O] performed by method toChannelSyntax in scalaz.stream.Process.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(halt: ChannelSyntax[F, Any, O]).contramap(f)
Definition Classes
ChannelSyntax
def contramapL[I0](f: (I0) ⇒ Any): Wye[I0, Any, O]

Transform the left input to a Wye.
Transform the left input to a Wye.
Implicit information
This member is added by an implicit conversion from Halt to WyeSyntax[Any, Any, O] performed by method toWyeSyntax in scalaz.stream.Process.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(halt: WyeSyntax[Any, Any, O]).contramapL(f)
Definition Classes
WyeSyntax
def contramapL[I0](f: (I0) ⇒ Any): Tee[I0, Any, O]

Transform the left input to a Tee.
Transform the left input to a Tee.
Implicit information
This member is added by an implicit conversion from Halt to TeeSyntax[Any, Any, O] performed by method toTeeSyntax in scalaz.stream.Process.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(halt: TeeSyntax[Any, Any, O]).contramapL(f)
Definition Classes
TeeSyntax
def contramapL[I0](f: (I0) ⇒ Any): Wye[I0, Any, O]

Transform the left input to a Wye.
Transform the left input to a Wye.
Implicit information
This member is added by an implicit conversion from Halt to WyeSyntax[Any, Any, O] performed by method toWyeSyntax in scalaz.stream.Process.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(halt: WyeSyntax[Any, Any, O]).contramapL(f)
Definition Classes
WyeSyntax
def contramapL[I0](f: (I0) ⇒ Any): Tee[I0, Any, O]

Transform the left input to a Tee.
Transform the left input to a Tee.
Implicit information
This member is added by an implicit conversion from Halt to TeeSyntax[Any, Any, O] performed by method toTeeSyntax in scalaz.stream.Process.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(halt: TeeSyntax[Any, Any, O]).contramapL(f)
Definition Classes
TeeSyntax
def contramapR[I3](f: (I3) ⇒ Any): Wye[Any, I3, O]

Transform the right input to a Wye.
Transform the right input to a Wye.
Implicit information
This member is added by an implicit conversion from Halt to WyeSyntax[Any, Any, O] performed by method toWyeSyntax in scalaz.stream.Process.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(halt: WyeSyntax[Any, Any, O]).contramapR(f)
Definition Classes
WyeSyntax
def contramapR[I3](f: (I3) ⇒ Any): Tee[Any, I3, O]

Transform the right input to a Tee.
Transform the right input to a Tee.
Implicit information
This member is added by an implicit conversion from Halt to TeeSyntax[Any, Any, O] performed by method toTeeSyntax in scalaz.stream.Process.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(halt: TeeSyntax[Any, Any, O]).contramapR(f)
Definition Classes
TeeSyntax
def contramapR[I3](f: (I3) ⇒ Any): Wye[Any, I3, O]

Transform the right input to a Wye.
Transform the right input to a Wye.
Implicit information
This member is added by an implicit conversion from Halt to WyeSyntax[Any, Any, O] performed by method toWyeSyntax in scalaz.stream.Process.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(halt: WyeSyntax[Any, Any, O]).contramapR(f)
Definition Classes
WyeSyntax
def contramapR[I3](f: (I3) ⇒ Any): Tee[Any, I3, O]

Transform the right input to a Tee.
Transform the right input to a Tee.
Implicit information
This member is added by an implicit conversion from Halt to TeeSyntax[Any, Any, O] performed by method toTeeSyntax in scalaz.stream.Process.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(halt: TeeSyntax[Any, Any, O]).contramapR(f)
Definition Classes
TeeSyntax
def detach1L: Wye[Any, Any, O]

Converting requests for the left input into normal termination.
Converting requests for the left input into normal termination. Note that Both requests are rewritten to fetch from the only input.
Implicit information
This member is added by an implicit conversion from Halt to WyeSyntax[Any, Any, O] performed by method toWyeSyntax in scalaz.stream.Process.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(halt: WyeSyntax[Any, Any, O]).detach1L
Definition Classes
WyeSyntax
def detach1L: Wye[Any, Any, O]

Converting requests for the left input into normal termination.
Converting requests for the left input into normal termination. Note that Both requests are rewritten to fetch from the only input.
Implicit information
This member is added by an implicit conversion from Halt to WyeSyntax[Any, Any, O] performed by method toWyeSyntax in scalaz.stream.Process.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(halt: WyeSyntax[Any, Any, O]).detach1L
Definition Classes
WyeSyntax
def detach1R: Wye[Any, Any, O]

Converting requests for the right input into normal termination.
Converting requests for the right input into normal termination. Note that Both requests are rewritten to fetch from the only input.
Implicit information
This member is added by an implicit conversion from Halt to WyeSyntax[Any, Any, O] performed by method toWyeSyntax in scalaz.stream.Process.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(halt: WyeSyntax[Any, Any, O]).detach1R
Definition Classes
WyeSyntax
def detach1R: Wye[Any, Any, O]

Converting requests for the right input into normal termination.
Converting requests for the right input into normal termination. Note that Both requests are rewritten to fetch from the only input.
Implicit information
This member is added by an implicit conversion from Halt to WyeSyntax[Any, Any, O] performed by method toWyeSyntax in scalaz.stream.Process.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(halt: WyeSyntax[Any, Any, O]).detach1R
Definition Classes
WyeSyntax
def drainO: Writer[F, W, Nothing]

Ignore the output side of this Writer.
Ignore the output side of this Writer.
Implicit information
This member is added by an implicit conversion from Halt to WriterSyntax[F, W, O] performed by method toWriterSyntax in scalaz.stream.Process.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(halt: WriterSyntax[F, W, O]).drainO
Definition Classes
WriterSyntax
def drainO: Writer[F, W, Nothing]

Ignore the output side of this Writer.
Ignore the output side of this Writer.
Implicit information
This member is added by an implicit conversion from Halt to WriterSyntax[F, W, O] performed by method toWriterSyntax in scalaz.stream.Process.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(halt: WriterSyntax[F, W, O]).drainO
Definition Classes
WriterSyntax
def drainW: Writer[F, Nothing, O]

Ignore the write side of this Writer.
Ignore the write side of this Writer.
Implicit information
This member is added by an implicit conversion from Halt to WriterSyntax[F, W, O] performed by method toWriterSyntax in scalaz.stream.Process.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(halt: WriterSyntax[F, W, O]).drainW
Definition Classes
WriterSyntax
def drainW: Writer[F, Nothing, O]

Ignore the write side of this Writer.
Ignore the write side of this Writer.
Implicit information
This member is added by an implicit conversion from Halt to WriterSyntax[F, W, O] performed by method toWriterSyntax in scalaz.stream.Process.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(halt: WriterSyntax[F, W, O]).drainW
Definition Classes
WriterSyntax
def eval: Process[F, O]

Evaluate the stream of F actions produced by this Process.
Evaluate the stream of F actions produced by this Process. This sequences F actions strictly--the first F action will be evaluated before work begins on producing the next F action. To allow for concurrent evaluation, use sequence or gather.
Implicit information
This member is added by an implicit conversion from Halt to EvalProcess[F, O] performed by method EvalProcess in scalaz.stream.Process.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(halt: EvalProcess[F, O]).eval
Definition Classes
EvalProcess
def eval: Process[F, O]

Evaluate the stream of F actions produced by this Process.
Evaluate the stream of F actions produced by this Process. This sequences F actions strictly--the first F action will be evaluated before work begins on producing the next F action. To allow for concurrent evaluation, use sequence or gather.
Implicit information
This member is added by an implicit conversion from Halt to EvalProcess[F, O] performed by method EvalProcess in scalaz.stream.Process.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(halt: EvalProcess[F, O]).eval
Definition Classes
EvalProcess
def feed1(i: Any): Process1[Any, O]

Feed a single input to this Process1.
Feed a single input to this Process1.
Implicit information
This member is added by an implicit conversion from Halt to Process1Syntax[Any, O] performed by method toProcess1Syntax in scalaz.stream.Process.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(halt: Process1Syntax[Any, O]).feed1(i)
Definition Classes
Process1Syntax
def feed1(i: Any): Process1[Any, O]

Feed a single input to this Process1.
Feed a single input to this Process1.
Implicit information
This member is added by an implicit conversion from Halt to Process1Syntax[Any, O] performed by method toProcess1Syntax in scalaz.stream.Process.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(halt: Process1Syntax[Any, O]).feed1(i)
Definition Classes
Process1Syntax
def forwardFill(implicit S: Strategy): Process[Task, O]

Produce a continuous stream from a discrete stream by using the most recent value.
Produce a continuous stream from a discrete stream by using the most recent value.
Implicit information
This member is added by an implicit conversion from Halt to SourceSyntax[O] performed by method SourceSyntax in scalaz.stream.Process.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(halt: SourceSyntax[O]).forwardFill(S)
Definition Classes
SourceSyntax
def forwardFill(implicit S: Strategy): Process[Task, O]

Produce a continuous stream from a discrete stream by using the most recent value.
Produce a continuous stream from a discrete stream by using the most recent value.
Implicit information
This member is added by an implicit conversion from Halt to SourceSyntax[O] performed by method SourceSyntax in scalaz.stream.Process.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(halt: SourceSyntax[O]).forwardFill(S)
Definition Classes
SourceSyntax
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.
Transform self to operate on the left hand side of an \/, passing through any values it receives on the right. Note that this halts whenever self halts.
Implicit information
This member is added by an implicit conversion from Halt to Process1Syntax[Any, O] performed by method toProcess1Syntax in scalaz.stream.Process.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(halt: Process1Syntax[Any, O]).liftL
Definition Classes
Process1Syntax
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.
Transform self to operate on the left hand side of an \/, passing through any values it receives on the right. Note that this halts whenever self halts.
Implicit information
This member is added by an implicit conversion from Halt to Process1Syntax[Any, O] performed by method toProcess1Syntax in scalaz.stream.Process.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(halt: Process1Syntax[Any, O]).liftL
Definition Classes
Process1Syntax
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.
Transform self to operate on the right hand side of an \/, passing through any values it receives on the left. Note that this halts whenever self halts.
Implicit information
This member is added by an implicit conversion from Halt to Process1Syntax[Any, O] performed by method toProcess1Syntax in scalaz.stream.Process.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(halt: Process1Syntax[Any, O]).liftR
Definition Classes
Process1Syntax
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.
Transform self to operate on the right hand side of an \/, passing through any values it receives on the left. Note that this halts whenever self halts.
Implicit information
This member is added by an implicit conversion from Halt to Process1Syntax[Any, O] performed by method toProcess1Syntax in scalaz.stream.Process.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(halt: Process1Syntax[Any, O]).liftR
Definition Classes
Process1Syntax
def pipeIn[I0](p1: Process1[I0, Any]): Sink[Task, I0]

converts sink to sink that first pipes received I0 to supplied p1
converts sink to sink that first pipes received I0 to supplied p1
Implicit information
This member is added by an implicit conversion from Halt to SinkTaskSyntax[Any] performed by method toSinkTaskSyntax in scalaz.stream.Process.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(halt: SinkTaskSyntax[Any]).pipeIn(p1)
Definition Classes
SinkTaskSyntax
def pipeIn[I0](p1: Process1[I0, Any]): Sink[Task, I0]

converts sink to sink that first pipes received I0 to supplied p1
converts sink to sink that first pipes received I0 to supplied p1
Implicit information
This member is added by an implicit conversion from Halt to SinkTaskSyntax[Any] performed by method toSinkTaskSyntax in scalaz.stream.Process.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(halt: SinkTaskSyntax[Any]).pipeIn(p1)
Definition Classes
SinkTaskSyntax
val self: Process[Task, O]
Implicit information
This member is added by an implicit conversion from Halt to SourceSyntax[O] performed by method SourceSyntax in scalaz.stream.Process.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(halt: SourceSyntax[O]).self
Definition Classes
SourceSyntax → WyeOps
val self: Process1[Any, O]
Implicit information
This member is added by an implicit conversion from Halt to Process1Syntax[Any, O] performed by method toProcess1Syntax in scalaz.stream.Process.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(halt: Process1Syntax[Any, O]).self
Definition Classes
Process1Syntax
val self: Process0[O]
Implicit information
This member is added by an implicit conversion from Halt to Process0Syntax[O] performed by method Process0Syntax in scalaz.stream.Process.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(halt: Process0Syntax[O]).self
Definition Classes
Process0Syntax
val self: Process[F, O]
Implicit information
This member is added by an implicit conversion from Halt to ProcessSyntax[F, O] performed by method ProcessSyntax in scalaz.stream.Process.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(halt: ProcessSyntax[F, O]).self
Definition Classes
ProcessSyntax
val self: Channel[F, Any, O]
Implicit information
This member is added by an implicit conversion from Halt to ChannelSyntax[F, Any, O] performed by method toChannelSyntax in scalaz.stream.Process.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(halt: ChannelSyntax[F, Any, O]).self
Definition Classes
ChannelSyntax
val self: Process[F, F[O]]
Implicit information
This member is added by an implicit conversion from Halt to EvalProcess[F, O] performed by method EvalProcess in scalaz.stream.Process.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(halt: EvalProcess[F, O]).self
Definition Classes
EvalProcess
val self: Wye[Any, Any, O]
Implicit information
This member is added by an implicit conversion from Halt to WyeSyntax[Any, Any, O] performed by method toWyeSyntax in scalaz.stream.Process.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(halt: WyeSyntax[Any, Any, O]).self
Definition Classes
WyeSyntax
val self: Writer[Task, W, O]
Implicit information
This member is added by an implicit conversion from Halt to WriterTaskSyntax[W, O] performed by method toWriterTaskSyntax in scalaz.stream.Process.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(halt: WriterTaskSyntax[W, O]).self
Definition Classes
WriterTaskSyntax
val self: Writer[F, W, O]
Implicit information
This member is added by an implicit conversion from Halt to WriterSyntax[F, W, O] performed by method toWriterSyntax in scalaz.stream.Process.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(halt: WriterSyntax[F, W, O]).self
Definition Classes
WriterSyntax
val self: Tee[Any, Any, O]
Implicit information
This member is added by an implicit conversion from Halt to TeeSyntax[Any, Any, O] performed by method toTeeSyntax in scalaz.stream.Process.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(halt: TeeSyntax[Any, Any, O]).self
Definition Classes
TeeSyntax
val self: Sink[Task, Any]
Implicit information
This member is added by an implicit conversion from Halt to SinkTaskSyntax[Any] performed by method toSinkTaskSyntax in scalaz.stream.Process.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(halt: SinkTaskSyntax[Any]).self
Definition Classes
SinkTaskSyntax
val self: Sink[F, Any]
Implicit information
This member is added by an implicit conversion from Halt to SinkSyntax[F, Any] performed by method toSinkSyntax in scalaz.stream.Process.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(halt: SinkSyntax[F, Any]).self
Definition Classes
SinkSyntax
val self: Process[Task, O]
Implicit information
This member is added by an implicit conversion from Halt to SourceSyntax[O] performed by method SourceSyntax in scalaz.stream.Process.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(halt: SourceSyntax[O]).self
Definition Classes
SourceSyntax → WyeOps
val self: Process0[O]
Implicit information
This member is added by an implicit conversion from Halt to Process0Syntax[O] performed by method Process0Syntax in scalaz.stream.Process.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(halt: Process0Syntax[O]).self
Definition Classes
Process0Syntax
val self: Process[F, F[O]]
Implicit information
This member is added by an implicit conversion from Halt to EvalProcess[F, O] performed by method EvalProcess in scalaz.stream.Process.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(halt: EvalProcess[F, O]).self
Definition Classes
EvalProcess
val self: Process[F, O]
Implicit information
This member is added by an implicit conversion from Halt to ProcessSyntax[F, O] performed by method ProcessSyntax in scalaz.stream.Process.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(halt: ProcessSyntax[F, O]).self
Definition Classes
ProcessSyntax
val self: Wye[Any, Any, O]
Implicit information
This member is added by an implicit conversion from Halt to WyeSyntax[Any, Any, O] performed by method toWyeSyntax in scalaz.stream.Process.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(halt: WyeSyntax[Any, Any, O]).self
Definition Classes
WyeSyntax
val self: Writer[Task, W, O]
Implicit information
This member is added by an implicit conversion from Halt to WriterTaskSyntax[W, O] performed by method toWriterTaskSyntax in scalaz.stream.Process.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(halt: WriterTaskSyntax[W, O]).self
Definition Classes
WriterTaskSyntax
val self: Writer[F, W, O]
Implicit information
This member is added by an implicit conversion from Halt to WriterSyntax[F, W, O] performed by method toWriterSyntax in scalaz.stream.Process.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(halt: WriterSyntax[F, W, O]).self
Definition Classes
WriterSyntax
val self: Tee[Any, Any, O]
Implicit information
This member is added by an implicit conversion from Halt to TeeSyntax[Any, Any, O] performed by method toTeeSyntax in scalaz.stream.Process.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(halt: TeeSyntax[Any, Any, O]).self
Definition Classes
TeeSyntax
val self: Sink[Task, Any]
Implicit information
This member is added by an implicit conversion from Halt to SinkTaskSyntax[Any] performed by method toSinkTaskSyntax in scalaz.stream.Process.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(halt: SinkTaskSyntax[Any]).self
Definition Classes
SinkTaskSyntax
val self: Sink[F, Any]
Implicit information
This member is added by an implicit conversion from Halt to SinkSyntax[F, Any] performed by method toSinkSyntax in scalaz.stream.Process.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(halt: SinkSyntax[F, Any]).self
Definition Classes
SinkSyntax
val self: Process1[Any, O]
Implicit information
This member is added by an implicit conversion from Halt to Process1Syntax[Any, O] performed by method toProcess1Syntax in scalaz.stream.Process.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(halt: Process1Syntax[Any, O]).self
Definition Classes
Process1Syntax
val self: Channel[F, Any, O]
Implicit information
This member is added by an implicit conversion from Halt to ChannelSyntax[F, Any, O] performed by method toChannelSyntax in scalaz.stream.Process.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(halt: ChannelSyntax[F, Any, O]).self
Definition Classes
ChannelSyntax
def stripO: Process[F, W]

Remove the output side of this Writer.
Remove the output side of this Writer.
Implicit information
This member is added by an implicit conversion from Halt to WriterSyntax[F, W, O] performed by method toWriterSyntax in scalaz.stream.Process.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(halt: WriterSyntax[F, W, O]).stripO
Definition Classes
WriterSyntax
def stripO: Process[F, W]

Remove the output side of this Writer.
Remove the output side of this Writer.
Implicit information
This member is added by an implicit conversion from Halt to WriterSyntax[F, W, O] performed by method toWriterSyntax in scalaz.stream.Process.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(halt: WriterSyntax[F, W, O]).stripO
Definition Classes
WriterSyntax
def stripW: Process[F, O]

Remove the write side of this Writer.
Remove the write side of this Writer.
Implicit information
This member is added by an implicit conversion from Halt to WriterSyntax[F, W, O] performed by method toWriterSyntax in scalaz.stream.Process.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(halt: WriterSyntax[F, W, O]).stripW
Definition Classes
WriterSyntax
def stripW: Process[F, O]

Remove the write side of this Writer.
Remove the write side of this Writer.
Implicit information
This member is added by an implicit conversion from Halt to WriterSyntax[F, W, O] performed by method toWriterSyntax in scalaz.stream.Process.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(halt: WriterSyntax[F, W, O]).stripW
Definition Classes
WriterSyntax
def toIndexedSeq: IndexedSeq[O]

Converts this Process0 to an IndexedSeq.
Converts this Process0 to an IndexedSeq.
Implicit information
This member is added by an implicit conversion from Halt to Process0Syntax[O] performed by method Process0Syntax in scalaz.stream.Process.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(halt: Process0Syntax[O]).toIndexedSeq
Definition Classes
Process0Syntax
def toIndexedSeq: IndexedSeq[O]

Converts this Process0 to an IndexedSeq.
Converts this Process0 to an IndexedSeq.
Implicit information
This member is added by an implicit conversion from Halt to Process0Syntax[O] performed by method Process0Syntax in scalaz.stream.Process.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(halt: Process0Syntax[O]).toIndexedSeq
Definition Classes
Process0Syntax
def toList: List[O]

Converts this Process0 to a List.
Converts this Process0 to a List.
Implicit information
This member is added by an implicit conversion from Halt to Process0Syntax[O] performed by method Process0Syntax in scalaz.stream.Process.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(halt: Process0Syntax[O]).toList
Definition Classes
Process0Syntax
def toList: List[O]

Converts this Process0 to a List.
Converts this Process0 to a List.
Implicit information
This member is added by an implicit conversion from Halt to Process0Syntax[O] performed by method Process0Syntax in scalaz.stream.Process.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(halt: Process0Syntax[O]).toList
Definition Classes
Process0Syntax
def toSeq: Seq[O]

Converts this Process0 to a Seq.
Converts this Process0 to a Seq.
Implicit information
This member is added by an implicit conversion from Halt to Process0Syntax[O] performed by method Process0Syntax in scalaz.stream.Process.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(halt: Process0Syntax[O]).toSeq
Definition Classes
Process0Syntax
def toSeq: Seq[O]

Converts this Process0 to a Seq.
Converts this Process0 to a Seq.
Implicit information
This member is added by an implicit conversion from Halt to Process0Syntax[O] performed by method Process0Syntax in scalaz.stream.Process.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(halt: Process0Syntax[O]).toSeq
Definition Classes
Process0Syntax
def toSignal(implicit S: Strategy): Signal[O]

converts process to signal *
converts process to signal *
Implicit information
This member is added by an implicit conversion from Halt to SourceSyntax[O] performed by method SourceSyntax in scalaz.stream.Process.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(halt: SourceSyntax[O]).toSignal(S)
Definition Classes
SourceSyntax
def toSignal(implicit S: Strategy): Signal[O]

converts process to signal *
converts process to signal *
Implicit information
This member is added by an implicit conversion from Halt to SourceSyntax[O] performed by method SourceSyntax in scalaz.stream.Process.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(halt: SourceSyntax[O]).toSignal(S)
Definition Classes
SourceSyntax
def toSource: Process[Task, O]
Implicit information
This member is added by an implicit conversion from Halt to Process0Syntax[O] performed by method Process0Syntax in scalaz.stream.Process.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(halt: Process0Syntax[O]).toSource
Definition Classes
Process0Syntax
def toSource: Process[Task, O]
Implicit information
This member is added by an implicit conversion from Halt to Process0Syntax[O] performed by method Process0Syntax in scalaz.stream.Process.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(halt: Process0Syntax[O]).toSource
Definition Classes
Process0Syntax
def toStream: Stream[O]

Converts this Process0 to a Stream.
Converts this Process0 to a Stream.
Implicit information
This member is added by an implicit conversion from Halt to Process0Syntax[O] performed by method Process0Syntax in scalaz.stream.Process.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(halt: Process0Syntax[O]).toStream
Definition Classes
Process0Syntax
def toStream: Stream[O]

Converts this Process0 to a Stream.
Converts this Process0 to a Stream.
Implicit information
This member is added by an implicit conversion from Halt to Process0Syntax[O] performed by method Process0Syntax in scalaz.stream.Process.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(halt: Process0Syntax[O]).toStream
Definition Classes
Process0Syntax
def toVector: Vector[O]

Converts this Process0 to a Vector.
Converts this Process0 to a Vector.
Implicit information
This member is added by an implicit conversion from Halt to Process0Syntax[O] performed by method Process0Syntax in scalaz.stream.Process.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(halt: Process0Syntax[O]).toVector
Definition Classes
Process0Syntax
def toVector: Vector[O]

Converts this Process0 to a Vector.
Converts this Process0 to a Vector.
Implicit information
This member is added by an implicit conversion from Halt to Process0Syntax[O] performed by method Process0Syntax in scalaz.stream.Process.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(halt: Process0Syntax[O]).toVector
Definition Classes
Process0Syntax
def yip[O2](p2: Process[Task, O2])(implicit S: Strategy): Process[Task, (O, O2)]

Non-deterministic version of zip.
Non-deterministic version of zip. Note this terminates whenever one of streams terminate
Implicit information
This member is added by an implicit conversion from Halt to SourceSyntax[O] performed by method SourceSyntax in scalaz.stream.Process.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(halt: SourceSyntax[O]).yip(p2)(S)
Definition Classes
WyeOps
def yip[O2](p2: Process[Task, O2])(implicit S: Strategy): Process[Task, (O, O2)]

Non-deterministic version of zip.
Non-deterministic version of zip. Note this terminates whenever one of streams terminate
Implicit information
This member is added by an implicit conversion from Halt to SourceSyntax[O] performed by method SourceSyntax in scalaz.stream.Process.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(halt: SourceSyntax[O]).yip(p2)(S)
Definition Classes
WyeOps

Deprecated Value Members

def liftIO: Process[Task, O]
Implicit information
This member is added by an implicit conversion from Halt to Process0Syntax[O] performed by method Process0Syntax in scalaz.stream.Process.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(halt: Process0Syntax[O]).liftIO
Definition Classes
Process0Syntax
Annotations
@deprecated
Deprecated
(Since version 0.7) liftIO is deprecated in favor of toSource. It will be removed in a future release.
def liftIO: Process[Task, O]
Implicit information
This member is added by an implicit conversion from Halt to Process0Syntax[O] performed by method Process0Syntax in scalaz.stream.Process.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(halt: Process0Syntax[O]).liftIO
Definition Classes
Process0Syntax
Annotations
@deprecated
Deprecated
(Since version 0.7) liftIO is deprecated in favor of toSource. It will be removed in a future release.

Inherited from Serializable

Inherited from Product

Inherited from Equals

Inherited from HaltOrStep[Nothing, Nothing]

Inherited from HaltEmitOrAwait[Nothing, Nothing]

Inherited from Process[Nothing, Nothing]

Inherited from TeeOps[Nothing, Nothing]

Inherited from Process1Ops[Nothing, Nothing]

Inherited from AnyRef

Inherited from Any

Inherited by implicit conversion SourceSyntax from Halt to SourceSyntax[O]

Inherited by implicit conversion toProcess1Syntax from Halt to Process1Syntax[Any, O]

Inherited by implicit conversion Process0Syntax from Halt to Process0Syntax[O]

Inherited by implicit conversion ProcessSyntax from Halt to ProcessSyntax[F, O]

Inherited by implicit conversion toChannelSyntax from Halt to ChannelSyntax[F, Any, O]

Inherited by implicit conversion EvalProcess from Halt to EvalProcess[F, O]

Inherited by implicit conversion toWyeSyntax from Halt to WyeSyntax[Any, Any, O]

Inherited by implicit conversion toWriterTaskSyntax from Halt to WriterTaskSyntax[W, O]

Inherited by implicit conversion toWriterSyntax from Halt to WriterSyntax[F, W, O]

Inherited by implicit conversion toTeeSyntax from Halt to TeeSyntax[Any, Any, O]

Inherited by implicit conversion toSinkTaskSyntax from Halt to SinkTaskSyntax[Any]

Inherited by implicit conversion toSinkSyntax from Halt to SinkSyntax[F, Any]

Inherited by implicit conversion SourceSyntax from Halt to SourceSyntax[O]

Inherited by implicit conversion Process0Syntax from Halt to Process0Syntax[O]

Inherited by implicit conversion EvalProcess from Halt to EvalProcess[F, O]

Inherited by implicit conversion ProcessSyntax from Halt to ProcessSyntax[F, O]

Inherited by implicit conversion toWyeSyntax from Halt to WyeSyntax[Any, Any, O]

Inherited by implicit conversion toWriterTaskSyntax from Halt to WriterTaskSyntax[W, O]

Inherited by implicit conversion toWriterSyntax from Halt to WriterSyntax[F, W, O]

Inherited by implicit conversion toTeeSyntax from Halt to TeeSyntax[Any, Any, O]

Inherited by implicit conversion toSinkTaskSyntax from Halt to SinkTaskSyntax[Any]

Inherited by implicit conversion toSinkSyntax from Halt to SinkSyntax[F, Any]

Inherited by implicit conversion toProcess1Syntax from Halt to Process1Syntax[Any, O]

Inherited by implicit conversion toChannelSyntax from Halt to ChannelSyntax[F, Any, O]

Related Doc: package Process

case class Halt(cause: Cause) extends HaltEmitOrAwait[Nothing, Nothing] with HaltOrStep[Nothing, Nothing] with Product with Serializable

Instance Constructors

new Halt(cause: Cause)

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

def +(other: String): String

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

def ->[B](y: B): (Halt, B)

final def ==(arg0: Any): Boolean

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

final def asFinalizer: Process[Nothing, Nothing]

final def asInstanceOf[T0]: T0

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

def awaitOption: Process[Nothing, Option[Nothing]]

def buffer(n: Int): Process[Nothing, Nothing]

def bufferAll: Process[Nothing, Nothing]

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

val cause: Cause

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

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

def chunkAll: Process[Nothing, Vector[Nothing]]

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

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

def clone(): AnyRef

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

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

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

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

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

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

final def drain: Process[Nothing, Nothing]

def drop(n: Int): Process[Nothing, Nothing]

def dropLast: Process[Nothing, Nothing]

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

def dropRight(n: Int): Process[Nothing, Nothing]

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

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

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

def ensuring(cond: (Halt) ⇒ Boolean, msg: ⇒ Any): Halt

def ensuring(cond: (Halt) ⇒ Boolean): Halt

def ensuring(cond: Boolean, msg: ⇒ Any): Halt

def ensuring(cond: Boolean): Halt

final def eq(arg0: AnyRef): Boolean

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

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

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

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

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

def finalize(): Unit

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

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

def flatMapO[F2[x] >: F[x], W2 >: W, B](f: (O) ⇒ Writer[F2, W2, B]): Writer[F2, W2, B]

def flatMapO[F2[x] >: F[x], W2 >: W, B](f: (O) ⇒ Writer[F2, W2, B]): Writer[F2, W2, B]

def flatMapW[F2[x] >: F[x], W2, O2 >: O](f: (W) ⇒ Writer[F2, W2, O2]): Writer[F2, W2, O2]

def flatMapW[F2[x] >: F[x], W2, O2 >: O](f: (W) ⇒ Writer[F2, W2, O2]): Writer[F2, W2, O2]

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

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

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

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

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

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

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

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

def formatted(fmtstr: String): String

def gather(bufSize: Int)(implicit F: Nondeterminism[F]): Process[F, O]

def gather(bufSize: Int)(implicit F: Nondeterminism[F]): Process[F, O]

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

final def getClass(): Class[_]

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

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

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

final def isHalt: Boolean

final def isInstanceOf[T0]: Boolean

final def kill: Process[Nothing, Nothing]

def last: Process[Nothing, Nothing]

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

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