scalaz.stream.Process

Halt

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

The Halt constructor instructs the driver that the last evaluation of Process completed with supplied cause.

Source
Process.scala
Linear Supertypes
Serializable, Serializable, Product, Equals, HaltOrStep[Nothing, Nothing], HaltEmitOrAwait[Nothing, Nothing], Process[Nothing, Nothing], TeeOps[Nothing, Nothing], Process1Ops[Nothing, Nothing], AnyRef, Any
Ordering
  1. Alphabetic
  2. By inheritance
Inherited
  1. Halt
  2. Serializable
  3. Serializable
  4. Product
  5. Equals
  6. HaltOrStep
  7. HaltEmitOrAwait
  8. Process
  9. TeeOps
  10. Process1Ops
  11. AnyRef
  12. Any
Implicitly
  1. by SourceSyntax
  2. by toProcess1Syntax
  3. by Process0Syntax
  4. by ProcessSyntax
  5. by toChannelSyntax
  6. by EvalProcess
  7. by toWyeSyntax
  8. by toWriterTaskSyntax
  9. by toWriterSyntax
  10. by toTeeSyntax
  11. by toSinkTaskSyntax
  12. by toSinkSyntax
  13. by SourceSyntax
  14. by Process0Syntax
  15. by EvalProcess
  16. by ProcessSyntax
  17. by toWyeSyntax
  18. by toWriterTaskSyntax
  19. by toWriterSyntax
  20. by toTeeSyntax
  21. by toSinkTaskSyntax
  22. by toSinkSyntax
  23. by toProcess1Syntax
  24. by toChannelSyntax
  25. by any2stringadd
  26. by any2stringfmt
  27. by any2ArrowAssoc
  28. by any2Ensuring
  1. Hide All
  2. Show all
Learn more about member selection
Visibility
  1. Public
  2. All

Instance Constructors

  1. new Halt(cause: Cause)

Value Members

  1. final def !=(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef

  2. final def !=(arg0: Any): Boolean

    Definition Classes
    Any

  3. final def ##(): Int

    Definition Classes
    AnyRef → Any

  4. def +(other: String): String

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

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

    Alias for append

    Alias for append

    Definition Classes
    Process

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

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

  7. final def ==(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef

  8. final def ==(arg0: Any): Boolean

    Definition Classes
    Any

  9. 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

  10. 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

  11. final def asInstanceOf[T0]: T0

    Definition Classes
    Any

  12. 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

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

    Alias for this |> process1.awaitOption.

    Alias for this |> process1.awaitOption.

    Definition Classes
    Process1Ops

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

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

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

    Definition Classes
    Process1Ops

  15. def bufferAll: Process[Nothing, Nothing]

    Alias for this |> process1.bufferAll.

    Alias for this |> process1.bufferAll.

    Definition Classes
    Process1Ops

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

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

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

    Definition Classes
    Process1Ops

  17. val cause: Cause

  18. 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

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

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

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

    Definition Classes
    Process1Ops

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

    Alias for this |> process1.chunkAll.

    Alias for this |> process1.chunkAll.

    Definition Classes
    Process1Ops

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

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

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

    Definition Classes
    Process1Ops

  22. 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

  23. def clone(): AnyRef

    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )

  24. 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

  25. 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

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

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

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

    Definition Classes
    Process1Ops

  27. 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

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

    Alias for this |> process1.distinctConsecutive.

    Alias for this |> process1.distinctConsecutive.

    Definition Classes
    Process1Ops

  29. 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

  30. final def drain: Process[Nothing, Nothing]

    Ignore all outputs of this Process.

    Ignore all outputs of this Process.

    Definition Classes
    Process

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

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

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

    Definition Classes
    Process1Ops

  32. def dropLast: Process[Nothing, Nothing]

    Alias for this |> process1.dropLast.

    Alias for this |> process1.dropLast.

    Definition Classes
    Process1Ops

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

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

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

    Definition Classes
    Process1Ops

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

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

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

    Definition Classes
    Process1Ops

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

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

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

    Definition Classes
    Process1Ops

  36. 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

  37. 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

  38. 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 any2Ensuring in scala.Predef.
    Definition Classes
    Ensuring

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

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

  40. 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 any2Ensuring in scala.Predef.
    Definition Classes
    Ensuring

  41. def ensuring(cond: Boolean): Halt

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

  42. final def eq(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef

  43. 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

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

    Alias for this |> process1.exists(f)

    Alias for this |> process1.exists(f)

    Definition Classes
    Process1Ops

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

    Alias for append

    Alias for append

    Definition Classes
    Process

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

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

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

    Definition Classes
    Process1Ops

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

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

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

    Definition Classes
    Process1Ops

  48. def finalize(): Unit

    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )

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

    Alias for this |> process1.find(f)

    Alias for this |> process1.find(f)

    Definition Classes
    Process1Ops

  50. 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

  51. 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

  52. 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

  53. 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

  54. 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

  55. 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

  56. 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

  57. 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

  58. 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

  59. 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

  60. 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

  61. 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

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

    Alias for this |> process1.forall(f)

    Alias for this |> process1.forall(f)

    Definition Classes
    Process1Ops

  63. def formatted(fmtstr: String): String

    Implicit information
    This member is added by an implicit conversion from Halt to StringFormat performed by method any2stringfmt in scala.Predef.
    Definition Classes
    StringFormat
    Annotations
    @inline()

  64. 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

  65. 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

  66. 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

  67. final def getClass(): Class[_]

    Definition Classes
    AnyRef → Any

  68. 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

  69. 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

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

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

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

    Definition Classes
    Process1Ops

  71. final def isHalt: Boolean

    Returns true, if this process is halted

    Returns true, if this process is halted

    Definition Classes
    Process

  72. final def isInstanceOf[T0]: Boolean

    Definition Classes
    Any

  73. 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

  74. def last: Process[Nothing, Nothing]

    Alias for this |> process1.last.

    Alias for this |> process1.last.

    Definition Classes
    Process1Ops

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

    Alias for this |> process1.last.

    Alias for this |> process1.last.

    Definition Classes
    Process1Ops

  76. 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

  77. 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

  78. 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

  79. 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

  80. 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

  81. 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

  82. 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

  83. 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

  84. def maximum[O2 >: Nothing](implicit O2: Order[O2]): Process[Nothing, O2]

    Alias for this |> process1.maximum.

    Alias for this |> process1.maximum.

    Definition Classes
    Process1Ops

  85. 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

  86. 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

  87. 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

  88. 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

  89. def minimum[O2 >: Nothing](implicit O2: Order[O2]): Process[Nothing, O2]

    Alias for this |> process1.minimum.

    Alias for this |> process1.minimum.

    Definition Classes
    Process1Ops

  90. 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

  91. 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

  92. final def ne(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef

  93. final def notify(): Unit

    Definition Classes
    AnyRef

  94. final def notifyAll(): Unit

    Definition Classes
    AnyRef

  95. 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

  96. 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

  97. 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

  98. 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

  99. 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

  100. 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

  101. 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

  102. 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

  103. 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

  104. 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

  105. 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

  106. 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

  107. 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

  108. 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

  109. 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

  110. 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

  111. def once: Process[Nothing, Nothing]

    Alias for this |> Process.await1.

    Alias for this |> Process.await1.

    Definition Classes
    Process1Ops

  112. 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

  113. 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

  114. 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

  115. 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

  116. 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

  117. 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

  118. def prefixSums[O2 >: Nothing](implicit N: Numeric[O2]): Process[Nothing, O2]

    Alias for this |> process1.prefixSums

    Alias for this |> process1.prefixSums

    Definition Classes
    Process1Ops

  119. 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

  120. 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

  121. 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

  122. 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

  123. 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

  124. 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

  125. 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

  126. 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

  127. 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

  128. 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

  129. 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

  130. 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

  131. 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

  132. 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

  133. 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

  134. 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

  135. 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

  136. 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

  137. 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

  138. 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

  139. 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

  140. 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

  141. def shiftRight[O2 >: Nothing](head: O2*): Process[Nothing, O2]

    Alias for this |> process1.shiftRight(head)

    Alias for this |> process1.shiftRight(head)

    Definition Classes
    Process1Ops

  142. 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

  143. def sliding(n: Int): Process[Nothing, Vector[Nothing]]

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

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

    Definition Classes
    Process1Ops

  144. def split(f: (Nothing) ⇒ Boolean): Process[Nothing, Vector[Nothing]]

    Alias for this |> process1.split(f)

    Alias for this |> process1.split(f)

    Definition Classes
    Process1Ops

  145. 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

  146. def splitWith(f: (Nothing) ⇒ Boolean): Process[Nothing, Vector[Nothing]]

    Alias for this |> process1.splitWith(f)

    Alias for this |> process1.splitWith(f)

    Definition Classes
    Process1Ops

  147. 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

  148. 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

  149. def sum[O2 >: Nothing](implicit N: Numeric[O2]): Process[Nothing, O2]

    Alias for this |> process1.sum

    Alias for this |> process1.sum

    Definition Classes
    Process1Ops

  150. final def suspendStep: Process0[HaltOrStep[Nothing, Nothing]]

    p.suspendStep propagates exceptions to p.

    p.suspendStep propagates exceptions to p.

    Definition Classes
    Process

  151. 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

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

    Definition Classes
    AnyRef

  153. def tail: Process[Nothing, Nothing]

    Alias for this |> process1.tail.

    Alias for this |> process1.tail.

    Definition Classes
    Process1Ops

  154. def take(n: Int): Process[Nothing, Nothing]

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

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

    Definition Classes
    Process1Ops

  155. def takeRight(n: Int): Process[Nothing, Nothing]

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

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

    Definition Classes
    Process1Ops

  156. def takeThrough(f: (Nothing) ⇒ Boolean): Process[Nothing, Nothing]

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

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

    Definition Classes
    Process1Ops

  157. def takeWhile(f: (Nothing) ⇒ Boolean): Process[Nothing, Nothing]

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

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

    Definition Classes
    Process1Ops

  158. 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

  159. def terminated: Process[Nothing, Option[Nothing]]

    Alias for this |> process1.terminated.

    Alias for this |> process1.terminated.

    Definition Classes
    Process1Ops

  160. 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

  161. 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

  162. 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

  163. 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

  164. 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

  165. 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

  166. 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

  167. 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

  168. 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

  169. 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

  170. 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

  171. 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

  172. 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

  173. 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

  174. 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

  175. 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

  176. 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

  177. 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()

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

    Definition Classes
    Process

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

    Definition Classes
    Process

  180. 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

  181. 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

  182. final def wait(): Unit

    Definition Classes
    AnyRef
    Annotations
    @throws( ... )

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

    Definition Classes
    AnyRef
    Annotations
    @throws( ... )

  184. final def wait(arg0: Long): Unit

    Definition Classes
    AnyRef
    Annotations
    @throws( ... )

  185. 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

  186. 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

  187. 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

  188. 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

  189. 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

  190. 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

  191. 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

  192. 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

  193. def zipWithIndex: Process[Nothing, (Nothing, Int)]

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

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

    Definition Classes
    Process1Ops

  194. def zipWithNext: Process[Nothing, (Nothing, Option[Nothing])]

    Alias for this |> process1.zipWithNext.

    Alias for this |> process1.zipWithNext.

    Definition Classes
    Process1Ops

  195. def zipWithPrevious: Process[Nothing, (Option[Nothing], Nothing)]

    Alias for this |> process1.zipWithPrevious.

    Alias for this |> process1.zipWithPrevious.

    Definition Classes
    Process1Ops

  196. def zipWithPreviousAndNext: Process[Nothing, (Option[Nothing], Nothing, Option[Nothing])]

    Alias for this |> process1.zipWithPreviousAndNext.

    Alias for this |> process1.zipWithPreviousAndNext.

    Definition Classes
    Process1Ops

  197. 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

  198. 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

  199. 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

  200. final def |>[O2](p2: Process1[Nothing, O2]): Process[Nothing, O2]

    Operator alias for pipe.

    Operator alias for pipe.

    Definition Classes
    Process

  201. def →[B](y: B): (Halt, B)

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

Shadowed Implicit Value Members

  1. 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

  2. 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

  3. 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

  4. 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

  5. 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

  6. 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

  7. 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

  8. 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

  9. 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

  10. 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

  11. 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

  12. 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

  13. 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

  14. 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

  15. 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

  16. 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

  17. 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

  18. 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

  19. 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

  20. 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

  21. 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

  22. 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

  23. 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

  24. 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

  25. 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

  26. 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

  27. 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

  28. 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

  29. 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

  30. 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

  31. 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

  32. 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

  33. 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

  34. 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

  35. 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

  36. 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

  37. 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

  38. 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

  39. 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

  40. 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

  41. 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

  42. 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

  43. 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

  44. 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

  45. 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

  46. 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

  47. 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

  48. 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

  49. 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

  50. 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

  51. 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

  52. 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

  53. 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

  54. 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

  55. 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

  56. 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

  57. 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

  58. 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

  59. 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

  60. 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

  61. 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

  62. 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

  63. 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

  64. 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

  65. val self: Any

    Implicit information
    This member is added by an implicit conversion from Halt to StringAdd performed by method any2stringadd in scala.Predef.
    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: StringAdd).self
    Definition Classes
    StringAdd

  66. val self: Any

    Implicit information
    This member is added by an implicit conversion from Halt to StringFormat performed by method any2stringfmt in scala.Predef.
    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: StringFormat).self
    Definition Classes
    StringFormat

  67. 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

  68. 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

  69. 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

  70. 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

  71. 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

  72. 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

  73. 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

  74. 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

  75. 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

  76. 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

  77. 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

  78. 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

  79. 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

  80. 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

  81. 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

  82. 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

  83. 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

  84. 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

  85. 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

  86. 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

  1. 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.

  2. 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.

  3. def x: Halt

    Implicit information
    This member is added by an implicit conversion from Halt to ArrowAssoc[Halt] performed by method any2ArrowAssoc in scala.Predef.
    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: ArrowAssoc[Halt]).x
    Definition Classes
    ArrowAssoc
    Annotations
    @deprecated
    Deprecated

    (Since version 2.10.0) Use leftOfArrow instead

  4. def x: Halt

    Implicit information
    This member is added by an implicit conversion from Halt to Ensuring[Halt] performed by method any2Ensuring in scala.Predef.
    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: Ensuring[Halt]).x
    Definition Classes
    Ensuring
    Annotations
    @deprecated
    Deprecated

    (Since version 2.10.0) Use resultOfEnsuring instead

Inherited from Serializable

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]

Inherited by implicit conversion any2stringadd from Halt to StringAdd

Inherited by implicit conversion any2stringfmt from Halt to StringFormat

Inherited by implicit conversion any2ArrowAssoc from Halt to ArrowAssoc[Halt]

Inherited by implicit conversion any2Ensuring from Halt to Ensuring[Halt]

Ungrouped